Lecture2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this lecture we'll talk about modules (not the ones you write by yourself for now) and discuss some common use examples.\n",
    "\n",
    "General remarks:\n",
    "\n",
    "**never do `from numpy import *`**\n",
    "\n",
    "**never do `%pylab`**\n",
    "\n",
    "This can only be done when you really need to save screen space and typing time (so this can be done in your other lectures, but never in real life). This is like `using namespace std` in `c++`, if not worse.\n",
    "\n",
    "The word \"import\" allows the use of functions from some package/module in your code. There are very very many packages in python, most you can install with conda/pip.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's start with importing some fun:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Zen of Python, by Tim Peters\n",
      "\n",
      "Beautiful is better than ugly.\n",
      "Explicit is better than implicit.\n",
      "Simple is better than complex.\n",
      "Complex is better than complicated.\n",
      "Flat is better than nested.\n",
      "Sparse is better than dense.\n",
      "Readability counts.\n",
      "Special cases aren't special enough to break the rules.\n",
      "Although practicality beats purity.\n",
      "Errors should never pass silently.\n",
      "Unless explicitly silenced.\n",
      "In the face of ambiguity, refuse the temptation to guess.\n",
      "There should be one-- and preferably only one --obvious way to do it.\n",
      "Although that way may not be obvious at first unless you're Dutch.\n",
      "Now is better than never.\n",
      "Although never is often better than *right* now.\n",
      "If the implementation is hard to explain, it's a bad idea.\n",
      "If the implementation is easy to explain, it may be a good idea.\n",
      "Namespaces are one honking great idea -- let's do more of those!\n"
     ]
    }
   ],
   "source": [
    "import this"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Standard Library**\n",
    "\n",
    "[the whole library docs](https://docs.python.org/3/library/)\n",
    "\n",
    "[math module docs](https://docs.python.org/3/library/math.html)\n",
    "\n",
    "[itertools docs](https://docs.python.org/3/library/itertools.html?highlight=itertools#module-itertools)\n",
    "\n",
    "Standard library is something that you don't have to specificaly install."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.sin(math.pi/2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.4142135623730951"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.sqrt(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import itertools as it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "permut = it.permutations([1,2,3])\n",
    "comb = it.combinations([1,2,3,4,5],3) \n",
    "pr = it.product([1,2,3],[2,3,4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3) (1, 3, 2) (2, 1, 3) (2, 3, 1) (3, 1, 2) (3, 2, 1)\n"
     ]
    }
   ],
   "source": [
    "print(*permut)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "itertools.permutations"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(permut)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3) (1, 2, 4) (1, 2, 5) (1, 3, 4) (1, 3, 5) (1, 4, 5) (2, 3, 4) (2, 3, 5) (2, 4, 5) (3, 4, 5)\n"
     ]
    }
   ],
   "source": [
    "print(*comb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2) (1, 3) (1, 4) (2, 2) (2, 3) (2, 4) (3, 2) (3, 3) (3, 4)\n"
     ]
    }
   ],
   "source": [
    "print(*pr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **SymPy**\n",
    "\n",
    "Let's look at something that is actually nice in python, even if it's a bit unrelated to the other material - symbolic calculation package. You can use it if you don't want to learn mathematica or don't have the license for that. \n",
    "\n",
    "do `conda install sympy` in your conda environment before proceeding."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sympy as sp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "https://docs.sympy.org/latest/tutorials/intro-tutorial/index.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's great even without the symbols:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.8284271247461903\n",
      "2*sqrt(2)\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 2 \\sqrt{2}$"
      ],
      "text/plain": [
       "2*sqrt(2)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import math\n",
    "print(math.sqrt(8))\n",
    "print(sp.sqrt(8))\n",
    "sp.sqrt(8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "for jupyter nice output, you can dosp.init_printing(use_unicode=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "sp.init_printing(use_unicode=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2*sqrt(2)\n"
     ]
    }
   ],
   "source": [
    "sp.sqrt(8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's look at symbols:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "x, y = sp.symbols('x y')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x*(x**2 + y**2)\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle x^{3} + x y^{2}$"
      ],
      "text/plain": [
       " 3      2\n",
       "x  + x⋅y "
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z=x**2+y**2\n",
    "print(x*z)\n",
    "(x*z).expand()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "symbols and variable names, technically, don't have to be the same, but it can be way too confusing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2*hi\n"
     ]
    }
   ],
   "source": [
    "dontdothis = sp.symbols('hi')\n",
    "print(dontdothis*2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Integrals:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\int \\frac{1}{x}\\, dx$"
      ],
      "text/plain": [
       "⌠     \n",
       "⎮ 1   \n",
       "⎮ ─ dx\n",
       "⎮ x   \n",
       "⌡     "
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sp.Integral(1/x,x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\sqrt{2} \\sqrt{\\pi}}{2}$"
      ],
      "text/plain": [
       "√2⋅√π\n",
       "─────\n",
       "  2  "
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sp.integrate(sp.sin(x**2), (x, -sp.oo, sp.oo)) # double o is infinity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\infty$"
      ],
      "text/plain": [
       "∞"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sp.oo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle x^{3} + x y^{2}$"
      ],
      "text/plain": [
       " 3      2\n",
       "x  + x⋅y "
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sp.expand(x*z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(x + 1\\right)^{2}$"
      ],
      "text/plain": [
       "       2\n",
       "(x + 1) "
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sp.factor(x**2+2*x+1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(x + 1\\right)^{3}$"
      ],
      "text/plain": [
       "       3\n",
       "(x + 1) "
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sp.factor(x**3+3*x*x+3*x+1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle x^{3} + x^{2} \\left(- x^{2} - y^{2} + 2\\right) + x \\left(y + 1\\right) - 3$"
      ],
      "text/plain": [
       " 3    2 ⎛   2    2    ⎞                \n",
       "x  + x ⋅⎝- x  - y  + 2⎠ + x⋅(y + 1) - 3"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sp.collect(x*y + x - 3 + 2*x**2 - z*x**2 + x**3,x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{x^{4} + 2 x^{2} y^{2} - 2 x^{2} y + y^{4} - 2 y^{3} + y^{2}}{x - 1}$"
      ],
      "text/plain": [
       " 4      2  2      2      4      3    2\n",
       "x  + 2⋅x ⋅y  - 2⋅x ⋅y + y  - 2⋅y  + y \n",
       "──────────────────────────────────────\n",
       "                x - 1                 "
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sp.cancel((x*y**2 - 2*x*y*z + x*z**2 + y**2 - 2*y*z + z**2)/(x**2 - 1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Taylor expansion:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\sin{\\left(h \\right)} + \\left(- h + x\\right) \\cos{\\left(h \\right)} - \\frac{\\left(- h + x\\right)^{2} \\sin{\\left(h \\right)}}{2} - \\frac{\\left(- h + x\\right)^{3} \\cos{\\left(h \\right)}}{6} + \\frac{\\left(- h + x\\right)^{4} \\sin{\\left(h \\right)}}{24} + O\\left(\\left(- h + x\\right)^{5}; x\\rightarrow h\\right)$"
      ],
      "text/plain": [
       "                                   2                  3                  4    \n",
       "                           (-h + x) ⋅sin(h)   (-h + x) ⋅cos(h)   (-h + x) ⋅sin\n",
       "sin(h) + (-h + x)⋅cos(h) - ──────────────── - ──────────────── + ─────────────\n",
       "                                  2                  6                  24    \n",
       "\n",
       "                         \n",
       "(h)    ⎛        5       ⎞\n",
       "─── + O⎝(-h + x) ; x → h⎠\n",
       "                         "
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "h = sp.symbols('h')\n",
    "sp.sin(x).series(x, x0=h, n=5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle x - \\frac{x^{3}}{6} + O\\left(x^{5}\\right)$"
      ],
      "text/plain": [
       "     3        \n",
       "    x     ⎛ 5⎞\n",
       "x - ── + O⎝x ⎠\n",
       "    6         "
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sp.sin(x).series(x, x0=0, n=5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Simplification of expressions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(2 x + 1\\right) \\sin{\\left(x \\right)}$"
      ],
      "text/plain": [
       "(2⋅x + 1)⋅sin(x)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr=sp.simplify(x*sp.sin(x)*(1/x+2))\n",
    "expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 1$"
      ],
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sp.simplify(sp.sin(x)**2 + sp.cos(x)**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\cos{\\left(4 x \\right)}}{2} + \\frac{1}{2}$"
      ],
      "text/plain": [
       "cos(4⋅x)   1\n",
       "──────── + ─\n",
       "   2       2"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sp.simplify(sp.sin(x)**4 - 2*sp.cos(x)**2*sp.sin(x)**2 + sp.cos(x)**4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Derivatives:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(2 x + 1\\right) \\cos{\\left(x \\right)} + 2 \\sin{\\left(x \\right)}$"
      ],
      "text/plain": [
       "(2⋅x + 1)⋅cos(x) + 2⋅sin(x)"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sp.diff(expr, x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Solving equations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[ - \\sqrt{2}, \\  \\sqrt{2}\\right]$"
      ],
      "text/plain": [
       "[-√2, √2]"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sp.solve(x**2 - 2, x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Solving differential equations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle y{\\left(t \\right)} = C_{2} e^{- t} + \\left(C_{1} + \\frac{t}{2}\\right) e^{t}$"
      ],
      "text/plain": [
       "           -t   ⎛     t⎞  t\n",
       "y(t) = C₂⋅ℯ   + ⎜C₁ + ─⎟⋅ℯ \n",
       "                ⎝     2⎠   "
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = sp.Function('y')\n",
    "t=sp.symbols('t')\n",
    "sp.dsolve(sp.Eq(y(t).diff(t, t) - y(t), sp.exp(t)), y(t))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Evaluating the expressions:\n",
    "be very careful with trying to change values of what you set as symbols. Python won't complain, but the result might be surprising"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x + 1\n",
      "x\n",
      "x + 1\n"
     ]
    }
   ],
   "source": [
    "x = sp.symbols('x')\n",
    "expr = x + 1\n",
    "print(expr)\n",
    "#x = 1 #uncomment this to get nonsence int he next line\n",
    "print(x)\n",
    "print(expr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 8$"
      ],
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr.subs(x,7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 40$"
      ],
      "text/plain": [
       "40"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x,y,z= sp.symbols('x y z')\n",
    "expr = x**3 + 4*x*y - z\n",
    "expr.subs([(x, 2), (y, 4), (z, 0)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also create expressions from strings:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle x^{3} + 7 x - \\frac{3}{22}$"
      ],
      "text/plain": [
       " 3         3 \n",
       "x  + 7⋅x - ──\n",
       "           22"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str_expr = \"x**3 + 7*x - 3/22\"\n",
    "expr = sp.sympify(str_expr)\n",
    "expr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Numpy**\n",
    "\n",
    "`conda install numpy`\n",
    "\n",
    "From the docs:\n",
    "\n",
    "NumPy is the fundamental package for scientific computing in Python. It is a Python library that provides a multidimensional array object, various derived objects (such as masked arrays and matrices), and an assortment of routines for fast operations on arrays, including mathematical, logical, shape manipulation, sorting, selecting, I/O, discrete Fourier transforms, basic linear algebra, basic statistical operations, random simulation and much more.\n",
    "\n",
    "[documentation](https://numpy.org/doc/stable/user/whatisnumpy.html)\n",
    "\n",
    "\n",
    "Numpy is mostly used for: \n",
    "\n",
    "    - manipulating arrays\n",
    "    - dealing with linear and matrix algebra\n",
    "    - basic data processing\n",
    "\n",
    "\n",
    "It's usually imported as \"np\". "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's start with the different ways of arrays creations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5]\n",
      "<class 'numpy.ndarray'>\n",
      "<class 'numpy.int32'>\n"
     ]
    }
   ],
   "source": [
    "arr1 = np.array([1,2,3,4,5],dtype=np.int32)                    # From a list (works with list comprehensions too)\n",
    "print(arr1)             \n",
    "print(type(arr1))\n",
    "print(type(arr1[0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]]\n"
     ]
    }
   ],
   "source": [
    "arr2 = np.array([[1,2],[3,4]])\n",
    "print(arr2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can create an array with zeros, ones, or leave it uninitialized"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 0 0 0]\n",
      " [0 0 0 0]\n",
      " [0 0 0 0]]\n",
      "[[1. 1. 1. 1.]\n",
      " [1. 1. 1. 1.]\n",
      " [1. 1. 1. 1.]]\n",
      "[0.00000000e+000 0.00000000e+000 0.00000000e+000 0.00000000e+000\n",
      " 0.00000000e+000 2.48819961e+180 1.38053330e-047 6.19656092e-091\n",
      " 5.19416176e+170 8.07184967e-315]\n"
     ]
    }
   ],
   "source": [
    "arr3 = np.zeros((3,4), dtype='int')            \n",
    "arr4 = np.ones((3,4), dtype='float')\n",
    "arr5=np.empty(10)\n",
    "print(arr3)\n",
    "print(arr4)\n",
    "print(arr5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[7.77 7.77 7.77 7.77 7.77]\n",
      " [7.77 7.77 7.77 7.77 7.77]\n",
      " [7.77 7.77 7.77 7.77 7.77]]\n",
      "[ 1 18 35 52 69 86]\n",
      "[0.         0.03846154 0.07692308 0.11538462 0.15384615 0.19230769\n",
      " 0.23076923 0.26923077 0.30769231 0.34615385 0.38461538 0.42307692\n",
      " 0.46153846 0.5        0.53846154 0.57692308 0.61538462 0.65384615\n",
      " 0.69230769 0.73076923 0.76923077 0.80769231 0.84615385 0.88461538\n",
      " 0.92307692 0.96153846 1.        ]\n",
      "[[1. 0. 0.]\n",
      " [0. 1. 0.]\n",
      " [0. 0. 1.]]\n"
     ]
    }
   ],
   "source": [
    "arr6 = np.full((3,5), 7.77)       # fill in the array with 1 number\n",
    "arr7 = np.arange(1,100,17)        # just like \"range\"\n",
    "arr8 = np.linspace(0,1,27)        # 27 values linearly spaced from 0 to 1\n",
    "arr9 = np.eye(3)      #identity\n",
    "print(arr6)\n",
    "print(arr7)\n",
    "print(arr8)\n",
    "print(arr9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you work specifically in 2D, you can use \"matrix\":"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]]\n"
     ]
    }
   ],
   "source": [
    "a = np.matrix('1 2; 3 4')\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.matrix'>\n"
     ]
    }
   ],
   "source": [
    "print(type(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 1. 1. 1. 1.]\n",
      " [1. 1. 1. 1. 1.]\n",
      " [1. 1. 1. 1. 1.]]\n"
     ]
    }
   ],
   "source": [
    "arr10=np.ones_like(arr6)\n",
    "print(arr10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also create random arrays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.37259006e-01 6.60153961e-01 4.50001303e-01 6.28616543e-01\n",
      "  8.14627247e-02]\n",
      " [3.47743630e-01 6.52301378e-01 4.38304775e-02 7.78115385e-01\n",
      "  5.87380624e-05]\n",
      " [9.03662471e-01 8.45817382e-01 7.91133789e-02 1.96155919e-01\n",
      "  9.72687338e-01]]\n",
      "[[-0.87493956 -0.05526955  5.74381664 -4.83999988]\n",
      " [ 4.21702567  6.05073341 -2.84561281  6.7661492 ]\n",
      " [ 0.97316475  1.55258787 -4.9097746  -7.00035094]]\n"
     ]
    }
   ],
   "source": [
    "arr11 = np.random.random((3,5))    # 3x5 Random numbers matrix with entries between 0-1\n",
    "arr12 = np.random.normal(0,5,(3,4))  # 3x4 Random numbers normal distributed with mean 0 and standard dev 5\n",
    "print(arr11)\n",
    "print(arr12)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Element-wise calculations:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 2.  4.  6.  8. 10. 12. 14. 16. 18. 20.]\n",
      "[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
      "[  1.   4.   9.  16.  25.  36.  49.  64.  81. 100.]\n",
      "[1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]\n",
      "[1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]\n",
      "[1.00000000e+00 4.00000000e+00 2.70000000e+01 2.56000000e+02\n",
      " 3.12500000e+03 4.66560000e+04 8.23543000e+05 1.67772160e+07\n",
      " 3.87420489e+08 1.00000000e+10]\n",
      "[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n"
     ]
    }
   ],
   "source": [
    "#standard math operations:\n",
    "A = np.linspace(1,10,10)\n",
    "B = np.linspace(1,10,10) #it will complain if sizes do not match\n",
    "print(A+B)\n",
    "print(A-B)\n",
    "print(A*B)\n",
    "print(A/B)\n",
    "print(A//B)\n",
    "print(A**B)\n",
    "print(A%B)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1. ]\n",
      "[0.99500417 0.98006658 0.95533649 0.92106099 0.87758256 0.82533561\n",
      " 0.76484219 0.69670671 0.62160997 0.54030231]\n",
      "[1.47062891 1.36943841 1.26610367 1.15927948 1.04719755 0.92729522\n",
      " 0.79539883 0.64350111 0.45102681 0.        ]\n",
      "[1.10517092 1.22140276 1.34985881 1.4918247  1.64872127 1.8221188\n",
      " 2.01375271 2.22554093 2.45960311 2.71828183]\n",
      "[-2.30258509 -1.60943791 -1.2039728  -0.91629073 -0.69314718 -0.51082562\n",
      " -0.35667494 -0.22314355 -0.10536052  0.        ]\n",
      "[10.          5.          3.33333333  2.5         2.          1.66666667\n",
      "  1.42857143  1.25        1.11111111  1.        ]\n"
     ]
    }
   ],
   "source": [
    "arr=np.linspace(0.1,1,10)\n",
    "print(abs(arr))\n",
    "print(np.cos(arr))\n",
    "print(np.arccos(arr))\n",
    "print(np.exp(arr))\n",
    "print(np.log(abs(arr)))\n",
    "print(np.reciprocal(arr))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Joining, splitting, shaping**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5 6 7 8]\n"
     ]
    }
   ],
   "source": [
    "#for joining arrays you can use concatinate\n",
    "arr1 = np.array([1,2,3,4])\n",
    "arr2 = np.array([5,6,7,8])\n",
    "print(np.concatenate([arr1,arr2]))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]\n",
      " [5 6]\n",
      " [7 8]]\n",
      "[[1 2 5 6]\n",
      " [3 4 7 8]]\n"
     ]
    }
   ],
   "source": [
    "#you can reshape the arrays, it will complain if dimensions do not allow for that\n",
    "A = arr1.reshape(2,2)\n",
    "B = arr2.reshape(2,2)\n",
    "print(np.concatenate([A,B]))\n",
    "print(np.concatenate([A,B],axis=1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3] (3,)\n",
      "[[4 5 6]\n",
      " [7 8 9]] (2, 3)\n",
      "[[1 2 3]\n",
      " [4 5 6]\n",
      " [7 8 9]]\n",
      "[[1 4 7]\n",
      " [2 5 8]\n",
      " [3 6 9]]\n"
     ]
    }
   ],
   "source": [
    "#you can \"stack\" arrays horizontally or vertically\n",
    "vect1 = np.array([1,2,3])\n",
    "vect2 = np.array([[4,5,6],[7,8,9]])\n",
    "print(vect1,np.shape(vect1))\n",
    "print(vect2,np.shape(vect2))\n",
    "print(np.vstack([vect1,vect2]))\n",
    "print(np.hstack([vect1.reshape(3,1),vect2.T]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2  3  4]\n",
      " [ 5  6  7  8  9]\n",
      " [10 11 12 13 14]\n",
      " [15 16 17 18 19]]\n",
      "B= [[0 1 2 3 4]\n",
      " [5 6 7 8 9]]\n",
      "C= [[10 11 12 13 14]\n",
      " [15 16 17 18 19]]\n",
      "[[ 0  1  2]\n",
      " [ 5  6  7]\n",
      " [10 11 12]\n",
      " [15 16 17]]\n",
      "[[ 3  4]\n",
      " [ 8  9]\n",
      " [13 14]\n",
      " [18 19]]\n"
     ]
    }
   ],
   "source": [
    "#splitting the arrays\n",
    "A = np.arange(20).reshape(4,5)\n",
    "print(A)\n",
    "B,C = np.split(A,2)\n",
    "print(\"B=\",B)\n",
    "print(\"C=\",C)\n",
    "B,C = np.split(A,[3],axis=1) #split vertically\n",
    "print(B)\n",
    "print(C)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Element access**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2  3  4  5]\n",
      " [ 6  7  8  9 10]\n",
      " [11 12 13 14 15]\n",
      " [16 17 18 19 20]\n",
      " [21 22 23 24 25]] \n",
      "\n",
      "7 9 25 23\n",
      "[[  1   2   3   4   5]\n",
      " [  6   7   8   9  10]\n",
      " [ 11  12  13 777  15]\n",
      " [ 16  17  18  19  20]\n",
      " [ 21  22  23  24  25]] \n",
      "\n",
      "[[  1   2   3   4   5]\n",
      " [  6   7   8   9  10]\n",
      " [ 11  12   1 777  15]\n",
      " [ 16  17  18  19  20]\n",
      " [ 21  22  23  24  25]] \n",
      "\n"
     ]
    }
   ],
   "source": [
    "A = np.array([range(i,i+5) for i in [1,6,11,16,21]])\n",
    "print(A,'\\n')\n",
    "print(A[1,1],A[1,3],A[-1,-1],A[-1,2])  # Accessing individual elements, negative counts from the end\n",
    "A[2,3] = 777    # Changing elements\n",
    "print(A,'\\n')             \n",
    "A[2,2] = 1.234   # Attention! numpy won't change array type, it will change your input\n",
    "print(A,'\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can specify the type you need to save that situation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.array([range(i,i+5) for i in [1,6,11,16,21]],dtype='float')\n",
    "            \n",
    "A[2,2] = 1.234   # Attention! numpy won't change array type, it will change your input\n",
    "print(A,'\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can have the same syntax as with range before (this takes time to get used to...):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 7  8  9]\n",
      " [12  1 14]\n",
      " [17 18 19]] \n",
      "\n",
      "[[ 3  4  5]\n",
      " [ 8  9 10]\n",
      " [ 1 14 15]] \n",
      "\n",
      "[[ 1  3  5]\n",
      " [ 6  8 10]\n",
      " [11  1 15]\n",
      " [16 18 20]\n",
      " [21 23 25]] \n",
      "\n",
      "[[21 22 23 24 25]\n",
      " [16 17 18 19 20]\n",
      " [11 12  1 14 15]\n",
      " [ 6  7  8  9 10]\n",
      " [ 1  2  3  4  5]] \n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(A[1:4,1:4],'\\n')  # central sub array\n",
    "print(A[:3,2:],'\\n')    # top right sub array\n",
    "print(A[:,0:5:2],'\\n')  # only even columns\n",
    "print(A[::-1,:],'\\n')   # reverse the rows "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Surprise!** If you assign this to something, this acts like a \"reference\" instead of copy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  7   8   9]\n",
      " [ 12   1 777]\n",
      " [ 17  18 999]]\n",
      "[[  1   2   3   4   5]\n",
      " [  6   7   8   9  10]\n",
      " [ 11  12   1 777  15]\n",
      " [ 16  17  18 999  20]\n",
      " [ 21  22  23  24  25]]\n"
     ]
    }
   ],
   "source": [
    "B=A[1:4,1:4]\n",
    "B[2][2]=999\n",
    "print(B)\n",
    "print(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "you need to call the `copy()` to actually copy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  7   8   9]\n",
      " [ 12   1 777]\n",
      " [ 17  18 888]]\n",
      "[[  1   2   3   4   5]\n",
      " [  6   7   8   9  10]\n",
      " [ 11  12   1 777  15]\n",
      " [ 16  17  18 999  20]\n",
      " [ 21  22  23  24  25]]\n"
     ]
    }
   ],
   "source": [
    "B=A[1:4,1:4].copy()\n",
    "B[2][2]=888\n",
    "print(B)\n",
    "print(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Linear Algebra** "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A: [[ 1 77  3]\n",
      " [ 4  5  6]\n",
      " [ 7  8  9]]\n",
      "B: [[ 5. 10.]\n",
      " [15. 20.]\n",
      " [25. 30.]]\n",
      "dot product\n",
      " [[1235. 1640.]\n",
      " [ 245.  320.]\n",
      " [ 380.  500.]]\n",
      "Matrix product\n",
      " [[1235. 1640.]\n",
      " [ 245.  320.]\n",
      " [ 380.  500.]]\n",
      "Inner product\n",
      " [[5939  407  650]\n",
      " [ 407   77  122]\n",
      " [ 650  122  194]]\n",
      "Outer product\n",
      " [[   5.   10.   15.   20.   25.   30.]\n",
      " [ 385.  770. 1155. 1540. 1925. 2310.]\n",
      " [  15.   30.   45.   60.   75.   90.]\n",
      " [  20.   40.   60.   80.  100.  120.]\n",
      " [  25.   50.   75.  100.  125.  150.]\n",
      " [  30.   60.   90.  120.  150.  180.]\n",
      " [  35.   70.  105.  140.  175.  210.]\n",
      " [  40.   80.  120.  160.  200.  240.]\n",
      " [  45.   90.  135.  180.  225.  270.]]\n",
      "Trace\n",
      " 15\n",
      "Transpose\n",
      " [[ 1  4  7]\n",
      " [77  5  8]\n",
      " [ 3  6  9]]\n",
      "Matrix Power\n",
      " [[330 486 492]\n",
      " [ 66 381  96]\n",
      " [102 651 150]]\n",
      "Inverse\n",
      " [[-0.00666667 -1.48666667  0.99333333]\n",
      " [ 0.01333333 -0.02666667  0.01333333]\n",
      " [-0.00666667  1.18       -0.67333333]]\n",
      "Singular Value Decomposition\n",
      " (array([[-9.91282776e-01,  1.31750591e-01, -4.90747261e-04],\n",
      "       [-6.99328398e-02, -5.29319553e-01, -8.45535457e-01],\n",
      "       [-1.11659558e-01, -8.38130415e-01,  5.33919048e-01]]), array([77.72341941, 12.99505959,  0.44553553]), array([[-0.02640943, -0.99804814, -0.05659017],\n",
      "       [-0.60426353,  0.06103507, -0.7944434 ],\n",
      "       [ 0.79634674,  0.01321458, -0.60469599]]))\n",
      "Determinant\n",
      " 450.00000000000006\n",
      "Eigen decomposition\n",
      " (array([ 27.26747775, -10.72934286,  -1.53813489]), array([[-0.85215682, -0.94982038, -0.83508751],\n",
      "       [-0.27331558,  0.13366723,  0.006095  ],\n",
      "       [-0.44623688,  0.2827973 ,  0.55008336]]))\n"
     ]
    }
   ],
   "source": [
    "A = np.array([[1,77,3],[4,5,6],[7,8,9]])\n",
    "B = np.linspace(5,30,6).reshape(3,2)\n",
    "print('A:',A)\n",
    "print('B:',B)\n",
    "print('dot product\\n',np.dot(A,B))\n",
    "print('Matrix product\\n',np.matmul(A,B)) #different from dot for dimensions>2\n",
    "print('Inner product\\n',np.inner(A,A))\n",
    "print('Outer product\\n',np.outer(A,B))\n",
    "print('Trace\\n',np.trace(A))\n",
    "print('Transpose\\n',A.T)\n",
    "print('Matrix Power\\n',np.linalg.matrix_power(A,2))\n",
    "print('Inverse\\n',np.linalg.inv(A))\n",
    "print('Singular Value Decomposition\\n',np.linalg.svd(A))\n",
    "print('Determinant\\n',np.linalg.det(A))\n",
    "print('Eigen decomposition\\n',np.linalg.eig(A))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(np.inner)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Statistics:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A: [0.    0.125 0.25  0.375 0.5   0.625 0.75  0.875 1.   ]\n",
      "sum:                4.5\n",
      "product:            0.0\n",
      "mean:               0.5\n",
      "standard deviation: 0.3227486121839514\n",
      "variance:           0.10416666666666667\n",
      "minimum:            0.0\n",
      "maximum:            1.0\n",
      "median:             0.5\n",
      "index of min:       0\n",
      "index of max:       8\n"
     ]
    }
   ],
   "source": [
    "A = np.linspace(0,1,9)\n",
    "print('A:',A)\n",
    "print('sum:               ',np.sum(A))\n",
    "print('product:           ',np.prod(A))\n",
    "print('mean:              ',np.mean(A))\n",
    "print('standard deviation:',np.std(A))\n",
    "print('variance:          ',np.var(A))\n",
    "print('minimum:           ',np.min(A))\n",
    "print('maximum:           ',np.max(A))\n",
    "print('median:            ',np.median(A))\n",
    "print('index of min:      ',np.argmin(A))\n",
    "print('index of max:      ',np.argmax(A))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**\"Surprise\" on argmin/argmax:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n"
     ]
    }
   ],
   "source": [
    "A=np.linspace(0,10,9).reshape(3,3)\n",
    "print(np.argmax(A))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 2)\n"
     ]
    }
   ],
   "source": [
    "print(np.unravel_index(np.argmax(A), A.shape))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **More traps:**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes you have to think like a c/c++ programmer:\n",
    "\n",
    "**overflow is possible with numpy arrays**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[12345678987654321]\n",
      "[-79]\n"
     ]
    }
   ],
   "source": [
    "arr13 = 12345678987654321*np.ones((1), dtype='int8')\n",
    "arr14 = np.array([12345678987654321], dtype='int8')\n",
    "print(arr13)\n",
    "print(arr14)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you deal with too much data/big arrays, it's a good idea to \"delete\" them after usage, so that they wouldn't take up memory space. Python garbage collector will take care of them then (though not instantly). You can just do:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "arr1=None\n",
    "print(arr1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Help becomes too complicated with too many functions. You can use:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Search results for 'exponent'\n",
      "-----------------------------\n",
      "numpy.exp\n",
      "    Calculate the exponential of all elements in the input array.\n",
      "numpy.frexp\n",
      "    Decompose the elements of x into mantissa and twos exponent.\n",
      "numpy.logaddexp\n",
      "    Logarithm of the sum of exponentiations of the inputs.\n",
      "numpy.logaddexp2\n",
      "    Logarithm of the sum of exponentiations of the inputs in base-2.\n",
      "numpy.ma.exp\n",
      "    Calculate the exponential of all elements in the input array.\n",
      "numpy.random.Generator.exponential\n",
      "    Draw samples from an exponential distribution.\n",
      "numpy.random.Generator.laplace\n",
      "    Draw samples from the Laplace or double exponential distribution with\n",
      "numpy.random.RandomState.exponential\n",
      "    Draw samples from an exponential distribution.\n",
      "numpy.random.RandomState.laplace\n",
      "    Draw samples from the Laplace or double exponential distribution with\n",
      "numpy.log\n",
      "    Natural logarithm, element-wise.\n",
      "numpy.expm1\n",
      "    Calculate ``exp(x) - 1`` for all elements in the array.\n",
      "numpy.finfo\n",
      "    finfo(dtype)\n",
      "numpy.ldexp\n",
      "    Returns x1 * 2**x2, element-wise.\n",
      "numpy.power\n",
      "    First array elements raised to powers from second array, element-wise.\n",
      "numpy.random.Generator.standard_exponential\n",
      "    Draw samples from the standard exponential distribution.\n",
      "numpy.double\n",
      "    Double-precision floating-point number type, compatible with Python `float`\n",
      "numpy.float16\n",
      "    Half-precision floating-point number type.\n",
      "numpy.float32\n",
      "    Single-precision floating-point number type, compatible with C ``float``.\n",
      "numpy.savetxt\n",
      "    Save an array to a text file.\n",
      "numpy.random.RandomState.standard_exponential\n",
      "    Draw samples from the standard exponential distribution.\n",
      "numpy.einsum_path\n",
      "    Evaluates the lowest cost contraction order for an einsum expression by\n",
      "numpy.float_power\n",
      "    First array elements raised to powers from second array, element-wise.\n",
      "numpy.ma.log\n",
      "    Natural logarithm, element-wise.\n",
      "numpy.shares_memory\n",
      "    Determine if two arrays share memory.\n",
      "numpy.format_float_scientific\n",
      "    Format a floating-point scalar as a decimal string in scientific notation.\n",
      "numpy.linalg.matrix_power\n",
      "    Raise a square matrix to the (integer) power `n`.\n",
      "numpy.random.Generator.power\n",
      "    Draws samples in [0, 1] from a power distribution with positive\n",
      "numpy.random.Generator.gumbel\n",
      "    Draw samples from a Gumbel distribution.\n",
      "numpy.random.Generator.weibull\n",
      "    Draw samples from a Weibull distribution.\n",
      "numpy.random.RandomState.power\n",
      "    Draws samples in [0, 1] from a power distribution with positive\n",
      "numpy.random.RandomState.gumbel\n",
      "    Draw samples from a Gumbel distribution.\n",
      "numpy.random.RandomState.weibull\n",
      "    Draw samples from a Weibull distribution.\n",
      "numpy.core._multiarray_umath.shares_memory\n",
      "    Determine if two arrays share memory."
     ]
    }
   ],
   "source": [
    "np.lookfor(\"exponent\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Why use numpy arrays over normal?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "A=np.array(range(0,900)).reshape(30,30)\n",
    "B=np.array(range(34,934)).reshape(30,30)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "29.2 µs ± 527 ns per loop (mean ± std. dev. of 7 runs, 10,000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "np.matmul(A,B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "A=[[x for x in range(30)] for i in range(30)]\n",
    "B=[[x+34 for x in range(30)] for i in range(30)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "212 µs ± 19 µs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "np.matmul(A,B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Is numpy fast?**\n",
    "\n",
    "Yes, when you know what you are doing.\n",
    "\n",
    "Unfortunately, it's very easy to write bad code in python, much easier than in c/c++...\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:my_env2]",
   "language": "python",
   "name": "conda-env-my_env2-py"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}