{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# **The `numpy` module**\n",
    "## Introduction\n",
    "[Numpy](https://numpy.org) is a Python package, it stands for numerical python. Using `numpy` we can perform operations such as:\n",
    "- Mathematical and logical operations on arrays\n",
    "- Operations related to linear algebra\n",
    "- Built-in functions for random number generation"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-09-27T14:28:53.485088Z",
     "start_time": "2026-09-27T14:28:53.477349Z"
    }
   },
   "source": [
    "import numpy as np"
   ],
   "outputs": [],
   "execution_count": 1
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The `ndarray` object\n",
    "The most important object defined in NumPy is an N-dimensional array type called `ndarray`:\n",
    "- It describes the collection of items of the same type\n",
    "- Items in the collection can be accessed using a zero-based index"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-09-27T14:28:53.498923Z",
     "start_time": "2026-09-27T14:28:53.486566Z"
    }
   },
   "source": [
    "L = [1, 2, 3]\n",
    "print(L)\n",
    "a = np.array(L)\n",
    "print(a)"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3]\n",
      "[1 2 3]\n"
     ]
    }
   ],
   "execution_count": 2
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-09-27T14:28:53.507761Z",
     "start_time": "2026-09-27T14:28:53.501648Z"
    }
   },
   "source": [
    "L = [[1, 2, 3], [4, 5, 6]]\n",
    "a = np.array(L)\n",
    "print(a)"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]]\n"
     ]
    }
   ],
   "execution_count": 3
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Computing the length of the array in `numpy` is done via the `shape` attribute:"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-09-27T14:28:53.525452Z",
     "start_time": "2026-09-27T14:28:53.515519Z"
    }
   },
   "source": [
    "print(a.shape)"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 3)\n"
     ]
    }
   ],
   "execution_count": 4
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Unlike Python lists, you can specify the data-type of the items in a `numpy` array. Python automatically casts all the items to the specified `dtype`. Once you specify the `dtype`, mixed types will not be allowed."
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-09-27T14:28:53.541908Z",
     "start_time": "2026-09-27T14:28:53.533154Z"
    }
   },
   "source": [
    "a_mixed = np.array([1, 'CSC243'])\n",
    "print(a_mixed)\n",
    "a_float = np.array([1, 2, 3 ], dtype=float)\n",
    "print(a_float)\n",
    "a_float = np.array([1.5, 2.7, 3.1 ], dtype=int)\n",
    "print(a_float)"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['1' 'CSC243']\n",
      "[1. 2. 3.]\n",
      "[1 2 3]\n"
     ]
    }
   ],
   "execution_count": 5
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating `ndarray` objects\n",
    "Numpy `ndarrays` are created:\n",
    "- As empty : empty function allocates memory without clearing it. The values inside will be arbitrary \"**garbage data**\" left over in your computer's RAM. You must overwrite them before reading from the array.\n",
    "- As zeros\n",
    "- As ones\n",
    "- From existing data"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-09-27T14:28:53.561486Z",
     "start_time": "2026-09-27T14:28:53.552930Z"
    }
   },
   "source": [
    "a = np.empty((3,4), dtype=float)\n",
    "print(a)\n",
    "a = np.zeros((2,4))\n",
    "print(a)\n",
    "a = np.ones((3,2))\n",
    "print(a)\n",
    "a = np.ones((3,), dtype=int)\n",
    "print(a)"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 0. 0. 0.]\n",
      " [0. 0. 0. 0.]\n",
      " [0. 0. 0. 0.]]\n",
      "[[0. 0. 0. 0.]\n",
      " [0. 0. 0. 0.]]\n",
      "[[1. 1.]\n",
      " [1. 1.]\n",
      " [1. 1.]]\n",
      "[1 1 1]\n"
     ]
    }
   ],
   "execution_count": 6
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ranges\n",
    "You can create ranges of data through: \n",
    "- `np.arange(start, stop, step, dtype)`: returns an `ndarray` object containing evenly spaced values within a given range.\n",
    "- `np.arange(stop, dtype)`: returns an `ndarray` object containing evenly spaced values from 0 till stop-1.\n",
    "- `np.linspace(start, stop, num, dtype)`: instead of step size, the number **num** of evenly spaced values in the interval is specified."
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-09-27T14:28:53.580464Z",
     "start_time": "2026-09-27T14:28:53.572538Z"
    }
   },
   "source": [
    "r = np.arange(1.5, 2, 0.1)\n",
    "print(r)\n",
    "r = np.arange(5)\n",
    "print(r)\n",
    "r = np.linspace(10, 50, 5)\n",
    "print(r)"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.5 1.6 1.7 1.8 1.9]\n",
      "[0 1 2 3 4]\n",
      "[10. 20. 30. 40. 50.]\n"
     ]
    }
   ],
   "execution_count": 7
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One advantage of using `numpy.arange` instead of range is that the step-size can\n",
    "be of type `float` in this case."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Math functions using `numpy`\n",
    "Mathematical functions can also be accessed from the `numpy` module (sin,\n",
    "cos, exp, ceil, floor, etc.). The advantage of using `numpy` functions is that we can pass a full array as an input (in contrast to the functions from the `math` module, which take a single value as input).\n",
    "\n",
    "Example: plotting exp(-x)*cos(2πx), for x = [0, 0.1, 0.2, …, 9.9]"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-09-27T14:28:53.660566Z",
     "start_time": "2026-09-27T14:28:53.589283Z"
    }
   },
   "source": [
    "from math import pi\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "X = np.arange(0, 10, 0.1)\n",
    "Y = np.exp(-X)*np.cos(2*pi*X)\n",
    "print(Y)\n",
    "plt.plot(X, Y)"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1.00000000e+00  7.32028848e-01  2.53001717e-01 -2.28925420e-01\n",
      " -5.42300309e-01 -6.06530660e-01 -4.43997940e-01 -1.53453298e-01\n",
      "  1.38850286e-01  3.28921764e-01  3.67879441e-01  2.69298364e-01\n",
      "  9.30741301e-02 -8.42169556e-02 -1.99501135e-01 -2.23130160e-01\n",
      " -1.63337714e-01 -5.64523135e-02  5.10801656e-02  1.21003555e-01\n",
      "  1.35335283e-01  9.90693315e-02  3.42400590e-02 -3.09816865e-02\n",
      " -7.33923659e-02 -8.20849986e-02 -6.00885870e-02 -2.07676456e-02\n",
      "  1.87913428e-02  4.45147201e-02  4.97870684e-02  3.64455703e-02\n",
      "  1.25962138e-02 -1.13975255e-02 -2.69995426e-02 -3.01973834e-02\n",
      " -2.21053558e-02 -7.63998984e-03  6.91294868e-03  1.63760504e-02\n",
      "  1.83156389e-02  1.34075760e-02  4.63388808e-03 -4.19291532e-03\n",
      " -9.93257663e-03 -1.11089965e-02 -8.13210594e-03 -2.81059519e-03\n",
      "  2.54313170e-03  6.02441225e-03  6.73794700e-03  4.93237158e-03\n",
      "  1.70471216e-03 -1.54248735e-03 -3.65399074e-03 -4.08677144e-03\n",
      " -2.99163459e-03 -1.03396019e-03  9.35565868e-04  2.21625741e-03\n",
      "  2.47875218e-03  1.81451810e-03  6.27128556e-04 -5.67449383e-04\n",
      " -1.34422807e-03 -1.50343919e-03 -1.10056086e-03 -3.80372697e-04\n",
      "  3.44175449e-04  8.15315539e-04  9.11881966e-04  6.67523905e-04\n",
      "  2.30707703e-04 -2.08752962e-04 -4.94513872e-04 -5.53084370e-04\n",
      " -4.04873715e-04 -1.39931295e-04  1.26615072e-04  2.99937825e-04\n",
      "  3.35462628e-04  2.45568321e-04  8.48726207e-05 -7.67959230e-05\n",
      " -1.81921487e-04 -2.03468369e-04 -1.48944716e-04 -5.14778466e-05\n",
      "  4.65790818e-05  1.10340959e-04  1.23409804e-04  9.03395368e-05\n",
      "  3.12228923e-05 -2.82516412e-05 -6.69251749e-05 -7.48518299e-05\n",
      " -5.47936988e-05 -1.89376414e-05  1.71354866e-05  4.05921705e-05]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x10c18f190>]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 8
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Statistical Operations\n",
    "We can compute the minimum and maximum through `np.amin(a, axis=)` and `np.amax(a, axis=)`. The `axis` keyword specifies the dimension over which min/max is computed. If not specified, the min/max will be computed over the whole array."
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-09-27T14:28:53.708443Z",
     "start_time": "2026-09-27T14:28:53.672895Z"
    }
   },
   "source": [
    "a = np.array([[7,2], [3,4], [5,6]])\n",
    "print(\"a =\\n\" + str(a))\n",
    "print(\"min:\", np.amin(a))\n",
    "print(\"minima (axis=0):\", np.amin(a, axis=0))\n",
    "print(\"minima (axis=1):\", np.amin(a, axis=1))"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a =\n",
      "[[7 2]\n",
      " [3 4]\n",
      " [5 6]]\n",
      "min: 2\n",
      "minima (axis=0): [3 2]\n",
      "minima (axis=1): [2 3 5]\n"
     ]
    }
   ],
   "execution_count": 9
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also compute the average (mean), median, standard deviation and variance. We use in these cases `np.mean()`, `np.median()`, `np.std()`, and `np.var()`, respectively. All these functions also admit an `axis` keyword parameter like `np.amin`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Generation Random Numbers\n",
    "We can generate random numbers using `numpy.random`. Here are a few examples:"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-09-27T14:28:53.746975Z",
     "start_time": "2026-09-27T14:28:53.718539Z"
    }
   },
   "source": [
    "import numpy.random as rand\n",
    "\n",
    "x = rand.uniform(1, 10)\n",
    "print(x)"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8.323015843186308\n"
     ]
    }
   ],
   "execution_count": 10
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `random.uniform(x, y)` function generates a uniformly-distributed random `float` in the real interval [x, y]. The default values are `x=0, y=1`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `random.randint` generates a random integer between `a` and `b` inclusive.\n",
    "Multiple runs of the same code give different random numbers (that is whole point)."
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-09-27T14:28:53.773055Z",
     "start_time": "2026-09-27T14:28:53.761396Z"
    }
   },
   "source": [
    "a = np.random.randint(3,500)\n",
    "print(\"a=\",a)\n"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a= 263\n"
     ]
    }
   ],
   "execution_count": 11
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-09-27T14:28:53.794161Z",
     "start_time": "2026-09-27T14:28:53.781656Z"
    }
   },
   "source": [
    "a = 1\n",
    "b = 5\n",
    "y = rand.randint(a, b+1)\n",
    "print(y)"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "execution_count": 12
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-09-27T14:28:53.809419Z",
     "start_time": "2026-09-27T14:28:53.801086Z"
    }
   },
   "source": [
    "\n",
    "arrayD = np.random.randint(3,500,10)\n",
    "print(arrayD.shape)\n",
    "print (\"arrayD=\" , arrayD)"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10,)\n",
      "arrayD= [253 378 103 420  65 180  88 181 388 141]\n"
     ]
    }
   ],
   "execution_count": 13
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pseudo-random values\n",
    "Numpy can be used to generate pseudo-random values from various distributions. \n",
    "\n",
    "In particular, a very useful distribution is the standard normal (zero mean and unit variance).\n",
    "\n",
    "Let's generate two vectors sampled from the normal distribution, using a length parameter that we'll be able to change if needed.\n",
    "\n",
    "The **numpy.random.randn()** function in Python's NumPy library is used to generate random numbers sampled from the standard normal distribution."
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-09-27T14:28:53.830040Z",
     "start_time": "2026-09-27T14:28:53.817757Z"
    }
   },
   "source": [
    "length = 50\n",
    "\n",
    "vecA = np.random.randn(length)\n",
    "vecB = np.random.randn(2*length)\n",
    "\n",
    "print(\"vecA:\" , vecA)\n",
    "print(\"vecB:\" , vecB)"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "vecA: [-2.10999809 -2.11287348  1.25280955 -0.4924122  -0.2719082  -0.46451978\n",
      " -0.64062689  0.19295273 -0.41339376 -0.3080825  -0.83406057  0.64042542\n",
      "  0.33229005  1.14290607  1.32707561 -0.51302455  0.97914793  1.91572189\n",
      " -1.69386572 -1.49945308 -0.9944069   0.06943031 -1.06752387 -0.39937929\n",
      "  1.99114138 -0.1341258  -0.80091109  2.10253385  1.35524086 -1.58320581\n",
      "  0.93282241  0.92543729  1.09713833 -1.44882033 -0.69751291 -0.36215201\n",
      " -0.88251173  0.07514971 -0.25168008 -1.36534188 -1.66889414  0.32727418\n",
      " -0.13753305  1.0402394  -1.03755714 -0.45327112 -0.48093412 -1.0695069\n",
      "  0.93856271 -1.81933384]\n",
      "vecB: [ 0.61000751  0.74915139  0.45793863  1.32809655  0.95842044  0.80711744\n",
      " -0.22509216 -0.13273978  0.22428596 -0.41573978 -1.12103327  1.55300499\n",
      "  1.03583227 -0.30461149 -0.97857771 -0.41309167 -2.17345279 -0.20978699\n",
      "  0.23694952  0.64353891  0.27651094  0.60680622 -0.38087215  1.7829058\n",
      " -0.30146565  2.00674765  0.37022398 -0.7213519   1.06728759  0.13603953\n",
      "  1.08551771 -0.09959652 -1.68196758 -1.14129733 -2.01333562 -0.38119678\n",
      " -0.88047318  0.2568253   0.01893283 -0.64069811 -0.05745972  0.24583993\n",
      " -0.73779167  0.83560195 -0.14166213 -0.29284934 -1.12737178  0.02145714\n",
      " -0.92795249  0.006617    0.57357712 -1.54218791  0.40486226  0.19323385\n",
      "  0.011521   -0.39188825  0.73097972  1.0469983   1.24918161  1.57031582\n",
      " -1.32300042 -0.78927998  0.57348572 -0.24271261 -0.83282858  0.06148128\n",
      " -0.85546067 -0.31907881 -0.13937268  1.57481757 -0.05967344  0.70178645\n",
      "  1.19600514  0.21307818 -1.13968704 -1.24644357 -0.15612841 -0.14511488\n",
      " -0.26215745  0.49376606 -0.057528    0.29816377  0.15734146  0.97027566\n",
      "  2.2217015   0.4296192   0.07338254 -0.04901035 -0.42025307 -1.49786917\n",
      " -0.92738247  0.19970072 -0.96130874 -1.35304152 -0.20948683 -0.3770746\n",
      "  0.04890955 -0.8281197   0.54528106 -0.26623394]\n"
     ]
    }
   ],
   "execution_count": 14
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "vecA and vecB are numpy *arrays*. One of their attributes can be fetched to check their *shape*"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-09-27T14:28:53.853955Z",
     "start_time": "2026-09-27T14:28:53.844580Z"
    }
   },
   "source": [
    "print(vecA.shape)\n",
    "print(vecB.shape)"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(50,)\n",
      "(100,)\n"
     ]
    }
   ],
   "execution_count": 15
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numpy arrays can be vectors as well as matrices, or any tensor. For example the following code will create tensors with 3 dimensions using the standard normal"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-09-27T14:28:53.876141Z",
     "start_time": "2026-09-27T14:28:53.866276Z"
    }
   },
   "source": [
    "arrayC = np.random.randn(3,10,4)\n",
    "print(arrayC.shape)\n",
    "print(arrayC)"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, 10, 4)\n",
      "[[[ 0.6103493  -0.9977386   1.24149819  0.59300844]\n",
      "  [-0.73872367  0.60845882  0.28568399 -0.43267838]\n",
      "  [-1.00679062  0.83438667 -0.80427253 -1.36078233]\n",
      "  [ 0.44765166  2.14543953 -1.16122586  0.35655495]\n",
      "  [ 0.25315243  0.86576808 -0.57761026 -0.73250677]\n",
      "  [-2.85917571  1.13342275  0.01235514  0.42349046]\n",
      "  [-0.71878794 -0.30369568  0.37075242  0.05745539]\n",
      "  [ 0.02791402  0.41983534 -1.00716576  1.34233683]\n",
      "  [-0.0413135  -1.41137134 -0.02696279  1.39171478]\n",
      "  [ 0.331664   -0.79183008  1.77118333 -1.44127238]]\n",
      "\n",
      " [[-1.38259346 -0.96248992 -0.24504574  0.08487525]\n",
      "  [ 2.50138512 -1.10035743 -0.60987928  0.040802  ]\n",
      "  [-0.84004769 -1.55645974  1.43365243 -1.2556008 ]\n",
      "  [ 0.78793701 -1.96177205 -3.01223948 -0.50406417]\n",
      "  [ 0.2043025   0.39563536 -0.75635317  0.67337065]\n",
      "  [-0.22398293 -0.50307142  1.15947818  0.0841907 ]\n",
      "  [ 0.24221879 -0.66059901 -1.38996028 -1.62408543]\n",
      "  [ 0.0883038   1.36255269 -2.08206203  0.24684805]\n",
      "  [ 1.54575432  1.18894425  0.08715927  1.08013783]\n",
      "  [ 1.42112677  1.09184144  0.48053391  0.09083689]]\n",
      "\n",
      " [[ 0.55342773  1.52352332  0.66681621  0.80510851]\n",
      "  [-0.85783124  0.46091983 -0.25287231  1.98495604]\n",
      "  [ 0.64906538 -2.03134777  0.74839709 -0.68752474]\n",
      "  [ 1.05048703  0.66923679  1.52298283 -1.43924225]\n",
      "  [-1.2473455  -0.94141396 -0.22155136 -0.57578813]\n",
      "  [-0.92528658  1.06919995  2.54984813 -0.47304496]\n",
      "  [-1.39855088 -0.75347335 -0.64908361  1.25573668]\n",
      "  [ 2.02022871 -1.39817262  0.0887552  -0.12159651]\n",
      "  [ 2.76382791  0.55718271 -0.21643165  0.03328396]\n",
      "  [-1.82241942  0.48814035 -0.95816279 -1.60424608]]]\n"
     ]
    }
   ],
   "execution_count": 16
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A very important features of arrays is the fact they can be used as *iterables*. For example, you can iterate over the dimensions of an array by simply \"looping\" over it using a *for* loop"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-09-27T14:28:53.892219Z",
     "start_time": "2026-09-27T14:28:53.883691Z"
    }
   },
   "source": [
    "for dim in arrayC:\n",
    "    print(dim.shape)"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10, 4)\n",
      "(10, 4)\n",
      "(10, 4)\n"
     ]
    }
   ],
   "execution_count": 17
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Also possible to enumerate along the dimension in order to get the index of the current \"smaller\" array"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-09-27T14:28:53.914545Z",
     "start_time": "2026-09-27T14:28:53.903434Z"
    }
   },
   "source": [
    "print('Initial shape is %d %d %d' % (arrayC.shape[0],arrayC.shape[1],arrayC.shape[2]))\n",
    "print('Iterating over the first dimension using an index k')\n",
    "for k,curdim in enumerate(arrayC):\n",
    "    print('k = %d, shape is %d %d' % (k,curdim.shape[0],curdim.shape[1]))"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initial shape is 3 10 4\n",
      "Iterating over the first dimension using an index k\n",
      "k = 0, shape is 10 4\n",
      "k = 1, shape is 10 4\n",
      "k = 2, shape is 10 4\n"
     ]
    }
   ],
   "execution_count": 18
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another important operation when working with Numpy Arrays is *reshaping*. Essentially, *reshaping* consists in changing the organisation of the array (in terms of dimension), while keeping the same number of elements. For example, a 20x10 2D array can be converted into a 4x5x10 array"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-09-27T14:28:53.944977Z",
     "start_time": "2026-09-27T14:28:53.925610Z"
    }
   },
   "source": [
    "A = np.random.randint(1,50,(10,20))\n",
    "print('Initial shape of A is %d x %d' % (A.shape[0],A.shape[1]))\n",
    "print(A)\n",
    "B = A.reshape((4,5,10))\n",
    "print('B is A reshaped to %d x %d x %d' % (B.shape[0],B.shape[1],B.shape[2]))\n",
    "print(B)"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initial shape of A is 10 x 20\n",
      "[[13 25 31 17 34 15 48 41 38 26 43 38 37  4 36 21 45 34 37 35]\n",
      " [ 8 26 36 21 28 14 19 47 34 31 20 37 26  3 20  7 40 19 32 44]\n",
      " [48  6 44  7 45  9  1 16 12  9 16 24 30 15 34 14 15  2 14 28]\n",
      " [ 7  3  5 26 30 38  8 43 25  4 36  6  9 43 18 31 10 13 26 26]\n",
      " [33 47 43 28 12 32 14 31 34  4 16 35 25 41 22  1 41 36 31  5]\n",
      " [13 12  6 10 25 16 19 34  9 24 22  4 19 29 29 25 38  8 35 26]\n",
      " [30 28 25 23 27 43 49 47 24 27 34 23  1 48  5 19 26 22 34 47]\n",
      " [41 12 25 39 37  9 22  7  2 15 11 24 40 24 23 40 21 14 26  4]\n",
      " [37 10  5 37 34  1  9  8 17  8  8 25 18 39  1 41 14 44 44  2]\n",
      " [31 15 19 38 44 31 31  6 36 23 14  4 48 36 32 23 47 27 48 12]]\n",
      "B is A reshaped to 4 x 5 x 10\n",
      "[[[13 25 31 17 34 15 48 41 38 26]\n",
      "  [43 38 37  4 36 21 45 34 37 35]\n",
      "  [ 8 26 36 21 28 14 19 47 34 31]\n",
      "  [20 37 26  3 20  7 40 19 32 44]\n",
      "  [48  6 44  7 45  9  1 16 12  9]]\n",
      "\n",
      " [[16 24 30 15 34 14 15  2 14 28]\n",
      "  [ 7  3  5 26 30 38  8 43 25  4]\n",
      "  [36  6  9 43 18 31 10 13 26 26]\n",
      "  [33 47 43 28 12 32 14 31 34  4]\n",
      "  [16 35 25 41 22  1 41 36 31  5]]\n",
      "\n",
      " [[13 12  6 10 25 16 19 34  9 24]\n",
      "  [22  4 19 29 29 25 38  8 35 26]\n",
      "  [30 28 25 23 27 43 49 47 24 27]\n",
      "  [34 23  1 48  5 19 26 22 34 47]\n",
      "  [41 12 25 39 37  9 22  7  2 15]]\n",
      "\n",
      " [[11 24 40 24 23 40 21 14 26  4]\n",
      "  [37 10  5 37 34  1  9  8 17  8]\n",
      "  [ 8 25 18 39  1 41 14 44 44  2]\n",
      "  [31 15 19 38 44 31 31  6 36 23]\n",
      "  [14  4 48 36 32 23 47 27 48 12]]]\n"
     ]
    }
   ],
   "execution_count": 19
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One property of numpy that is really important is broadcasting. The goal of broadcasting is to simplify the vectorization of certain operations when the vectors do not have the same shape. For example you can easily perform element-wise multiplication.\n"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-09-27T14:28:53.960707Z",
     "start_time": "2026-09-27T14:28:53.952868Z"
    }
   },
   "source": [
    "x = np.array([2,3])\n",
    "y = np.array([[4,1],[9,10],[12,13]])\n",
    "result = x*y\n",
    "print(\"X: \",x)\n",
    "print(\"Y: \")\n",
    "print(y)\n",
    "print(\"X shape is: \",x.shape)\n",
    "print(\"Y shape is: \",y.shape)\n",
    "print(\"Element-wise multiplication shape:\", result.shape)\n",
    "print(\"Element-wise multiplication result:\")\n",
    "print(result)\n"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X:  [2 3]\n",
      "Y: \n",
      "[[ 4  1]\n",
      " [ 9 10]\n",
      " [12 13]]\n",
      "X shape is:  (2,)\n",
      "Y shape is:  (3, 2)\n",
      "Element-wise multiplication shape: (3, 2)\n",
      "Element-wise multiplication result:\n",
      "[[ 8  3]\n",
      " [18 30]\n",
      " [24 39]]\n"
     ]
    }
   ],
   "execution_count": 20
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another very powerful tool in numpy is indexing. You can use either an integer vector or a boolean vector to choose which indexes you want to extract from your numpy tensor.\n",
    "\n",
    "Consider that we want to extract all elements from the first line of your vector y that have a higher value than 1, you would have to do:"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-09-27T14:28:53.987247Z",
     "start_time": "2026-09-27T14:28:53.971500Z"
    }
   },
   "source": [
    "first_row = y[0]\n",
    "print(first_row)\n",
    "first_row_higher_than_one = first_row > 1\n",
    "print(\"Result: \", first_row[first_row_higher_than_one])"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4 1]\n",
      "Result:  [4]\n"
     ]
    }
   ],
   "execution_count": 21
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also choose specific lines to query, for example if you want to query lines 0 and 2"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-09-27T14:28:54.018359Z",
     "start_time": "2026-09-27T14:28:53.998919Z"
    }
   },
   "source": [
    "rows = [0,2]\n",
    "rows_result = y[rows]\n",
    "values_higher_than_one = rows_result > 1\n",
    "print(\"Result: \", rows_result[values_higher_than_one])"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Result:  [ 4 12 13]\n"
     ]
    }
   ],
   "execution_count": 22
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also save and load your numpy tensors using np.savez and np.load. This will be really important in the next courses as this enable you to generate your data only once instead of having to do all the calculations every time you need your data."
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-09-27T14:28:54.035188Z",
     "start_time": "2026-09-27T14:28:54.020253Z"
    }
   },
   "source": [
    "filename = \"y.npz\"\n",
    "source_tensor = y\n",
    "np.savez(filename,data=source_tensor)"
   ],
   "outputs": [],
   "execution_count": 23
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-09-27T14:28:54.057261Z",
     "start_time": "2026-09-27T14:28:54.038187Z"
    }
   },
   "source": [
    "loaded_npz = np.load(filename)\n",
    "loaded_tensor = loaded_npz[\"data\"]\n",
    "print(\"Your tensor was loaded and contains: \", loaded_tensor)"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Your tensor was loaded and contains:  [[ 4  1]\n",
      " [ 9 10]\n",
      " [12 13]]\n"
     ]
    }
   ],
   "execution_count": 24
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-09-27T14:28:54.068738Z",
     "start_time": "2026-09-27T14:28:54.062477Z"
    }
   },
   "source": [],
   "outputs": [],
   "execution_count": 24
  }
 ],
 "metadata": {
  "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.13.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
