Lecture3.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 inline`**\n",
    "\n",
    "This can only be done when you really need to save screen space and typing time (like is done in your other lectures, but never in real life. Remember `using namespace std`? This is even worse.\n",
    "\n",
    "**Exercise0:** go through any 2 lectures of numerical analysis and fix the notebooks to use all the names properly."
   ]
  },
  {
   "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)"
   ]
  },
  {
   "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": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import itertools as it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(*permut)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(permut)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(*comb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(*pr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **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 manipulations on arrays. It's usually imported as \"np\". "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "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": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1. 2. 3. 4. 5.]\n",
      "<class 'numpy.ndarray'>\n",
      "<class 'numpy.float64'>\n"
     ]
    }
   ],
   "source": [
    "arr1 = np.array([1,2,3,4,5],dtype='float')                    # 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": 9,
   "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": 12,
   "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",
      " 8.30769620e-072 2.54739442e-052 3.27054236e+179 7.73684576e-091\n",
      " 2.31863562e-056 5.56137509e+141]\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": 13,
   "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": "code",
   "execution_count": 15,
   "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": 19,
   "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": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.05884326 0.90681354 0.3200834  0.3180189  0.65618513]\n",
      " [0.21823833 0.12281995 0.22217896 0.37009915 0.98712793]\n",
      " [0.75605559 0.9147898  0.43758631 0.04762919 0.87356852]]\n",
      "[[ 5.42123257  4.7899498  -2.05694552 -3.17214919]\n",
      " [ 2.77616338 11.03279275 -6.47188671  4.24733839]\n",
      " [-3.80725691  2.27849356 -0.93944711  0.76549637]]\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": 23,
   "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": 24,
   "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": 25,
   "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": 26,
   "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": 27,
   "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": 28,
   "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": 29,
   "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 777  14  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 14 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,2] = 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 have the same syntax as with range before (this takes time to get used to...):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "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": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  7   8   9]\n",
      " [ 12   1  14]\n",
      " [ 17  18 999]]\n",
      "[[  1   2   3   4   5]\n",
      " [  6   7   8   9  10]\n",
      " [ 11  12   1  14  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": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  7   8   9]\n",
      " [ 12   1  14]\n",
      " [ 17  18 888]]\n",
      "[[  1   2   3   4   5]\n",
      " [  6   7   8   9  10]\n",
      " [ 11  12   1  14  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": 33,
   "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": 34,
   "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": 37,
   "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": 38,
   "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": 39,
   "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": null,
   "metadata": {},
   "outputs": [],
   "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": 40,
   "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.random.Generator.standard_exponential\n",
      "    Draw samples from the standard exponential distribution.\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.MachAr\n",
      "    Diagnosing machine parameters.\n",
      "numpy.double\n",
      "    Double-precision floating-point number type, compatible with Python `float`\n",
      "numpy.random.RandomState.standard_exponential\n",
      "    Draw samples from the standard exponential distribution.\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.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.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."
     ]
    }
   ],
   "source": [
    "np.lookfor(\"exponent\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Why use numpy arrays over normal?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "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": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "31 µs ± 129 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "np.matmul(A,B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "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": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "192 µs ± 1.81 µs per loop (mean ± std. dev. of 7 runs, 1000 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",
    "\n",
    "Let's look at the exercise1 from the last lecture (see solutions1.ipynb)"
   ]
  }
 ],
 "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
}