{
 "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",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "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",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "[1 2 3]\n"
     ]
    }
   ],
   "source": [
    "L = [1, 2, 3]\n",
    "a = np.array(L)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]]\n"
     ]
    }
   ],
   "source": [
    "L = [[1, 2, 3], [4, 5, 6]]\n",
    "a = np.array(L)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Computing the length of the array in `numpy` is done via the `shape` attribute:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "(2, 3)\n"
     ]
    }
   ],
   "source": [
    "print(a.shape)"
   ]
  },
  {
   "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",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "['1' 'CSC243']\n",
      "[1. 2. 3.]\n"
     ]
    }
   ],
   "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)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating `ndarray` objects\n",
    "Numpy `ndarrays` are created:\n",
    "- As empty\n",
    "- As zeros\n",
    "- As ones\n",
    "- From existing data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "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"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "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)"
   ]
  },
  {
   "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",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "[1.5 1.6 1.7 1.8 1.9]\n",
      "[0 1 2 3 4]\n",
      "[10. 20. 30. 40. 50.]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "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)"
   ]
  },
  {
   "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",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "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"
     ]
    },
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x109e07010>]"
      ]
     },
     "metadata": {},
     "execution_count": 8
    },
    {
     "output_type": "display_data",
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {}
    }
   ],
   "source": [
    "import numpy as np\n",
    "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)"
   ]
  },
  {
   "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",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "a =\n",
      "[[1 2]\n",
      " [3 4]\n",
      " [5 6]]\n",
      "min: 1\n",
      "minima (axis=0): [1 2]\n",
      "minima (axis=1): [1 3 5]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "a = np.array([[1,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))"
   ]
  },
  {
   "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",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "2.7593254354391625\n"
     ]
    }
   ],
   "source": [
    "import numpy.random as rand\n",
    "\n",
    "x = rand.uniform(1, 10)\n",
    "print(x)"
   ]
  },
  {
   "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": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "a = 1\n",
    "b = 5\n",
    "y = rand.randint(a, b+1)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `random.randint` generates a random integer between`a` and `b` inclusive. Multiple runs of the same code give different random numbers (that is whole point)."
   ]
  }
 ],
 "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
}
