NumPy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# NumPy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numpy is short for numerical Python, and is essential to most Python workflows. While Python does actually provided an Array type in the `array` module, it is rarely used because it only supports 1D arrays and also lacks much of the rich functionality that makes `ndarrays` so fundamental to much of the Python infrastructure.\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "Numpy provides an efficient representation of arrays, matrices and tensors with a range of numerical operations defined on for the object type."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numpy's main object is the homogeneuous multidimensional array. It is a table of elements (usually numeric), all of the same type and indexed by a tuple of non-negative integers. In numpy (and Pandas), dimensions are refered to as axes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "# Additional packages we will use\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import sys"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Declaration"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are many ways to make an array. One of the most common is converting from a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.5, 3.2, 7.6])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array = np.array([1.5, 3.2, 7.6])    # Make an array from a list\n",
    "array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another is using the `arange` method. \n",
    "\n",
    "It takes the form **$numpy.arange([start, ]stop, [step, ]dtype=None)$**\n",
    "\n",
    "**REMEMBER**: Arguments in `[]` are optional! This is standard notation in the Python docs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "range_arr = np.arange(15)\n",
    "range_arr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `arange` function has additional value beyond declaring arrays. \n",
    "\n",
    "You can use it to make your iteration faster! Because the implementation of a loop or comprehension in Python is based on the type of iterator object used in the call, often using `arange` instead of `range` can move your looping out of base Python and into 'NumPy Space', where the iteration instead gets executed in highly optimzed C code.\n",
    "\n",
    "**TL;DR** - Use `arange` instead of `range` when iterating over a numeric sequence, it is faster!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are a number of additional other declaration methods for different use cases, we will get into them later."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Array Attributes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `ndarray` type in NumPy comes with a variety of built-in properties describing the object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "range_arr.ndim    # How many dimensions does the array have?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(15,)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "range_arr.shape    # What are the dimensions of the array? (rows, columns, ...)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int64')"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "range_arr.dtype    # What datatype are the array elements?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "range_arr.itemsize    # How big is on array element?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "range_arr.size    # How many array elements are there?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "120"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "range_arr.nbytes    # How big is the array in bytes?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<memory at 0x7f6e9b3d0dc0>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "range_arr.data    # Returns a buffer object containing the array data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Slicing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The same powerful *slicing* syntax that works for `strings`, `lists` and other sequence types also work for `ndarrays`.\n",
    "\n",
    "\n",
    "**RECALL:** Slicing syntax follows the $start:stop:step$ pattern. It returns a `view` object and allows modification of the original array by *refrence*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "range_arr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Suppose you want to retrieve 3, 4, 5. How would you do it?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 4, 5])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "range_arr[3:6]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How about the number 2, 5, 8?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 5, 8])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "range_arr[2:9:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What about 13, 11, 9, 7?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The slicing syntax is simple for 1D arrays, but can get complicated (and powerful) when working with multi-dimensional arrays. We will revist this after discussion different ways to intialize `arrays`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Intialization\n",
    "\n",
    "It is advantageous to predeclare large arrays in situations where you know the size that you need. There are several NumPy methods that make this easy to do! \n",
    "\n",
    "By predeclaring your array, you avoid the memory allocations that take place as the array grows; this speeds up your code, especially for large arrays.\n",
    "\n",
    "For more information see: [Array creation routines documentation](https://numpy.org/doc/stable/reference/routines.array-creation.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Arrays of zeros: \n",
    "\n",
    "$numpy.zeros(shape, dtype=float, order='C')$\n",
    "\n",
    "**ASIDE:** What does the argument `order` do?\n",
    "\n",
    ">Row vs Column Major Order:\n",
    ">  - All arrays in are stored in memory contiguously\n",
    ">  - The 'shape' of an array does not change the representation in memory, it just changes the way the array >is indexed\n",
    ">  - There are two organization themes:\n",
    ">  \n",
    ">  ![](https://upload.wikimedia.org/wikipedia/commons/thumb/4/4d/Row_and_column_major_order.svg/170px-Row_and_column_major_order.svg.png)\n",
    "> \n",
    ">There is an array property that lets use see details about the internal representation of an array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "zero_array = np.zeros((2, 5, 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "zero_array.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[0., 0., 0.],\n",
       "        [0., 0., 0.],\n",
       "        [0., 0., 0.],\n",
       "        [0., 0., 0.],\n",
       "        [0., 0., 0.]],\n",
       "\n",
       "       [[0., 0., 0.],\n",
       "        [0., 0., 0.],\n",
       "        [0., 0., 0.],\n",
       "        [0., 0., 0.],\n",
       "        [0., 0., 0.]]])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "zero_array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "  C_CONTIGUOUS : True\n",
       "  F_CONTIGUOUS : False\n",
       "  OWNDATA : True\n",
       "  WRITEABLE : True\n",
       "  ALIGNED : True\n",
       "  WRITEBACKIFCOPY : False\n",
       "  UPDATEIFCOPY : False"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "zero_array.flags"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, *C_CONTIGUOUS* represents column-major order and *F_CONTIGUOUS* is for row-major order."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Arrays of ones:\n",
    "\n",
    "$numpy.ones(shape, dtype=None, order='C')$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "ones_array = np.ones((2, 3, 4), dtype='int8', order='F')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[1, 1, 1, 1],\n",
       "        [1, 1, 1, 1],\n",
       "        [1, 1, 1, 1]],\n",
       "\n",
       "       [[1, 1, 1, 1],\n",
       "        [1, 1, 1, 1],\n",
       "        [1, 1, 1, 1]]], dtype=int8)"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ones_array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "  C_CONTIGUOUS : False\n",
       "  F_CONTIGUOUS : True\n",
       "  OWNDATA : True\n",
       "  WRITEABLE : True\n",
       "  ALIGNED : True\n",
       "  WRITEBACKIFCOPY : False\n",
       "  UPDATEIFCOPY : False"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ones_array.flags    # Now our array is in row-major order"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Understanding the internal representation of arrays helps us peel back the simplicity of Python syntax and get a deeper understanding of how the language works. Row vs column major order is utilized in NumPy to perform by reference transposition of matrix and tensor objects - in this operation the underlyling data is not changed, just the order of the index."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[1 1]\n",
      "  [1 1]\n",
      "  [1 1]]\n",
      "\n",
      " [[1 1]\n",
      "  [1 1]\n",
      "  [1 1]]\n",
      "\n",
      " [[1 1]\n",
      "  [1 1]\n",
      "  [1 1]]\n",
      "\n",
      " [[1 1]\n",
      "  [1 1]\n",
      "  [1 1]]]\n"
     ]
    }
   ],
   "source": [
    "print(ones_array.T) # .transpose()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "  C_CONTIGUOUS : True\n",
       "  F_CONTIGUOUS : False\n",
       "  OWNDATA : False\n",
       "  WRITEABLE : True\n",
       "  ALIGNED : True\n",
       "  WRITEBACKIFCOPY : False\n",
       "  UPDATEIFCOPY : False"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ones_array.T.flags"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see here that a transpose operation (`.T`) inverts row vs column major order. Similar to slicing, it returns a *view* of the object, not a copy. Thus modifying a transposed array will change the original array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "ones_array.T[1, 0, 1] = 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[1, 1, 1, 1],\n",
       "        [1, 1, 1, 1],\n",
       "        [1, 1, 1, 1]],\n",
       "\n",
       "       [[1, 2, 1, 1],\n",
       "        [1, 1, 1, 1],\n",
       "        [1, 1, 1, 1]]], dtype=int8)"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ones_array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Arrays With Custom Values:\n",
    "\n",
    "$numpy.full(shape, fill\\_value, dtype=None, order='C')$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "custom_array = np.full((2, 3), 0.+0.j)    # An array with complex numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.+0.j, 0.+0.j, 0.+0.j],\n",
       "       [0.+0.j, 0.+0.j, 0.+0.j]])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "custom_array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('complex128')"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "custom_array.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also replicate the shape of other arrays using `np.full_like`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "like_ones_array = np.full_like(ones_array, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[4, 4, 4, 4],\n",
       "        [4, 4, 4, 4],\n",
       "        [4, 4, 4, 4]],\n",
       "\n",
       "       [[4, 4, 4, 4],\n",
       "        [4, 4, 4, 4],\n",
       "        [4, 4, 4, 4]]], dtype=int8)"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "like_ones_array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "like_ones_array.shape == ones_array.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For most of the initialization methods discussed, there exits a simliar `*_like` method for copying the shape of existing arrays."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Numerical Sequences"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We already discussed on way to declare numerical sequences in the **Declaration** section. What was it?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# declare sequences question?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we want an array from 1 to 5 by 0.15, how do we declare it?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.  , 1.15, 1.3 , 1.45, 1.6 , 1.75, 1.9 , 2.05, 2.2 , 2.35, 2.5 ,\n",
       "       2.65, 2.8 , 2.95, 3.1 , 3.25, 3.4 , 3.55, 3.7 , 3.85, 4.  , 4.15,\n",
       "       4.3 , 4.45, 4.6 , 4.75, 4.9 , 5.05, 5.2 , 5.35, 5.5 , 5.65, 5.8 ,\n",
       "       5.95])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.arange(1, 6, 0.15)\n",
    "arr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Evenly Spaced Numbers Over An Interval"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Can be declared using **$linspace(start, stop[, num, endpoint, …])$**.\n",
    "\n",
    "Say we want a sequence from 1 to 5 in intervals of divided into 13 equal size chunks?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.        , 1.33333333, 1.66666667, 2.        , 2.33333333,\n",
       "       2.66666667, 3.        , 3.33333333, 3.66666667, 4.        ,\n",
       "       4.33333333, 4.66666667, 5.        ])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linspace(1, 5, 13)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What does the `endpoint` argument do?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.        , 1.30769231, 1.61538462, 1.92307692, 2.23076923,\n",
       "       2.53846154, 2.84615385, 3.15384615, 3.46153846, 3.76923077,\n",
       "       4.07692308, 4.38461538, 4.69230769])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linspace(1, 5, 13, endpoint=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see that `endpoint` is a boolean argument which makes the returned array *exclusive* of the `stop` value."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Log Intervals"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Can be declared using **$logspace(start, stop[, num, endpoint, base, …])$**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2.        , 2.05739147, 2.11642982, 2.17716233, 2.2396376 ,\n",
       "       2.30390564, 2.37001791, 2.43802731, 2.50798829, 2.57995685,\n",
       "       2.65399061, 2.73014882, 2.80849244, 2.88908419, 2.97198858,\n",
       "       3.05727197, 3.14500263, 3.23525079, 3.32808868, 3.42359063,\n",
       "       3.52183307, 3.62289466, 3.72685628, 3.83380115, 3.94381489,\n",
       "       4.05698555, 4.17340372, 4.2931626 , 4.41635805, 4.54308869,\n",
       "       4.67345595, 4.8075642 , 4.94552078, 5.08743612, 5.23342383,\n",
       "       5.38360077, 5.53808714, 5.69700662, 5.8604864 , 6.02865736,\n",
       "       6.2016541 , 6.37961511, 6.56268285, 6.75100385, 6.94472885,\n",
       "       7.14401294, 7.34901563, 7.55990103, 7.77683793, 8.        ])"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.logspace(1, 3, base=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For `logspace`, start and stop represent `base ** start` to `base ** stop`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "log_array = np.logspace(1, 5, 20, base=3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  3.        ,   3.78066185,   4.764468  ,   6.0042808 ,\n",
       "         7.56671845,   9.53573458,  12.01712931,  15.1442341 ,\n",
       "        19.08507602,  24.05140626,  30.31007801,  38.19738518,\n",
       "        48.13713227,  60.66340648,  76.44927548,  96.34295303,\n",
       "       121.4133756 , 153.00763898, 192.82338103, 243.        ])"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "log_array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f6e9924d250>]"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(log_array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(log_array, )\n",
    "plt.yscale('log')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reshaping and Casting Arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similar to the R functions for reshaping `data.frame`s, NumPy provides simple methods to customize the shape of an array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "flat_array = np.linspace(1, 5, 6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "flat_array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "flat_array.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "flat_array.reshape((3, 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "flat_array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Part 4: Numpy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numpy is short for numerical Python, and is essential to most Python workflows. While Python does actually provided an Array type in the `array` module, it is rarely used because it only supports 1D arrays and also lacks much of the rich functionality that makes `ndarrays` so fundamental to much of the Python infrastructure.\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "Numpy provides an efficient representation of arrays, matrices and tensors with a range of numerical operations defined on for the object type."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numpy's main object is the homogeneuous multidimensional array. It is a table of elements (usually numeric), all of the same type and indexed by a tuple of non-negative integers. In numpy (and Pandas), dimensions are refered to as axes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import sys"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Declaration"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are many ways to make an array. One of the most common is converting from a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "array = np.array([1.5, 3.2, 7.6]) # Make an array from a list\n",
    "array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another is using the `arange` method. It takes the form **$numpy.arange([start, ]stop, [step, ]dtype=None)$**\n",
    "\n",
    "**REMEMBER**: Arguments in `[]` are optional! This is standard notation in the Python docs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "range_arr = np.arange(15)\n",
    "range_arr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `arange` function has additional value beyond declaring arrays. \n",
    "\n",
    "You can use it to make your iteration faster! Because the implementation of a loop or comprehension in Python is based on the type of iterator object used in the call, often using `arange` instead of `range` can move your looping out of base Python and into 'NumPy Space', where the iteration instead gets executed in highly optimzed C code.\n",
    "\n",
    "**TL;DR** - Use `arange` instead of `range` when iterating over a numeric sequence, it is faster!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are a number of additional other declaration methods for different use cases, we will get into them later."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Array Attributes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `ndarray` type in NumPy comes with a variety of built-in properties describing the object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "range_arr.ndim    # How many dimensions does the array have?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "range_arr.shape    # What are the dimensions of the array? (rows, columns, ...)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "range_arr.dtype    # What datatype are the array elements?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "range_arr.itemsize    # How big is on array element?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "range_arr.size    # How many array elements are there?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "range_arr.nbytes    # How big is the array in bytes?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "range_arr.data    # Returns a buffer object containing the array data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Slicing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The same powerful *slicing* syntax that works for `strings`, `lists` and other sequence types also work for `ndarrays`.\n",
    "\n",
    "\n",
    "**RECALL:** Slicing syntax follows the $start:stop:step$ pattern."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "range_arr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Suppose you want to retrieve 3, 4, 5. How would you do it?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "range_arr[]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How about the number 2, 5, 8?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "range_arr[]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What about 13, 11, 9, 7?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "range_arr[]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The slicing syntax is simple for 1D arrays, but can get complicated (and powerful) when working with multi-dimensional arrays. We will revist this after discussion different ways to intialize `arrays`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Intialization\n",
    "\n",
    "It is advantageous to predeclare large arrays in situations where you know the size that you need. There are several NumPy methods that make this easy to do! \n",
    "\n",
    "By predeclaring your array, you avoid the memory allocations that take place as the array grows; this speeds up your code, especially for large arrays."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Arrays of zeros: \n",
    "\n",
    "$numpy.zeros(shape, dtype=float, order='C')$\n",
    "\n",
    "**ASIDE:** What does the argument `order` do?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "zero_array = np.zeros((2, 5, 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "zero_array.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "zero_array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**\\*ASIDE:**\n",
    "Row vs Column Major Order:\n",
    "  - All arrays in are stored in memory contiguously\n",
    "  - The 'shape' of an array does not change the representation in memory, it just changes the way the array is indexed\n",
    "  - There are two organization themes:\n",
    "  \n",
    "  ![](https://upload.wikimedia.org/wikipedia/commons/thumb/4/4d/Row_and_column_major_order.svg/170px-Row_and_column_major_order.svg.png)\n",
    "  \n",
    "There is an array property that lets use see details about the internal representation of an array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "zero_array.flags"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, *C_CONTIGUOUS* represents column-major order and *F_CONTIGUOUS* is for row-major order."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Arrays of ones:\n",
    "\n",
    "$numpy.ones(shape, dtype=None, order='C')$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ones_array = np.ones((2, 3, 4), dtype='int8', order='F')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ones_array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ones_array.flags    # Now our array is in row-major order"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Understanding the internal representation of arrays helps us peel back the simplicity of Python syntax and get a deeper understanding of how the language works. Row vs column major order is utilized in NumPy to perform by reference transposition of matrix and tensor objects - in this operation the underlyling data is not changed, just the order of the index."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(ones_array.T)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ones_array.T.flags"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see here that a transpose operation (`.T`) inverts row vs column major order. Similar to slicing, it returns a *view* of the object, not a copy. Thus modifying a transposed array will change the original array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ones_array.T[1, 0, 1] = 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ones_array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Arrays With Custom Values:\n",
    "\n",
    "$numpy.full(shape, fill\\_value, dtype=None, order='C')$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "custom_array = np.full((2, 3), 0.+0.j)    # An array with complex numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "custom_array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "custom_array.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also replicate the shape of other arrays using `np.full_like`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "like_ones_array = np.full_like(ones_array, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "like_ones_array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "like_ones_array.shape == ones_array.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reshaping and Casting Arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reshaping"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "flat_array = np.linspace(1, 10, 6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1. ,  2.8,  4.6,  6.4,  8.2, 10. ])"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "flat_array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1. ,  2.8,  4.6],\n",
       "       [ 6.4,  8.2, 10. ]])"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "flat_array.reshape(2, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1. ,  2.8,  4.6,  6.4,  8.2, 10. ])"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "flat_array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see that the original array is unmodified. Similar to transposition with `.T`, the object returned by `.reshape` is a view of the original array. To keep the modified array we must assign it to a new variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "matrix = flat_array.reshape(2, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1. ,  2.8,  4.6],\n",
       "       [ 6.4,  8.2, 10. ]])"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matrix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is a potential issue here... Can you find it?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Reference semantics are powerful and memory efficient, but they can also have nasty side effects!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "matrix[0, 1:3] = [5, 6]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1. ,  5. ,  6. ],\n",
       "       [ 6.4,  8.2, 10. ]])"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1. ,  5. ,  6. ,  6.4,  8.2, 10. ])"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "flat_array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see because we assigned a *view* of `flat_array` to `matrix`, the original array is modified with `matrix`. To get around this we need to ensure we *copy* the array."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This can be achieved using `.copy()`. This is a commond method in Python and is implemented for most Python types with modify by reference semantics."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "matrix = flat_array.reshape(2, 3).copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "matrix = np.arange(1, 6, 0.5).reshape((2, 5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1. , 1.5, 2. , 2.5, 3. ],\n",
       "       [3.5, 4. , 4.5, 5. , 5.5]])"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1. ,  5. ,  6. ,  6.4,  8.2, 10. ])"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "flat_array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With copies, we trade memory efficiency for code which is more robust to bugs and easier to reason about."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Casting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy will automatically infer the types of you array, but in sutations where memory management is important you can manually cast your arrays to the desired data types."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('float64')"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "flat_array.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1,  5,  6,  6,  8, 10], dtype=int32)"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "flat_array.astype('int32')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A full list of available datatypes in NumPy can be found in the [basic types documentation](https://numpy.org/doc/stable/user/basics.types.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Math"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy provides a set of standard mathematical operators optimized for vectorized calculations on `ndarrays`. It is always recommended to use these math functions over the base Python ones when working with `arrays`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "More advanced mathematical operations can be found in the `SciPy` package, although Numpy supports a range of advanced functions for trigonometry, linear algebra and statistics.\n",
    "\n",
    "For a list of advanced mathematical functions in NumPy see the [routines.math](https://numpy.org/doc/stable/reference/routines.math.html) documentation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Basic Operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "array1 = np.logspace(1, 6, base=2)\n",
    "array2 = np.linspace(1, 6, 50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(50,)"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array1.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(50,)"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array2.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 3.        ,  3.24862212,  3.50798728,  3.77888284,  4.06215387,\n",
       "        4.35870739,  4.66951687,  4.99562714,  5.3381596 ,  5.69831786,\n",
       "        6.07739371,  6.47677364,  6.89794575,  7.34250719,  7.8121722 ,\n",
       "        8.30878062,  8.83430716,  9.39087125,  9.98074764, 10.60637781,\n",
       "       11.27038219, 11.97557325, 12.72496958, 13.52181102, 14.36957485,\n",
       "       15.27199321, 16.23307175, 17.25710973, 18.34872149, 19.51285954,\n",
       "       20.75483939, 22.08036611, 23.49556291, 25.00700177, 26.62173633,\n",
       "       28.3473372 , 30.19192984, 32.16423524, 34.27361355, 36.53011093,\n",
       "       38.94450984, 41.52838298, 44.29415122, 47.25514578, 50.42567493,\n",
       "       53.82109558, 57.45789018, 61.35374919, 65.52765961, 70.        ])"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.add(array1, array2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  2.        ,   2.36562021,   2.77409047,   3.22972785,\n",
       "         3.73725208,   4.30182132,   4.92907114,   5.62515673,\n",
       "         6.39679885,   7.25133364,   8.19676672,   9.24183193,\n",
       "        10.39605507,  11.66982306,  13.07445901,  14.62230365,\n",
       "        16.32680365,  18.20260749,  20.26566936,  22.53336187,\n",
       "        25.02459825,  27.75996492,  30.76186507,  34.05467446,\n",
       "        37.66491019,  41.62141361,  45.95554866,  50.70141664,\n",
       "        55.89608899,  61.57985954,  67.79651764,  74.59364416,\n",
       "        82.02293201,  90.14053334,  99.00743546, 108.68986801,\n",
       "       119.25974375, 130.79513589, 143.38079479, 157.10870733,\n",
       "       172.07870244, 188.39910642, 206.18745237, 225.57124774,\n",
       "       246.68880516, 269.69014128, 294.73794946, 322.00865212,\n",
       "       351.69353924, 384.        ])"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.multiply(array1, array2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 2.        ,  1.94782377,  1.91341316,  1.89320717,  1.88471797,\n",
       "        1.88617111,  1.89628261,  1.91411583,  1.93898675,  1.97039974,\n",
       "        2.00800295,  2.05155681,  2.10091139,  2.15598993,  2.21677679,\n",
       "        2.28330847,  2.35566706,  2.43397531,  2.51839305,  2.60911467,\n",
       "        2.7063673 ,  2.81040967,  2.92153151,  3.04005329,  3.16632644,\n",
       "        3.30073372,  3.44369003,  3.59564335,  3.75707594,  3.92850576,\n",
       "        4.11048809,  4.30361735,  4.5085291 ,  4.72590227,  4.95646155,\n",
       "        5.20098001,  5.46028193,  5.73524584,  6.0268078 ,  6.3359649 ,\n",
       "        6.66377904,  7.01138097,  7.37997456,  7.77084145,  8.18534599,\n",
       "        8.62494045,  9.09117068,  9.58568208, 10.11022602, 10.66666667])"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.divide(array1, array2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1.        ,  1.04454049,  1.09982401,  1.16663794,  1.24582734,\n",
       "        1.33829923,  1.44502707,  1.56705571,  1.70550654,  1.86158317,\n",
       "        2.03657738,  2.23187568,  2.44896615,  2.68944597,  2.95502934,\n",
       "        3.24755613,  3.56900104,  3.92148349,  4.30727825,  4.72882679,\n",
       "        5.18874954,  5.68985897,  6.23517367,  6.82793347,  7.47161567,\n",
       "        8.16995239,  8.9269493 ,  9.74690565, 10.63443577, 11.59449219,\n",
       "       12.63239041, 13.7538355 , 14.96495067, 16.27230789, 17.68296082,\n",
       "       19.20448005, 20.84499106, 22.61321483, 24.51851151, 26.57092726,\n",
       "       28.78124453, 31.16103604, 33.72272265, 36.47963558, 39.44608309,\n",
       "       42.63742211, 46.07013508, 49.76191246, 53.73174124, 58.        ])"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.subtract(array1, array2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2.00000000e+00, 2.32059372e+00, 2.73172561e+00, 3.26245014e+00,\n",
       "       3.95293377e+00, 4.85919176e+00, 6.06006644e+00, 7.66760230e+00,\n",
       "       9.84261774e+00, 1.28183022e+01, 1.69363273e+01, 2.27026637e+01,\n",
       "       3.08747351e+01, 4.25989123e+01, 5.96297004e+01, 8.46828744e+01,\n",
       "       1.22010554e+02, 1.78347923e+02, 2.64488965e+02, 3.97938452e+02,\n",
       "       6.07425612e+02, 9.40674001e+02, 1.47793055e+03, 2.35579644e+03,\n",
       "       3.80969616e+03, 6.25045691e+03, 1.04040406e+04, 1.75695709e+04,\n",
       "       3.01015680e+04, 5.23221919e+04, 9.22681018e+04, 1.65076818e+05,\n",
       "       2.99632859e+05, 5.51774509e+05, 1.03086709e+06, 1.95394602e+06,\n",
       "       3.75743344e+06, 7.33058910e+06, 1.45095954e+07, 2.91367143e+07,\n",
       "       5.93601096e+07, 1.22692399e+08, 2.57282040e+08, 5.47356309e+08,\n",
       "       1.18140725e+09, 2.58700925e+09, 5.74731735e+09, 1.29539203e+10,\n",
       "       2.96214360e+10, 6.87194767e+10])"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.power(array1, array2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Broadcasting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "array1 = np.logspace(1, 6, base=2)\n",
    "array2 = np.linspace(1, 6, 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "array1.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "array2.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Random Numbers and Statistical Distributions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy provides native support for random numbers and sampling via the `random` submodule. These allow application of NumPy in various statistical applications. In fact `SciPy`, one of the major packages for advanced mathematics in Python, is built on top of NumPy.\n",
    "\n",
    "To declare sequences of random numbers there are several options."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Random Sequence by Shape"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "ceeles",
   "language": "python",
   "name": "ceeles"
  },
  "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.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}