Lab04.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "fmw2iyvRlNrT"
   },
   "source": [
    "# Numpy -  multidimensional data arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "4KAie0i9lNrY"
   },
   "source": [
    "## Introduction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "1PDTT5mPlNrY"
   },
   "source": [
    "The `numpy` package (module) is used in almost all numerical computation using Python. It is a package that provide high-performance vector, matrix and higher-dimensional data structures for Python. \n",
    "\n",
    "To use `numpy` you need to import the module, using for example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "id": "kJ4xFTyVlNrZ"
   },
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "YpQgAIWolNrZ"
   },
   "source": [
    "Here, we have imported the numpy module into its own namespace in our programs. We have chosen to call this namespace `np`, which is the standard rule for using `numpy`, but any name will do, in principle.\n",
    "\n",
    "In the `numpy` package the terminology used for vectors, matrices and higher-dimensional data sets is *array*. \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ae5UW4J2lNra"
   },
   "source": [
    "## Creating `numpy` arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ApaeNrAzlNra"
   },
   "source": [
    "There are a number of ways to initialize new numpy arrays, for example from\n",
    "\n",
    "* a Python list or tuples\n",
    "* using functions that are dedicated to generating numpy arrays, such as `arange`, `linspace`, etc.\n",
    "* reading data from files"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "7-gzYqDdlNrb"
   },
   "source": [
    "### From lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "buj7BsiOlNrb"
   },
   "source": [
    "For example, to create new vector and matrix arrays from Python lists we can use the `numpy.array` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "ab7_YhjylNrb",
    "outputId": "41511860-09ca-4406-a4e8-dddcf5fcd6f8"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# a vector: the argument to the array function is a Python list\n",
    "v = np.array([1,2,3,4])\n",
    "\n",
    "v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "yzoBVDmllNrc",
    "outputId": "17477701-b4ed-4389-f422-75588dfec503"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4]])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# a matrix: the argument to the array function is a nested Python list\n",
    "M = np.array([[1, 2], [3, 4]])\n",
    "\n",
    "M"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "vYIw5qBtlNrc"
   },
   "source": [
    "The `v` and `M` objects are both of the type `ndarray` that the `numpy` module provides."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "5otsE0LUlNrd",
    "outputId": "c83a720d-d207-45a0-fd09-0e3c8ec4f3db"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(numpy.ndarray, numpy.ndarray)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(v), type(M)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "rE_KBlKclNrd"
   },
   "source": [
    "The difference between the `v` and `M` arrays is only their shapes. We can get information about the shape of an array by using the `ndarray.shape` property."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "C2AYM6zwlNrd",
    "outputId": "69822cfe-3787-4e18-f42e-7394d37f3cdd"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4,)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "kuJvcSLTlNrd",
    "outputId": "f7969f6e-76f6-4e30-c063-03102b7b1fec"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 2)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "wvd_QxaHlNre"
   },
   "source": [
    "The number of elements in the array is available through the `ndarray.size` property:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "7tgEonbclNre",
    "outputId": "ef7fe2f5-6d68-4321-de49-414d95d0f2d7"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "PqnElkIFlNrg"
   },
   "source": [
    "If we want, we can explicitly define the type of the array data when we create it, using the `dtype` keyword argument: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "id": "wDnO0B-3lNrg",
    "outputId": "1691b384-f71d-459a-d662-d4390c347729"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.+0.j, 2.+0.j],\n",
       "       [3.+0.j, 4.+0.j]])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M = np.array([[1, 2], [3, 4]], dtype=complex)\n",
    "\n",
    "M"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that python uses 'j' to denote $\\sqrt{-1}$ instead of the usual $i$. This is so that programmers can use the letter 'i' for other things. Complex numbers can be handled seamlessly in python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 01:\n",
    "\n",
    "   1. In the code cell below, create a list of the numbers $1,2,3,4, \\dots 10,000$ and call it 'a'. Then, Convert it to a numpy array and use array programming to multiply all the numbers by $2$ and output the result. \n",
    "   2. Use the code cell below and use numpy to build the three Pauli matrices. use the 'print()' function to show the output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "oA4OuvmBlNrh"
   },
   "source": [
    "### Using array-generating functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "9FVwGmnElNrh"
   },
   "source": [
    "For larger arrays it is impractical to initialize the data manually, using explicit python lists. Instead we can use one of the many functions in `numpy` that generate arrays of different forms. Some of the more common are:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "4ZEe9TgmlNrh"
   },
   "source": [
    "#### arange"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "id": "ZfrXArsxlNrh",
    "outputId": "3fd0201d-ff13-4318-be81-8416c955a792",
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16,\n",
       "       17, 18, 19, 20, 21, 22, 23])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "array([ 0,  2,  4,  6,  8, 10, 12, 14, 16, 18])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# create a range\n",
    "x = np.arange(0, 24, 1) # arguments: start, stop, step\n",
    "display(x)\n",
    "\n",
    "y = np.arange(9)\n",
    "display(y)\n",
    "\n",
    "z = np.arange(0, 20, 2)\n",
    "display(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "lUqjUpgHlNrj"
   },
   "source": [
    "**Note:** This function is called 'a-range' (the letter 'a' followed by 'range') and typed `arange` (with a single 'r'). **It is not called `arrange`** (with two 'r's), a common mistake.\n",
    "\n",
    "The linspace() and logspace() functions create uniformly spaced list of numbers on a line. The first function does it on a linear scale, and the second function on a log-scale. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "id": "DzKBte8nlNrk",
    "outputId": "443e06d6-46de-4fc6-c17c-9833b4c8a759"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.        ,  0.41666667,  0.83333333,  1.25      ,  1.66666667,\n",
       "        2.08333333,  2.5       ,  2.91666667,  3.33333333,  3.75      ,\n",
       "        4.16666667,  4.58333333,  5.        ,  5.41666667,  5.83333333,\n",
       "        6.25      ,  6.66666667,  7.08333333,  7.5       ,  7.91666667,\n",
       "        8.33333333,  8.75      ,  9.16666667,  9.58333333, 10.        ])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# using linspace, both end points ARE included\n",
    "np.linspace(0, 10, 25)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "id": "BF48VzA5lNrk",
    "outputId": "0b7ee404-616a-45a9-e5d9-5e4b4af8a2a4"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.00000000e+00, 3.03773178e+00, 9.22781435e+00, 2.80316249e+01,\n",
       "       8.51525577e+01, 2.58670631e+02, 7.85771994e+02, 2.38696456e+03,\n",
       "       7.25095809e+03, 2.20264658e+04])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.logspace(0, 10, 10, base=np.e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 02:\n",
    "\n",
    "1. Using numpy, create a list of all even numbers from $1 - 100$. Also, create a list of all odd numbers in the same range, as well as a list of multiples of $4$.\n",
    "2. Create an array of $100$ uniformly spaced numbers in the interval $\\left[-\\pi , \\pi\\right]$.  The value of $\\pi$ can be gotten from `np.pi`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "avzofHDQlNrl"
   },
   "source": [
    "### The diag function:\n",
    "\n",
    "The `np.diag()` function can be used to create a matrix and populate it with a given vector along a desired diagonal."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "id": "58ooCseGlNrl",
    "outputId": "7e9504dc-42d3-47ce-a992-2898c4bbd85b"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 0, 0],\n",
       "       [0, 2, 0],\n",
       "       [0, 0, 3]])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# a diagonal matrix\n",
    "np.diag([1,2,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "id": "e0x2DelzlNrl",
    "outputId": "3a3a892b-2375-48d6-c647-3b92c3767bed"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 0, 0],\n",
       "       [0, 0, 2, 0],\n",
       "       [0, 0, 0, 3],\n",
       "       [0, 0, 0, 0]])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# diagonal with offset from the main diagonal\n",
    "np.diag([1,2,3], k=1) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With the diag function we can also extract the diagonal and subdiagonals of an array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.1097733 , 0.47724435, 0.46572997],\n",
       "       [0.18731052, 0.68840323, 0.05433925],\n",
       "       [0.08983981, 0.08060106, 0.70280683]])"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.random.rand(3,3)\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.1097733 , 0.68840323, 0.70280683])"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.diag(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.18731052, 0.08060106])"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.diag(A, k=-1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "4t0OtKbolNrm"
   },
   "source": [
    "### Arrays of zeros and ones\n",
    "\n",
    "Homogeneous arrays (where all the values are the same) of any size and shape can be easily created."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 0., 0., 0.])"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "id": "Ga9m6pPElNrm",
    "outputId": "db3a38e5-ad17-481a-aa15-ff5fde8590cf"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0.],\n",
       "       [0., 0., 0.],\n",
       "       [0., 0., 0.]])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros((3,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 1., 1., 1.])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ones(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "HGfj6dd3lNrm",
    "outputId": "ba60acce-181d-4dd0-fc4c-b090eb7205b3",
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1., 1.],\n",
       "       [1., 1., 1.],\n",
       "       [1., 1., 1.]])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ones((3,3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can combine multiple functions to create more complex arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 1., 0., 0.],\n",
       "       [0., 0., 0., 1., 0.],\n",
       "       [0., 0., 0., 0., 1.],\n",
       "       [0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0.]])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Diagonal matrix with ones on the superdiagonal \n",
    "np.diag(np.ones(3), k=2) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0.],\n",
       "       [2., 0., 0., 0., 0.],\n",
       "       [0., 2., 0., 0., 0.],\n",
       "       [0., 0., 2., 0., 0.]])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Diagonal matrix with twos on the subdiagonal \n",
    "np.diag(2 * np.ones(3), k=-2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 03:\n",
    "\n",
    "Prepare a $7 \\times 7$ matrix with fixed numbers ($5$) on the $2^{nd}$ superdiagonal and subdiagonal."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Mjew_W-3QctZ",
    "outputId": "0eebdd9c-5e36-496c-f5ce-fcd5a008af5c"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "vf3gA14jlNrp"
   },
   "source": [
    "## Manipulating arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "hasnjLprlNrp"
   },
   "source": [
    "### Indexing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "guBXQfEalNrp"
   },
   "source": [
    "We can index elements in an array using square brackets and indices:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "id": "Zl8HN2JplNrp",
    "outputId": "25173694-7ff5-4515-fffc-54fa0ef2ffb0"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.39796982 0.97571643 0.14047112 0.36550337 0.19483888 0.68575146\n",
      " 0.57990971 0.85476018 0.01678117 0.39794892]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.3979698156787721"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v = np.random.random(10) # 10 random numbers from a uniform distribution in [0,1]\n",
    "print(v)\n",
    "# v is a vector, and has only one dimension, taking one index\n",
    "v[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "id": "M8HTJiFRlNrp",
    "outputId": "8b2fef06-821d-48e5-8d04-3411caab8689"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.8187199  0.65338288 0.33229777 0.81532183]\n",
      " [0.555501   0.16744827 0.43188729 0.70565032]\n",
      " [0.28648923 0.4375707  0.16593807 0.55852771]\n",
      " [0.17304955 0.66272481 0.30567052 0.94329551]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.16744826663043788"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M = np.random.random((4,4))  # M is a 4 X 4 matrix, or a 2 dimensional array, taking two indices \n",
    "print(M)\n",
    "\n",
    "M[1,1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "unpY18n4lNrp"
   },
   "source": [
    "If we omit an index of a multidimensional array it returns the whole row (or, in general, a N-1 dimensional array) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "id": "UP6qxJXFlNrp",
    "outputId": "b7ca6f18-79c5-47b6-a8d0-361321a9bcc9"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.8187199 , 0.65338288, 0.33229777, 0.81532183],\n",
       "       [0.555501  , 0.16744827, 0.43188729, 0.70565032],\n",
       "       [0.28648923, 0.4375707 , 0.16593807, 0.55852771],\n",
       "       [0.17304955, 0.66272481, 0.30567052, 0.94329551]])"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "id": "64Qjtdq-lNrq",
    "outputId": "d3839575-a07e-4360-97ce-b2cb426bc0d0"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.555501  , 0.16744827, 0.43188729, 0.70565032])"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "r6m6tmAclNrq"
   },
   "source": [
    "The same thing can be achieved with using `:` instead of an index:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "id": "Z-j3d8lylNrq",
    "outputId": "2855cbd8-2133-4445-e05f-71ae6605f09c"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.555501  , 0.16744827, 0.43188729, 0.70565032])"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M[1,:] # row 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "id": "9L_Us3v7lNrq",
    "outputId": "cfa65663-68e9-4246-ba34-be70b4f41357"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.65338288, 0.16744827, 0.4375707 , 0.66272481])"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M[:,1] # column 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "EyWrMGQzlNrq"
   },
   "source": [
    "We can assign new values to elements in an array using indexing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "id": "P7tCRbrblNrq"
   },
   "outputs": [],
   "source": [
    "M[0,0] = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "id": "41vvwymhlNrq",
    "outputId": "e84c63e0-f3e8-42a2-dc09-0c7ef9402d5a"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.        , 0.65338288, 0.33229777, 0.81532183],\n",
       "       [0.555501  , 0.16744827, 0.43188729, 0.70565032],\n",
       "       [0.28648923, 0.4375707 , 0.16593807, 0.55852771],\n",
       "       [0.17304955, 0.66272481, 0.30567052, 0.94329551]])"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "id": "0oxAshkAlNrr"
   },
   "outputs": [],
   "source": [
    "# also works for rows and columns\n",
    "M[1,:] = 0\n",
    "M[:,2] = -1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "id": "7O6PoM2DlNrr",
    "outputId": "2082c003-cdb5-44d7-a036-3f3eb3235482"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.        ,  0.65338288, -1.        ,  0.81532183],\n",
       "       [ 0.        ,  0.        , -1.        ,  0.        ],\n",
       "       [ 0.28648923,  0.4375707 , -1.        ,  0.55852771],\n",
       "       [ 0.17304955,  0.66272481, -1.        ,  0.94329551]])"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "o64CLOuglNrr"
   },
   "source": [
    "### Index slicing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "_Bb2Qw2ClNrr"
   },
   "source": [
    "Index slicing is the technical name for the syntax `M[lower:upper:step]` to extract part of an array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "id": "E4-VBFVGlNrr",
    "outputId": "64d361e4-fb29-4f22-ac9e-85372159c007"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.array([1,2,3,4,5])\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "id": "c5DTLomGlNrr",
    "outputId": "b5153496-5225-4969-ad60-e5e7d7430f3e"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 3])"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[1:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "FCfg85FNlNrr"
   },
   "source": [
    "Array slices are *mutable*: if they are assigned a new value the original array from which the slice was extracted is modified:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "id": "ytG7IS--lNrr",
    "outputId": "65f8eca0-60a3-4990-deb7-1af3af61fbf0"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1, -2, -3,  4,  5])"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[1:3] = [-2,-3]\n",
    "\n",
    "A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "FoEO0NjVlNrs"
   },
   "source": [
    "We can omit any of the three parameters in `M[lower:upper:step]`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "id": "pUv4C8FwlNrs",
    "outputId": "20ccdd44-cfbb-4f26-d8cb-c5fe7b14bfb1"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1, -2, -3,  4,  5])"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[::] # lower, upper, step all take the default values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "id": "Q85c29uplNrs",
    "outputId": "9a7b41af-1379-4d66-9ada-2f43308a57e0"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1, -3,  5])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[::2] # step is 2, lower and upper defaults to the beginning and end of the array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "id": "nbzH_Wx-lNrs",
    "outputId": "ba92eecd-cc57-4bbe-afd6-560d5554a9d2"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1, -2, -3])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[:3] # first three elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "id": "CskrskvllNrs",
    "outputId": "ce461747-1ba2-4d11-b4b0-197b8600cdcf"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4, 5])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[3:] # elements from index 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Zp5S33CclNrs"
   },
   "source": [
    "Negative indices counts from the end of the array (positive index from the begining):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "id": "Jrvme1dDlNrs"
   },
   "outputs": [],
   "source": [
    "A = np.array([1,2,3,4,5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "id": "3ZLDzA85lNrt",
    "outputId": "bdf4a2c4-e941-45ab-916e-9483e7c10fcd"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[-1] # the last element in the array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "id": "E3r3S-fllNrt",
    "outputId": "b268f814-9273-4e5c-bf3d-17e0c51f0858"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 4, 5])"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[-3:] # the last three elements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "4KA7Ym_hlNrt"
   },
   "source": [
    "Index slicing works exactly the same way for multidimensional arrays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "id": "cxkUap1zlNrt",
    "outputId": "7aba3ff6-89c9-4906-e34e-ea0f3b9e71e4"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  4],\n",
       "       [10, 11, 12, 13, 14],\n",
       "       [20, 21, 22, 23, 24],\n",
       "       [30, 31, 32, 33, 34],\n",
       "       [40, 41, 42, 43, 44]])"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.array([[n+m*10 for n in range(5)] for m in range(5)])\n",
    "\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "id": "s4UodZfLlNrt",
    "outputId": "c33a3e17-6f33-4d96-fe92-c2d69315463d"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[11, 12, 13],\n",
       "       [21, 22, 23],\n",
       "       [31, 32, 33]])"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# a block from the original array\n",
    "A[1:4, 1:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "id": "80GfPlxBlNrt",
    "outputId": "872e78b4-81f5-4166-8f32-7bcefda02011"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  2,  4],\n",
       "       [20, 22, 24],\n",
       "       [40, 42, 44]])"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# strides\n",
    "A[::2, ::2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### An important point to remember\n",
    "So, array slices work more-or-less like slices of python lists or strings. There is, however, one key difference.\n",
    "\n",
    "With lists (or strings, tuples), each slice is a copy. However, slices of `NumPy` arrays are different. These slices are actually **views** on the original array. `Numpy` is designed to be memory-efficient and does not make unnecessary copies.\n",
    "\n",
    "What this means is that changing the slice of an array **actually changes** the original array. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2  3  4]\n",
      " [10 11 12 13 14]\n",
      " [20 21 22 23 24]\n",
      " [30 31 32 33 34]\n",
      " [40 41 42 43 44]]\n",
      "[[ 0  0  2  3  4]\n",
      " [10  1 12 13 14]\n",
      " [20  2 22 23 24]\n",
      " [30  3 32 33 34]\n",
      " [40  4 42 43 44]]\n"
     ]
    }
   ],
   "source": [
    "G = np.array([[n+m*10 for n in range(5)] for m in range(5)])\n",
    "print(G)\n",
    "\n",
    "G[:,1] = np.arange(5) #I changed the second column of G by taking the slice of the second column and assigning it a new value\n",
    "print(G) #The original array G has been modified"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[   20     2 21347    23    24]\n",
      "[   20     2 21347    23    24]\n",
      "[[    0     0     2     3     4]\n",
      " [   10     1    12    13    14]\n",
      " [   20     2 21347    23    24]\n",
      " [   30     3    32    33    34]\n",
      " [   40     4    42    43    44]]\n"
     ]
    }
   ],
   "source": [
    "y = G[2] #y is a slice consisting of the third row of G\n",
    "\n",
    "print(y)\n",
    "\n",
    "y[2] = 21347 #I changed the third element of y to 21347\n",
    "\n",
    "print(y) #The slice y has been modified\n",
    "\n",
    "print(G) #The original array G has ALSO been modified"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want to make a copy of an array in order to fiddle with it without damaging the original data, you can use the `copy()` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2  3  4]\n",
      " [10 11 12 13 14]\n",
      " [20 21 22 23 24]\n",
      " [30 31 32 33 34]\n",
      " [40 41 42 43 44]]\n",
      "[[ 0  1  2  3  4]\n",
      " [ 5  6  7  8  9]\n",
      " [20 21 22 23 24]\n",
      " [30 31 32 33 34]\n",
      " [40 41 42 43 44]]\n",
      "[[ 0  1  2  3  4]\n",
      " [10 11 12 13 14]\n",
      " [20 21 22 23 24]\n",
      " [30 31 32 33 34]\n",
      " [40 41 42 43 44]]\n"
     ]
    }
   ],
   "source": [
    "G = np.array([[n+m*10 for n in range(5)] for m in range(5)])\n",
    "print(G)\n",
    "\n",
    "H = G.copy() #This is a COPY of the array G. A new array, with a new memory address, has been created.\n",
    "\n",
    "H[1] = np.arange(5, 10) #I changed the second row of H by taking the slice of the second row and assigning it a new value\n",
    "print(H) #The array H has been modified\n",
    "\n",
    "print(G) #The original array G has NOT been modified"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's something interesting. We can use index slicing to extract diagonals and anti-diagonals of a matrix."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.23739847, 0.73347351, 0.12733749, 0.33997725, 0.77604993],\n",
       "       [0.88018944, 0.5973701 , 0.20135709, 0.42591759, 0.22129381],\n",
       "       [0.40073728, 0.75331752, 0.77766081, 0.98397582, 0.72918257],\n",
       "       [0.90166093, 0.46368833, 0.95693924, 0.16777689, 0.23720114],\n",
       "       [0.47464523, 0.08948455, 0.35870972, 0.84836818, 0.31748749]])"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.random.rand(5,5)\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.31748749, 0.84836818, 0.35870972, 0.08948455, 0.47464523],\n",
       "       [0.23720114, 0.16777689, 0.95693924, 0.46368833, 0.90166093],\n",
       "       [0.72918257, 0.98397582, 0.77766081, 0.75331752, 0.40073728],\n",
       "       [0.22129381, 0.42591759, 0.20135709, 0.5973701 , 0.88018944],\n",
       "       [0.77604993, 0.33997725, 0.12733749, 0.73347351, 0.23739847]])"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Extract diagonal\n",
    "A[::-1,::-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "sbWUkAjolNrt"
   },
   "source": [
    "**Fancy indexing** is the name for when an array or list is used in-place of an index: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "id": "QW1ePwDblNru",
    "outputId": "59f8e61f-1bc1-4043-8dc2-05a4906cd8ff",
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10, 11, 12, 13, 14],\n",
       "       [20, 21, 22, 23, 24],\n",
       "       [30, 31, 32, 33, 34]])"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "row_indices = [1, 2, 3]\n",
    "A[row_indices]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "id": "2XYhGUkmlNru",
    "outputId": "46feb22f-7037-4f16-8f35-4f39fd4435fb"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([11, 22, 34])"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "col_indices = [1, 2, -1] # remember, index -1 means the last element\n",
    "A[row_indices, col_indices]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 04:\n",
    "\n",
    "Execute the cell below to create the $3 \\times 4 \\times 4$ array named 'data', which is an array of three $4\\times 4$ matrices."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = np.array([[[ 1.,  2.,  3.,  4.],\n",
    "                [ 5.,  6.,  7.,  8.],\n",
    "                [ 9., 10., 11., 12.],\n",
    "                [13., 14., 15., 16.]],\n",
    "        \n",
    "                [[17., 18., 19., 20.],\n",
    "                [21., 22., 23., 24.],\n",
    "                [25., 26., 27., 28.],\n",
    "                [29., 30., 31., 32.]],\n",
    "\n",
    "                [[33., 34., 35., 36.],\n",
    "                [37., 38., 39., 40.],\n",
    "                [41., 42., 43., 44.],\n",
    "                [45., 46., 47., 48.]]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, index or slice this array to obtain the following:\n",
    "\n",
    "1. $20.0$\n",
    "2. The array $\\left[9.10,11,12\\right]$\n",
    "3. The following square matrix\n",
    "   \\begin{pmatrix}\n",
    "   33 & 34 & 35 & 36\\\\\n",
    "   37 & 38 & 39 & 40\\\\\n",
    "   41 & 42 & 43 & 44\\\\\n",
    "   45 & 46 & 47 & 48\n",
    "   \\end{pmatrix}\n",
    "4. The following sub-matrix\n",
    "   \\begin{pmatrix}\n",
    "   18 & 19 \\\\\n",
    "   22 & 23\n",
    "   \\end{pmatrix}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Linear Algebra with arrays\n",
    "As we have seen above, **vectorizing code** is the key to writing efficient numerical calculation with Python/Numpy. That means that as much as possible of a program should be formulated in terms of matrix and vector operations, like matrix-matrix multiplication."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Scalar-array operations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use the usual arithmetic operators to multiply, add, subtract, and divide arrays with scalar numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "v1 = np.arange(0, 5)\n",
    "v1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 2, 4, 6, 8])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "v1 * 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 3, 4, 5, 6])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "v1 + 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2  3  4]\n",
      " [10 11 12 13 14]\n",
      " [20 21 22 23 24]\n",
      " [30 31 32 33 34]\n",
      " [40 41 42 43 44]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(array([[ 0,  2,  4,  6,  8],\n",
       "        [20, 22, 24, 26, 28],\n",
       "        [40, 42, 44, 46, 48],\n",
       "        [60, 62, 64, 66, 68],\n",
       "        [80, 82, 84, 86, 88]]),\n",
       " array([[ 2,  3,  4,  5,  6],\n",
       "        [12, 13, 14, 15, 16],\n",
       "        [22, 23, 24, 25, 26],\n",
       "        [32, 33, 34, 35, 36],\n",
       "        [42, 43, 44, 45, 46]]))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "print(A)\n",
    "A * 2, A + 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Element-wise array-array operations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When we add, subtract, multiply and divide arrays with each other, the default behaviour is **element-wise** operations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2  3  4]\n",
      " [10 11 12 13 14]\n",
      " [20 21 22 23 24]\n",
      " [30 31 32 33 34]\n",
      " [40 41 42 43 44]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[   0,    1,    4,    9,   16],\n",
       "       [ 100,  121,  144,  169,  196],\n",
       "       [ 400,  441,  484,  529,  576],\n",
       "       [ 900,  961, 1024, 1089, 1156],\n",
       "       [1600, 1681, 1764, 1849, 1936]])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "print(A)\n",
    "A * A # element-wise multiplication"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  4,  9, 16])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "print(v1)\n",
    "v1 * v1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we multiply arrays with compatible shapes, we get an element-wise multiplication of each row:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((5, 5), (5,))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "A.shape, v1.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  0,   1,   4,   9,  16],\n",
       "       [  0,  11,  24,  39,  56],\n",
       "       [  0,  21,  44,  69,  96],\n",
       "       [  0,  31,  64,  99, 136],\n",
       "       [  0,  41,  84, 129, 176]])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "A * v1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Matrix algebra"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What about matrix mutiplication? There are many ways. The simplest way is to use the `@` idiom, which applies a matrix-matrix, matrix-vector, or inner vector multiplication to its two arguments: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 300,  310,  320,  330,  340],\n",
       "       [1300, 1360, 1420, 1480, 1540],\n",
       "       [2300, 2410, 2520, 2630, 2740],\n",
       "       [3300, 3460, 3620, 3780, 3940],\n",
       "       [4300, 4510, 4720, 4930, 5140]])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "A @ A # Matrix-Matrix product"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 30, 130, 230, 330, 430])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "A @ v1 # Matrix-Vector product"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "v1 @ v1 # Inner Product (Real vectors)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(57+0j)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "vc = np.array([0 + 1.j, 1 + 2.j, 4 + 3.j, 1 + 5.j, 0])\n",
    "vc.conjugate() @ vc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 30.+1.j, 131.+2.j, 234.+3.j, 331.+5.j, 430.+0.j])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "vc + A @ v1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The transpose of an array can be obtained with the `.T` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0.+25.j  1.+26.j  2.+27.j  3.+28.j  4.+29.j]\n",
      " [ 5.+30.j  6.+31.j  7.+32.j  8.+33.j  9.+34.j]\n",
      " [10.+35.j 11.+36.j 12.+37.j 13.+38.j 14.+39.j]\n",
      " [15.+40.j 16.+41.j 17.+42.j 18.+43.j 19.+44.j]\n",
      " [20.+45.j 21.+46.j 22.+47.j 23.+48.j 24.+49.j]]\n"
     ]
    }
   ],
   "source": [
    "A= np.arange(25).reshape(5,5) + (1j) * np.arange(25, 50).reshape(5,5)\n",
    "print(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0.+25.j  5.+30.j 10.+35.j 15.+40.j 20.+45.j]\n",
      " [ 1.+26.j  6.+31.j 11.+36.j 16.+41.j 21.+46.j]\n",
      " [ 2.+27.j  7.+32.j 12.+37.j 17.+42.j 22.+47.j]\n",
      " [ 3.+28.j  8.+33.j 13.+38.j 18.+43.j 23.+48.j]\n",
      " [ 4.+29.j  9.+34.j 14.+39.j 19.+44.j 24.+49.j]]\n"
     ]
    }
   ],
   "source": [
    "B = A.T\n",
    "print(B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To obtain the Hermitian conjugate of an array, simply transpose it and obtain the complex conjugate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0.-25.j  5.-30.j 10.-35.j 15.-40.j 20.-45.j]\n",
      " [ 1.-26.j  6.-31.j 11.-36.j 16.-41.j 21.-46.j]\n",
      " [ 2.-27.j  7.-32.j 12.-37.j 17.-42.j 22.-47.j]\n",
      " [ 3.-28.j  8.-33.j 13.-38.j 18.-43.j 23.-48.j]\n",
      " [ 4.-29.j  9.-34.j 14.-39.j 19.-44.j 24.-49.j]]\n"
     ]
    }
   ],
   "source": [
    "A_dagger = A.T.conj()\n",
    "print(A_dagger)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 05:\n",
    "1. Use NumPy to create the three Pauli matrices $\\sigma_x, \\sigma_y, \\sigma_z$ and show that the commutation relations $\\left[\\sigma_x, \\sigma_y\\right] = i \\sigma_z$ and $\\left[\\sigma_z, \\sigma_y\\right] = -i \\sigma_x$, hold true.\n",
    "2. Create the following matrix and vector and multiply them in the usual matrix-vector way.\n",
    "\\begin{align*}\n",
    "A & = \\begin{pmatrix}\n",
    "0 & 1 & 0 & 0\\\\\n",
    "1 & 0 & 0 & 0\\\\\n",
    "0 & 0 & 0 & 1\\\\\n",
    "0 & 0 & 1 & 0\n",
    "\\end{pmatrix}\\\\\n",
    "\\vert{v}\\rangle &= \\begin{pmatrix}\n",
    "1\\\\\n",
    "-1\\\\\n",
    "1\\\\\n",
    "-1\n",
    "\\end{pmatrix}\n",
    "\\end{align*}\n",
    "3. If a unitary transformation $U$ is given by \n",
    "\\begin{pmatrix}\n",
    "0 & 0 & 0 & 1\\\\\n",
    "0 & 0 & -1 & 0\\\\\n",
    "0 & -1 & 0 & 0\\\\\n",
    "1 & 0 & 0 & 0\n",
    "\\end{pmatrix},\n",
    "then, compute the transformed matrix $A^\\prime = UAU^T$ and vector $\\vert{v^\\prime}\\rangle = U \\vert{v}\\rangle$. Show that $A^\\prime\\vert{v^\\prime}\\rangle = U\\left(A\\vert{v}\\rangle\\right)$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reshaping arrays\n",
    "Arrays can be reshaped with the new shape supplied as a tuple to the `.reshape` method. For instance, a $4 \\times 4$ array can be reshaped into a $8 \\times 2$ array as follows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.66190534, 0.91136482, 0.20079742, 0.36789149],\n",
       "       [0.0690701 , 0.04662735, 0.81528806, 0.1804445 ],\n",
       "       [0.58777082, 0.39515522, 0.17799737, 0.78331803],\n",
       "       [0.40864391, 0.79105166, 0.63214028, 0.69704231]])"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.random.random((4,4))\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.66190534, 0.91136482],\n",
       "       [0.20079742, 0.36789149],\n",
       "       [0.0690701 , 0.04662735],\n",
       "       [0.81528806, 0.1804445 ],\n",
       "       [0.58777082, 0.39515522],\n",
       "       [0.17799737, 0.78331803],\n",
       "       [0.40864391, 0.79105166],\n",
       "       [0.63214028, 0.69704231]])"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B = A.reshape(8,2)\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.66190534, 0.91136482, 0.20079742, 0.36789149, 0.0690701 ,\n",
       "        0.04662735, 0.81528806, 0.1804445 ],\n",
       "       [0.58777082, 0.39515522, 0.17799737, 0.78331803, 0.40864391,\n",
       "        0.79105166, 0.63214028, 0.69704231]])"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C = A.reshape(2,8)\n",
    "C"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Arrays of any shape can be flattened to vectors in row-major order."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.66190534, 0.91136482, 0.20079742, 0.36789149, 0.0690701 ,\n",
       "       0.04662735, 0.81528806, 0.1804445 , 0.58777082, 0.39515522,\n",
       "       0.17799737, 0.78331803, 0.40864391, 0.79105166, 0.63214028,\n",
       "       0.69704231])"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "V = A.flatten()\n",
    "V"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Computations on arrays\n",
    "\n",
    "NumPy has special functions that can perform computations on arrays to yield numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5])"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.arange(1, 6)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Sums over all elements\n",
    "np.sum(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "120"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Multiplies all elements\n",
    "np.prod(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These can be combined on the fly with scalar and array operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2 3 4 5 6]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(a+1)\n",
    "np.sum(a+1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "34\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "34"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([1,2,3,2,1])\n",
    "b = np.array([2,3,4,5,4])\n",
    "\n",
    "print(a @ b)\n",
    "np.sum(a * b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also perform operations on array slices. For instance:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6],\n",
       "       [7, 8, 9]])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "array([[5, 6],\n",
       "       [8, 9]])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "28"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "array([1, 5, 9])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "M = np.arange(1, 10).reshape(3,3)\n",
    "display(M)\n",
    "\n",
    "display(M[1:3, 1:3])\n",
    "s1 = np.sum(M[1:3, 1:3])\n",
    "display(s1)\n",
    "\n",
    "display(np.diag(M))\n",
    "s2 = np.sum(np.diag(M))\n",
    "display(s2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.16354624, 0.5589451 , 0.74464038, 0.03487922])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "0.375502734852901"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "0.28760373511116877"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Averages (mean) and standard deviations (std) can also me computed\n",
    "a = np.random.rand(4)\n",
    "display(a)\n",
    "display(np.mean(a))\n",
    "display(np.std(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.9634749 , 0.71714948, 0.5249472 ],\n",
       "       [0.40292622, 0.39014927, 0.15456273],\n",
       "       [0.39922343, 0.5076424 , 0.57344493]])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Note that random matrices of any shape can be created\n",
    "\n",
    "a = np.random.rand(3,3)\n",
    "display(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.99856939, -0.27526011, -1.05217683, ..., -0.40203312,\n",
       "        0.63862949, -0.4877782 ])"
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# A random array with samples chosen from a Gaussian (Normal) distribution should yield close to zero mean and unit standard deviation\n",
    "a = np.random.normal(size=10000)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.0036212158919876132, 0.9945376451413487)"
      ]
     },
     "execution_count": 149,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.mean(a), np.std(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, there are NumPy functions for computing determinants and traces of matrices. The determinant function is in the `np.linalg` submodule."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-2.0000000000000004"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.array([[1,2], \n",
    "              [3,4]])\n",
    "\n",
    "np.linalg.det(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.trace(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 06:\n",
    "\n",
    "1. Use the `np.sum()` function to demonstrate the following relation for $N=5, 10, 20$\n",
    "   \\begin{equation*}\n",
    "   \\sum^N_{n=1} n^2 = \\frac{1}{6}\\;N\\left(N+1\\right)\\left(2N+1\\right)\n",
    "   \\end{equation*}\n",
    "2. Create two random $5\\times 5$ matrices $A,B$ and show that $\\rm{Tr}\\left[AB\\right] = \\rm{Tr}\\left[BA\\right]$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "include_colab_link": true,
   "name": "Lecture-2-Numpy.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "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.11.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}