Learning-Sympy/Docs/Lists/Python-Lists.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lists in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Core"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The python core libraries are expanded upon by both `sympy` and `numpy`.\n",
    "\n",
    "- Python only has lists and Tupples\n",
    "- Sympy introduces Matrices\n",
    "- Numpy introduces Arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lists and Tupples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lists in python are an ordered collection of objects (that may or may not be repeated). A tupple is a list that is immutable, much like a constant value.\n",
    "\n",
    "The terminology across languages is inconsistent and very confusing (It appears that terminology within ***R*** and *Julia* is more appropriate in a mathematical context), refer to this comparison table for clarification:\n",
    "\n",
    "|               | **Order** | **Repetition** | **Many Data Type** | **Mutable?** |\n",
    "| ---           | ---       | ---            | ---                | ---          |\n",
    "| Python-List   | Yes       | Yes            | Yes                | Yes          |\n",
    "| Python-Tupple | Yes       | Yes            | Yes                | No           |\n",
    "| Sympy-Matrix  | Yes       | Yes            | Numeric/Symbolic   | Yes          |\n",
    "| Python-Array  | Yes       | Yes            | One Type of Data   | Yes          |\n",
    "| NumPy-Array   | Yes       | Yes            | Numeric            | Yes          |\n",
    "| R-Vector      | Yes       | Yes            | One Type of Data   | Yes          |\n",
    "| R-List        | Yes       | Yes            | Yes                | Yes          |\n",
    "| Julia-List    | Yes       | Yes            | Yes                | Yes          |\n",
    "| Julia-Tupple  | Yes       | Yes            | Numeric            | No           |\n",
    "| Math Vector   | Yes       | Yes            | Numeric            | No           |\n",
    "| Math Set      | No        | No             | Yes                | Yes          |\n",
    "| Math Matrix   | Yes       | Yes            | Numeric            | Yes          |\n",
    "\n",
    "\n",
    "Another really frustrating thing in python is that matrices are typed transversely, for example, in ***R*** and *Julia* vectors are treated similarly to 1-dimensional vertical matrices, this means to enter a matrix in ***R*** and *Python* would be different:\n",
    "\n",
    "```python\n",
    "M = Array([[11, 12, 13],\n",
    "           [21, 22, 23],\n",
    "           [31, 32, 33]])\n",
    "from sympy import *\n",
    "M = Matrix([[11, 12, 13],\n",
    "            [21, 22, 23],\n",
    "            [31, 32, 33]])\n",
    "import numpy as NumPy\n",
    "M = np.array([[11, 12, 13],\n",
    "              [21, 22, 23],\n",
    "              [31, 32, 33]])\n",
    "```\n",
    "\n",
    "```r\n",
    "M = matrix(c(11, 21, 31), c(12, 22, 32), c(13, 23, 33))\n",
    "\n",
    "## This is easier\n",
    "\n",
    "M = rbind(\n",
    "    c(11, 12, 13),\n",
    "    c(21, 22, 23),\n",
    "    c(31, 32, 33)\n",
    ")\n",
    "```\n",
    "\n",
    "\n",
    "$\\begin{aligned}\n",
    "M = \\begin{bmatrix}\n",
    "    x_{11} & x_{12} & x_{13} \\\\\n",
    "    x_{21} & x_{22} & x_{23} \\\\\n",
    "    x_{31} & x_{32} & x_{33} \n",
    "\\end{bmatrix}\\end{aligned}$\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "['apple', 9, x, 9, 9, 7, 9]\n"
    }
   ],
   "source": [
    "y = 9\n",
    "mylist = [\"apple\", 9, x, y, 9, 7, 9]\n",
    "print(mylist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mapping Functions over Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In *Python* recursive functions are often slower because of the overhead of a function call [CITE], moreover any process that can be expressed with a loop can be expressed via recursion and vice versa, hence recursive functions should be avoided unless necessary to conceptually demonstrate the proces."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mapping functions over lists however will always lead to better performance and should be used, for example consider the two processes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]\n"
    }
   ],
   "source": [
    "## This is bad, ALWAYS use a static vector not a dynamic one on a`for` loop,\n",
    "#  this is for demonstration.\n",
    "values = []  \n",
    "for i in range(10):\n",
    "    values.append(i**2)\n",
    "print(values)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]\n"
    }
   ],
   "source": [
    "squares = list(map((lambda x: x**2), range(10)))\n",
    "print(squares)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### List Comprehension"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Of course however, this example is so common there is a syntax known as *List Comprehension* just for it, don't recreate that:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "[0, 1, 8, 27, 64, 125, 216, 343, 512, 729]\n"
    }
   ],
   "source": [
    "cubes = [i**3 for i in range(10)]\n",
    "print(cubes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sympy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sympy is concered with symbolic algebra, it is required to solve equations et cetera.\n",
    "\n",
    "It offers the luxury of printing with LaTeX, MathJax or nice ascii-art."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Loading Sympy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from __future__ import division\n",
    "from sympy import *\n",
    "x, y, z, t = symbols('x y z t')\n",
    "k, m, n = symbols('k m n', integer=True)\n",
    "f, g, h = symbols('f g h', cls=Function)\n",
    "init_printing()\n",
    "init_printing(use_latex='mathjax', latex_mode='equation')\n",
    "\n",
    "\n",
    "import pyperclip\n",
    "def lx(expr):\n",
    "    pyperclip.copy(latex(expr))\n",
    "    print(expr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Matrices are mutable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "⎡11  12  13  14⎤\n⎢              ⎥\n⎣21  22  23  24⎦",
      "text/latex": "\\begin{equation}\\left[\\begin{matrix}11 & 12 & 13 & 14\\\\21 & 22 & 23 & 24\\end{matrix}\\right]\\end{equation}"
     },
     "metadata": {},
     "execution_count": 42
    }
   ],
   "source": [
    "Array([[11,12,13,14], [21,22,23,24]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Syntax"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Matrices are built in sympy with the following syntax [^symMat]\n",
    "\n",
    "[^symMat]: [Matrices — SymPy 1.6.1 documentation](https://docs.sympy.org/latest/tutorial/matrices.html)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "⎡11  12  13⎤\n⎢          ⎥\n⎢21  22  23⎥\n⎢          ⎥\n⎣31  32  33⎦",
      "text/latex": "\\begin{equation}\\left[\\begin{matrix}11 & 12 & 13\\\\21 & 22 & 23\\\\31 & 32 & 33\\end{matrix}\\right]\\end{equation}"
     },
     "metadata": {},
     "execution_count": 7
    }
   ],
   "source": [
    "mat = Matrix([[11, 12, 13], [21, 22, 23], [31, 32, 33]])\n",
    "mat\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Numpy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numpy is concerned with numerical computation, it is the best for raw performance [^symPerf]. This performance improvement can be seen by comparing [Matrix-Determinant](Matrix-Determinant.ipynb) with one done in `numpy`: [Matrix-Determinant-Numpy](Matrix-Determinant-Numpy.ipynb)\n",
    "\n",
    "[^symPerf]: [Python Lists vs. Numpy Arrays - What is the difference?: IST Advanced Topics Primer](https://webcourses.ucf.edu/courses/1249560/pages/python-lists-vs-numpy-arrays-what-is-the-difference#:~:text=Numpy%20is%20the%20core%20library%20for%20scientific%20computing%20in%20Python.&text=A%20numpy%20array%20is%20a,the%20array%20along%20each%20dimension.)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Matrices"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Syntax"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Matrices in Numpy are declared with the following syntax [^npsynmat]\n",
    "\n",
    "[^npsynmat]: [Quickstart tutorial — NumPy v1.19 Manual](https://numpy.org/doc/stable/user/quickstart.html)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "array([[1, 2, 3],\n       [4, 5, 6],\n       [7, 8, 9]])"
     },
     "metadata": {},
     "execution_count": 28
    }
   ],
   "source": [
    "import numpy as np\n",
    "np.array([[1,2,3], [4, 5, 6], [7, 8, 9]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "5"
     },
     "metadata": {},
     "execution_count": 41
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "## return M_2,2=5    (beware OBOB)\n",
    "i = 2; j = 2\n",
    "i -= 1; j -= 1\n",
    "np.array([[1,2,3], [4, 5, 6], [7, 8, 9]])[i, j]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pandas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pandas are essentially just data frames:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "Matrix.Size  Determinant.Value\n0           45               2025\n1           46               2116\n2           47               2209\n3           48               2304\n4           49               2401\n"
    }
   ],
   "source": [
    "\n",
    "import pandas as pd\n",
    "data = {'Matrix.Size': range(45, 50),\n",
    "        'Determinant.Value': list(map((lambda x: x**2), range(45, 50)))\n",
    "}\n",
    "df = pd.DataFrame(data, columns = ['Matrix.Size', 'Determinant.Value'])\n",
    "print(df)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Convert a panda into a list\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is necessary when performing Linear Regression with Python\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "[[2*log(45)]\n [2*log(46)]\n [2*log(47)]\n [2*log(48)]\n [4*log(7)]]\n"
    }
   ],
   "source": [
    "\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "from sympy import *\n",
    "\n",
    "data = {'Matrix.Size': range(45, 50),\n",
    "        'Determinant.Value': list(map((lambda x: x**2), range(45, 50)))\n",
    "}\n",
    "df = pd.DataFrame(data, columns = ['Matrix.Size', 'Determinant.Value'])\n",
    "df['Determinant.Value'] = [ log(val).expand(force = True) for val in df['Determinant.Value']]\n",
    "df\n",
    "from sklearn.linear_model import LinearRegression\n",
    "\n",
    "\n",
    "X = df.iloc[:, 0].values.reshape(-1, 1)  # values converts it into a numpy array\n",
    "Y = df.iloc[:, 1].values.reshape(-1, 1)  # -1 means that calculate the dimension of rows, but have 1 column\n",
    "\n",
    "print(Y)"
   ]
  }
 ],
 "nbformat": 4,
 "nbformat_minor": 5,
 "metadata": {
  "kernelspec": {
   "name": "python38364bitb58c1e4a530841da8c36eeef2b5a935c",
   "display_name": "Python 3.8.3 64-bit"
  }
 }
}