Numpy in details.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Numpy Array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "type(np.array([\"vbhvh\", 2, 3]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Upcasting:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 2., 3.])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array([1, 2, 3.0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#two dimensions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4]])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    " np.array([[1, 2], [3, 4]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Minimum dimensions 2:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[[[1, 2, 3]]]]])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array([1, 2, 3], ndmin=5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "#dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.+0.j, 2.+0.j, 3.+0.j])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    " np.array([1, 2, 3], dtype=complex)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Data-type consisting of more than one element:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([(1, 2), (3, 4)], dtype=[('a', '<i2'), ('b', '<i8')])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.array([(1,2),(3,4)],dtype=[('a','<i2'),('b','<i8')])\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.int16"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(x[1][0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "#Creating an array from sub-classes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[1, 2],\n",
       "        [4, 7]])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.mat(np.array([[1, 2],[4,7]]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[1, 2],\n",
       "        [3, 4]])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.mat('1 2; 3 4')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# numpy.asarray"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Convert the input to an array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#Convert a list into an array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    " a = [1, 2]\n",
    "type(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(np.asarray(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([1, 2]) #Existing arrays are not copied\n",
    "type(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.asarray((1,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#If dtype is set, array is copied only if dtype does not match:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 2.], dtype=float32)"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([1, 2], dtype=np.float32)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.asarray([1,2]) is a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2])"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.asarray([1,2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.asarray(a, dtype=np.float64) is a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# ndarray subclasses are not passed through"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "issubclass(np.matrix, np.ndarray)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[1, 2]])"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.matrix([[1, 2]])\n",
    "np.asanyarray(a)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.asarray(a) is a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.asanyarray(a) is a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(np.asarray(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# numpy.asanyarray"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2])"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = [1, 2]\n",
    "np.asanyarray(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[1, 2]])"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.matrix([1, 2])\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.asanyarray([1,2]) is a"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "#numpy.copy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2]])"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array(a, copy=True)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#Create an array x, with a reference y and a copy z:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3])"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.array([1, 2, 3])\n",
    "x\n",
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "z = np.copy(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([100,   2,   3])"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y[0] = 100\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([100,   2,   3])"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4767545360"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "id(x[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4767545408"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "id(y[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4768156128"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "id(x) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4768156128"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "id(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# numpy.fromfunction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#Construct an array by executing a function over each coordinate."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ True, False, False],\n",
       "       [False,  True, False],\n",
       "       [False, False,  True]])"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.fromfunction(lambda i, j: i == j, (3, 3), dtype=int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 0, 0],\n",
       "       [0, 1, 2],\n",
       "       [0, 2, 4]])"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.fromfunction(lambda i, j: i * j, (3, 3), dtype=int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#Create a new 1-dimensional array from an iterable object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<generator object <genexpr> at 0x11c326b10>"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "iterable = (x*x for x in range(5))\n",
    "iterable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.,  1.,  4.,  9., 16.])"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.fromiter(iterable, float)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#A new 1-D array initialized from text data in a string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([234., 234.])"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.fromstring('234 234',sep=' ')\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2])"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.fromstring('1, 2', dtype=int, sep=',')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# How to create create a record array from a (flat) list of arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [],
   "source": [
    "x1=np.array([1,2,3,4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [],
   "source": [
    "x2=np.array(['a','dd','xyz','12'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x3=np.array([1.1,2,3,4])\n",
    "x4=np.array([1.1,2,3,4])\n",
    "type(x4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "rec.array([(1, 'a', 1.1, 1.1), (2, 'dd', 2. , 2. ), (3, 'xyz', 3. , 3. ),\n",
       "           (4, '12', 4. , 4. )],\n",
       "          dtype=[('a', '<i8'), ('b', '<U3'), ('c', '<f8'), ('d', '<f8')])"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r = np.core.records.fromarrays([x1,x2,x3,x4],names='a,b,c,d')\n",
    "r"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "print(r[1][\"a\"])"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "x1[1]=34"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 130,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x1[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# data types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Type/Class of this object: <class 'numpy.ndarray'>\n",
      "Here is the vector\n",
      "--------------------\n",
      " [1 2 3]\n"
     ]
    }
   ],
   "source": [
    "my_list = [1,2,3]\n",
    "import numpy as np\n",
    "arr = np.array(my_list)\n",
    "print(\"Type/Class of this object:\",type(arr))\n",
    "print(\"Here is the vector\\n--------------------\\n\",arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Type/Class of this object: <class 'numpy.ndarray'>\n",
      "Here is the matrix\n",
      "----------\n",
      " [[1 2 3]\n",
      " [4 5 6]\n",
      " [7 8 9]] \n",
      "----------\n",
      "Dimension of this matrix: 2\n",
      "Size of this matrix: 9\n",
      "Shape of this matrix: (3, 3)\n",
      "Data type of this matrix: int64\n"
     ]
    }
   ],
   "source": [
    "my_mat = [[1,2,3],[4,5,6],[7,8,9]]\n",
    "mat = np.array(my_mat)\n",
    "print(\"Type/Class of this object:\",type(mat))\n",
    "print(\"Here is the matrix\\n----------\\n\",mat,\"\\n----------\")\n",
    "print(\"Dimension of this matrix: \",mat.ndim,sep='') #ndim gives the dimensison, 2 for a matrix, 1 for a vector\n",
    "print(\"Size of this matrix: \", mat.size,sep='') #size gives the total number of elements\n",
    "print(\"Shape of this matrix: \", mat.shape,sep='') #shape gives the number of elements along each axes (dimension)\n",
    "print(\"Data type of this matrix: \", mat.dtype,sep='') #dtype gives the data type contained in the array\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Data type of the modified matrix: float64\n",
      "\n",
      "\n",
      "Even tuples can be converted to ndarrays...\n"
     ]
    }
   ],
   "source": [
    "my_mat = [[1.1,2,3],[4,5.2,6],[7,8.3,9]]\n",
    "mat = np.array(my_mat)\n",
    "print(\"Data type of the modified matrix: \", mat.dtype,sep='') #dtype gives the data type contained in the array\n",
    "print(\"\\n\\nEven tuples can be converted to ndarrays...\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "We write b = np.array([(1.5,2,3), (4,5,6)])\n",
      "Matrix made from tuples, not lists\n",
      "---------------------------------------\n",
      "[[1.5 2.  3. ]\n",
      " [4.  5.  6. ]]\n"
     ]
    }
   ],
   "source": [
    "b = np.array([(1.5,2,3), (4,5,6)])\n",
    "print(\"We write b = np.array([(1.5,2,3), (4,5,6)])\")\n",
    "print(\"Matrix made from tuples, not lists\\n---------------------------------------\")\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# arange and linspace"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A series of numbers: <class 'numpy.ndarray'>\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([ 5. ,  7.3,  9.6, 11.9, 14.2])"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(\"A series of numbers:\",type(np.arange(5,16)))\n",
    "np.arange(5,16,2.3)# A series of numbers from low to high"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 7, 9, 11, 13, 15]"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(5,16,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(50,-1,5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Numbers spaced apart by 2: []\n"
     ]
    }
   ],
   "source": [
    "print(\"Numbers spaced apart by 2:\",np.arange(50,-1,5)) # Numbers spaced apart by 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Numbers spaced apart by float: [ 0.   2.5  5.   7.5 10. ]\n"
     ]
    }
   ],
   "source": [
    "print(\"Numbers spaced apart by float:\",np.arange(0,11,2.5)) # Numbers spaced apart by 2.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Every 5th number from 50 in reverse order\n",
      " [5. 0.]\n"
     ]
    }
   ],
   "source": [
    "print(\"Every 5th number from 50 in reverse order\\n\",np.arange(5.0,-1,-5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "21 linearly spaced numbers between 1 and 5\n",
      "--------------------------------------------\n",
      "[1.         1.08163265 1.16326531 1.24489796 1.32653061 1.40816327\n",
      " 1.48979592 1.57142857 1.65306122 1.73469388 1.81632653 1.89795918\n",
      " 1.97959184 2.06122449 2.14285714 2.2244898  2.30612245 2.3877551\n",
      " 2.46938776 2.55102041 2.63265306 2.71428571 2.79591837 2.87755102\n",
      " 2.95918367 3.04081633 3.12244898 3.20408163 3.28571429 3.36734694\n",
      " 3.44897959 3.53061224 3.6122449  3.69387755 3.7755102  3.85714286\n",
      " 3.93877551 4.02040816 4.10204082 4.18367347 4.26530612 4.34693878\n",
      " 4.42857143 4.51020408 4.59183673 4.67346939 4.75510204 4.83673469\n",
      " 4.91836735 5.        ]\n"
     ]
    }
   ],
   "source": [
    "print(\"21 linearly spaced numbers between 1 and 5\\n--------------------------------------------\")\n",
    "print((np.linspace(1,5,50)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Matrix creation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Vector of zeroes\n",
      "---------------------\n",
      "[0. 0. 0. 0. 0.]\n"
     ]
    }
   ],
   "source": [
    "print(\"Vector of zeroes\\n---------------------\")\n",
    "print(np.zeros(5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Matrix of zeroes\n",
      "--------------------\n",
      "[[0. 0. 0. 0.]\n",
      " [0. 0. 0. 0.]\n",
      " [0. 0. 0. 0.]]\n"
     ]
    }
   ],
   "source": [
    "print(\"Matrix of zeroes\\n--------------------\")\n",
    "print(np.zeros((3,4))) # Notice Tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Vector of ones\n",
      "---------------------\n",
      "[1. 1. 1. 1. 1.]\n"
     ]
    }
   ],
   "source": [
    "print(\"Vector of ones\\n---------------------\")\n",
    "print(np.ones(5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Matrix of ones\n",
      "---------------------\n",
      "[[[1. 1. 1. 1. 1. 1. 1. 1.]\n",
      "  [1. 1. 1. 1. 1. 1. 1. 1.]]\n",
      "\n",
      " [[1. 1. 1. 1. 1. 1. 1. 1.]\n",
      "  [1. 1. 1. 1. 1. 1. 1. 1.]]\n",
      "\n",
      " [[1. 1. 1. 1. 1. 1. 1. 1.]\n",
      "  [1. 1. 1. 1. 1. 1. 1. 1.]]\n",
      "\n",
      " [[1. 1. 1. 1. 1. 1. 1. 1.]\n",
      "  [1. 1. 1. 1. 1. 1. 1. 1.]]\n",
      "\n",
      " [[1. 1. 1. 1. 1. 1. 1. 1.]\n",
      "  [1. 1. 1. 1. 1. 1. 1. 1.]]]\n"
     ]
    }
   ],
   "source": [
    "print(\"Matrix of ones\\n---------------------\")\n",
    "print(np.ones((5,2,8))) # Note matrix dimension specified by Tuples\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Matrix of 5's\n",
      "---------------------\n",
      "[[6. 6. 6. 6. 6.]\n",
      " [6. 6. 6. 6. 6.]\n",
      " [6. 6. 6. 6. 6.]]\n"
     ]
    }
   ],
   "source": [
    "print(\"Matrix of 5's\\n---------------------\")\n",
    "print(5+np.ones((3,5)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Empty matrix\n",
      "-------------\n",
      " [[6. 6. 6. 6. 6.]\n",
      " [6. 6. 6. 6. 6.]\n",
      " [6. 6. 6. 6. 6.]]\n"
     ]
    }
   ],
   "source": [
    "print(\"Empty matrix\\n-------------\\n\", np.empty((3,5)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Identity matrix of dimension (4, 4)\n",
      "[[1. 0. 0. 0.]\n",
      " [0. 1. 0. 0.]\n",
      " [0. 0. 1. 0.]\n",
      " [0. 0. 0. 1.]]\n"
     ]
    }
   ],
   "source": [
    "mat1 = np.eye(4) \n",
    "print(\"Identity matrix of dimension\", mat1.shape)\n",
    "print(mat1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2])"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 1., 2.])"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(3.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 4, 5, 6])"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    " np.arange(3,7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 5])"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(3,7,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2.  , 2.25, 2.5 , 2.75, 3.  ])"
      ]
     },
     "execution_count": 150,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linspace(2.0, 3.0, num=5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2. , 2.2, 2.4, 2.6, 2.8])"
      ]
     },
     "execution_count": 151,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linspace(2.0, 3.0, num=5, endpoint=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([2.   , 2.125, 2.25 , 2.375, 2.5  , 2.625, 2.75 , 2.875, 3.   ]), 0.125)"
      ]
     },
     "execution_count": 153,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linspace(2.0, 3.0, num=9, retstep=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2.        , 2.33333333, 2.66666667, 3.        ])"
      ]
     },
     "execution_count": 147,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Return numbers spaced evenly on a log scale.\n",
    "np.linspace(2.0, 3.0, num=4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 100.        ,  215.443469  ,  464.15888336, 1000.        ])"
      ]
     },
     "execution_count": 154,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.logspace(2.0, 3.0, num=4,base = 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 100.        ,  177.827941  ,  316.22776602,  562.34132519])"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.logspace(2.0, 3.0, num=4, endpoint=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4.        , 5.0396842 , 6.34960421, 8.        ])"
      ]
     },
     "execution_count": 155,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.logspace(2.0, 3.0, num=4, base=2.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#Extract a diagonal or construct a diagonal array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.arange(16).reshape((-1,4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3],\n",
       "       [ 4,  5,  6,  7],\n",
       "       [ 8,  9, 10, 11],\n",
       "       [12, 13, 14, 15]])"
      ]
     },
     "execution_count": 180,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  5, 10, 15])"
      ]
     },
     "execution_count": 172,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.diag(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 7])"
      ]
     },
     "execution_count": 182,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.diag(x, k=2\n",
    "       )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 4,  9, 14])"
      ]
     },
     "execution_count": 183,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.diag(x, k=-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  0,  0,  0],\n",
       "       [ 0,  5,  0,  0],\n",
       "       [ 0,  0, 10,  0],\n",
       "       [ 0,  0,  0, 15]])"
      ]
     },
     "execution_count": 184,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.diag(np.diag(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#Create a two-dimensional array with the flattened input as a diagonal."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 0, 0, 0],\n",
       "       [0, 2, 0, 0],\n",
       "       [0, 0, 3, 0],\n",
       "       [0, 0, 0, 4]])"
      ]
     },
     "execution_count": 180,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.diagflat([[1,2], [3,4]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 0],\n",
       "       [0, 0, 2],\n",
       "       [0, 0, 0]])"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.diagflat([1,2], 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#An array with ones at and below the given diagonal and zeros elsewhere."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 1, 0, 0, 0],\n",
       "       [1, 1, 1, 0, 0],\n",
       "       [1, 1, 1, 1, 0]])"
      ]
     },
     "execution_count": 187,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.tri(3, 5, 1, dtype=int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0., 0., 0.],\n",
       "       [1., 0., 0., 0., 0.],\n",
       "       [1., 1., 0., 0., 0.]])"
      ]
     },
     "execution_count": 191,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.tri(3, 5,k=-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#return a Lower triangle of an array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 205,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 0, 0],\n",
       "       [4, 5, 0],\n",
       "       [7, 8, 9]])"
      ]
     },
     "execution_count": 205,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.tril([[1,2,3],[4,5,6],[7,8,9]], 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#return Upper triangle of an array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 206,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 2, 3],\n",
       "       [0, 0, 6],\n",
       "       [0, 0, 0],\n",
       "       [0, 0, 0]])"
      ]
     },
     "execution_count": 206,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.triu([[1,2,3],[4,5,6],[7,8,9],[10,11,12]], 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Random number generation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 197,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Random number generation (from Uniform distribution)\n",
      "[[0.79234365 0.26636652 0.84876143]\n",
      " [0.78766627 0.06627396 0.8829639 ]]\n"
     ]
    }
   ],
   "source": [
    "print(\"Random number generation (from Uniform distribution)\")\n",
    "print(np.random.rand(2,3)) # 2 by 3 matrix with random numbers ranging from 0 to 1, Note no Tuple is necessary "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 209,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Numbers from Normal distribution with zero mean and standard deviation 1 i.e. standard normal\n",
      "[[ 0.08550888  0.73651756  0.08329424]\n",
      " [ 0.75179279  0.42441618  0.47752353]\n",
      " [ 0.23835886  1.06582108 -0.01790105]\n",
      " [ 0.48190152 -0.24940656 -0.44992115]]\n"
     ]
    }
   ],
   "source": [
    "print(\"Numbers from Normal distribution with zero mean and standard deviation 1 i.e. standard normal\")\n",
    "print(np.random.randn(4,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 202,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Random integer vector: 4\n",
      "\n",
      "Random integer matrix\n"
     ]
    }
   ],
   "source": [
    "print(\"Random integer vector:\",np.random.randint(1,10)) #randint (low, high, # of samples to be drawn)\n",
    "print (\"\\nRandom integer matrix\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 208,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[28 90 28 25]\n",
      " [14 51 32 98]\n",
      " [10 98 11 71]\n",
      " [12 42 54 77]]\n",
      "\n",
      "20 samples drawn from a dice throw: [1 6 2 1 1 1 5 2 5 1 1 5 5 1 6 6 5 4 1 1]\n"
     ]
    }
   ],
   "source": [
    "print(np.random.randint(1,100,(4,4))) #randint (low, high, # of samples to be drawn in a tuple to form a matrix)\n",
    "print(\"\\n20 samples drawn from a dice throw:\",np.random.randint(1,7,20)) # 20 samples drawn from a dice throw"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Reshaping"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 211,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[51, 63, 51, 54, 96],\n",
       "       [11, 93,  2, 51, 34],\n",
       "       [62, 35, 42, 95, 58],\n",
       "       [88, 44, 36, 93, 83],\n",
       "       [86, 56, 30,  2, 15],\n",
       "       [68, 40, 77, 48, 57]])"
      ]
     },
     "execution_count": 211,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from numpy.random import randint as ri\n",
    "a = ri(1,100,30)\n",
    "b = a.reshape(2,3,5)\n",
    "c = a.reshape(6,-19878)\n",
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 209,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape of a: (30,)\n",
      "Shape of b: (2, 3, 5)\n",
      "Shape of c: (6, 5)\n"
     ]
    }
   ],
   "source": [
    "print (\"Shape of a:\", a.shape)\n",
    "print (\"Shape of b:\", b.shape)\n",
    "print (\"Shape of c:\", c.shape)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 219,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "a looks like\n",
      " -------------------- \n",
      " [72 69 61 67 42  2 92 42 38 56 22 71 21 81 81 47  2  1  6 94 52 14 87 71\n",
      " 38 57 99 87 62 88] \n",
      " --------------------\n",
      "\n",
      "b looks like\n",
      " -------------------- \n",
      " [[[72 69 61 67 42]\n",
      "  [ 2 92 42 38 56]\n",
      "  [22 71 21 81 81]]\n",
      "\n",
      " [[47  2  1  6 94]\n",
      "  [52 14 87 71 38]\n",
      "  [57 99 87 62 88]]] \n",
      " --------------------\n",
      "\n",
      "c looks like\n",
      " -------------------- \n",
      " [[72 69 61 67 42]\n",
      " [ 2 92 42 38 56]\n",
      " [22 71 21 81 81]\n",
      " [47  2  1  6 94]\n",
      " [52 14 87 71 38]\n",
      " [57 99 87 62 88]] \n",
      " --------------------\n"
     ]
    }
   ],
   "source": [
    "print(\"\\na looks like\\n\",'-'*20,\"\\n\",a,\"\\n\",'-'*20)\n",
    "print(\"\\nb looks like\\n\",'-'*20,\"\\n\",b,\"\\n\",'-'*20)\n",
    "print(\"\\nc looks like\\n\",'-'*20,\"\\n\",c,\"\\n\",'-'*20)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 212,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Vector of random integers\n",
      " -------------------------------------------------- \n",
      " [69 99 45 72 41 16 50 80 80 22]\n",
      "\n",
      "Here is the sorted vector\n",
      " -------------------------------------------------- \n",
      " [16 22 41 45 50 69 72 80 80 99]\n"
     ]
    }
   ],
   "source": [
    "A = ri(1,100,10) # Vector of random interegrs\n",
    "print(\"\\nVector of random integers\\n\",'-'*50,\"\\n\",A)\n",
    "print(\"\\nHere is the sorted vector\\n\",'-'*50,\"\\n\",np.sort(A))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 221,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Here is the sorted matrix along each column\n",
      " -------------------------------------------------- \n",
      " [[18 25 38 73 94]\n",
      " [18 42 75 79 91]\n",
      " [21 44 62 78 85]\n",
      " [15 17 44 89 91]\n",
      " [ 3 24 38 62 86]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[18, 94, 25, 38, 73],\n",
       "       [75, 42, 79, 18, 91],\n",
       "       [21, 44, 85, 78, 62],\n",
       "       [91, 15, 17, 44, 89],\n",
       "       [62, 38,  3, 24, 86]])"
      ]
     },
     "execution_count": 221,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M = ri(1,100,25).reshape(5,5) # Matrix of random interegrs\n",
    "#print(\"\\nHere is the sorted matrix along each row\\n\",'-'*50,\"\\n\",np.sort(M, kind='mergesort')) # Default axis =1\n",
    "print(\"\\nHere is the sorted matrix along each column\\n\",'-'*50,\"\\n\",np.sort(M, axis=1, kind='mergesort'))\n",
    "M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 214,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Max of a: 99\n",
      "Max of b: 96\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[[51, 63, 51, 54, 96],\n",
       "        [11, 93,  2, 51, 34],\n",
       "        [62, 35, 42, 95, 58]],\n",
       "\n",
       "       [[88, 44, 36, 93, 83],\n",
       "        [86, 56, 30,  2, 15],\n",
       "        [68, 40, 77, 48, 57]]])"
      ]
     },
     "execution_count": 214,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(\"Max of a:\", M.max())\n",
    "print(\"Max of b:\", b.max())\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 217,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[46, 88, 23, 66, 57],\n",
       "       [50, 90, 30, 46, 36],\n",
       "       [31, 19, 42, 23, 31],\n",
       "       [ 4, 44, 86, 10, 81],\n",
       "       [73, 35, 30, 99, 43]])"
      ]
     },
     "execution_count": 217,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 218,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Max of a location: [1 1 2 2 3]\n",
      "Max of b location: 4\n",
      "Max of c location: 4\n"
     ]
    }
   ],
   "source": [
    "print(\"Max of a location:\", M.argmax(axis= 1 ))\n",
    "print(\"Max of b location:\", b.argmax())\n",
    "print(\"Max of c location:\", b.argmax())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Indexing and slicing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 229,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Array: [ 0  1  2  3  4  5  6  7  8  9 10]\n"
     ]
    }
   ],
   "source": [
    "arr = np.arange(0,11)\n",
    "print(\"Array:\",arr)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Element at 7th index is: 7\n"
     ]
    }
   ],
   "source": [
    "print(\"Element at 7th index is:\", arr[7])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 230,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Elements from 3rd to 5th index are: [3 5]\n"
     ]
    }
   ],
   "source": [
    "print(\"Elements from 3rd to 5th index are:\", arr[3:6:2])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 231,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Elements up to 4th index are: [0 1 2 3]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10])"
      ]
     },
     "execution_count": 231,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(\"Elements up to 4th index are:\", arr[:4])\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 233,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Elements from last backwards are: [10  9  8]\n"
     ]
    }
   ],
   "source": [
    "print(\"Elements from last backwards are:\", arr[-1:7:-1])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 Elements from last backwards are: []\n"
     ]
    }
   ],
   "source": [
    "print(\"3 Elements from last backwards are:\", arr[-1:-6:2])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "New array: [ 0  2  4  6  8 10 12 14 16 18 20]\n"
     ]
    }
   ],
   "source": [
    "arr = np.arange(0,21,2)\n",
    "print(\"New array:\",arr)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Elements at 2nd, 4th, and 9th index are: [ 4  8 18]\n"
     ]
    }
   ],
   "source": [
    "print(\"Elements at 2nd, 4th, and 9th index are:\", arr[[2,4,9]]) # Pass a list as a index to subset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 237,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Matrix of random 2-digit numbers\n",
      "--------------------------------\n",
      " [[35 75 44 59 85]\n",
      " [71 58 75 72 69]\n",
      " [76 97 49 63 53]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[75, 59],\n",
       "       [58, 72],\n",
       "       [97, 63]])"
      ]
     },
     "execution_count": 237,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np \n",
    "mat = np.array(ri(10,100,15)).reshape(3,5)\n",
    "print(\"Matrix of random 2-digit numbers\\n--------------------------------\\n\",mat)\n",
    "mat[1:4,3:5]\n",
    "mat[0:3,[1,3]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 238,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[35, 75, 44, 59, 85],\n",
       "       [71, 58, 75, 72, 69],\n",
       "       [76, 97, 49, 63, 53]])"
      ]
     },
     "execution_count": 238,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mat[0:3,[1,3]]\n",
    "mat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 241,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Double bracket indexing\n",
      "------------------------\n",
      "Element in row index 1 and column index 2: 58\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[35, 75, 44, 59, 85],\n",
       "       [71, 58, 75, 72, 69],\n",
       "       [76, 97, 49, 63, 53]])"
      ]
     },
     "execution_count": 241,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(\"\\nDouble bracket indexing\\n------------------------\")\n",
    "print(\"Element in row index 1 and column index 2:\", mat[1][1])\n",
    "mat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 242,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Single bracket with comma indexing\n",
      "----------------------------------\n",
      "Element in row index 1 and column index 2: 75\n",
      "\n",
      "Row or column extract\n",
      "----------------------\n"
     ]
    }
   ],
   "source": [
    "print(\"\\nSingle bracket with comma indexing\\n----------------------------------\")\n",
    "print(\"Element in row index 1 and column index 2:\", mat[1,2])\n",
    "print(\"\\nRow or column extract\\n----------------------\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Entire row at index 2: [22 10 57 59 61]\n",
      "Entire column at index 3: [92 88 59]\n"
     ]
    }
   ],
   "source": [
    "print(\"Entire row at index 2:\", mat[2])\n",
    "print(\"Entire column at index 3:\", mat[:,3])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Subsetting sub-matrices\n",
      "--------------------------\n",
      "Matrix with row indices 1 and 2 and column indices 3 and 4\n",
      " [[14 32]\n",
      " [62 27]]\n"
     ]
    }
   ],
   "source": [
    "print(\"\\nSubsetting sub-matrices\\n--------------------------\")\n",
    "print(\"Matrix with row indices 1 and 2 and column indices 3 and 4\\n\", mat[1:3,3:5])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Matrix with row indices 0 and 1 and column indices 1 and 3\n",
      " [[77 69]\n",
      " [64 17]]\n"
     ]
    }
   ],
   "source": [
    "print(\"Matrix with row indices 0 and 1 and column indices 1 and 3\\n\", mat[0:2,[1,3]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Subseting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Matrix of random 2-digit numbers\n",
      "--------------------------------\n",
      " [[51 99 67 32 43]\n",
      " [53 61 80 97 51]\n",
      " [82 76 18 26 11]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[ True,  True,  True, False, False],\n",
       "       [ True,  True,  True,  True,  True],\n",
       "       [ True,  True, False, False, False]])"
      ]
     },
     "execution_count": 173,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mat = np.array(ri(10,100,15)).reshape(3,5)\n",
    "print(\"Matrix of random 2-digit numbers\\n--------------------------------\\n\",mat)\n",
    "mat>50"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Elements greater than 50\n",
      " [51 99 67 53 61 80 97 51 82 76]\n"
     ]
    }
   ],
   "source": [
    "print (\"Elements greater than 50\\n\", mat[mat>50])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Slicing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original matrix\n",
      "[[11 12 13]\n",
      " [21 22 23]\n",
      " [31 32 33]]\n"
     ]
    }
   ],
   "source": [
    "mat = np.array([[11,12,13],[21,22,23],[31,32,33]])\n",
    "print(\"Original matrix\")\n",
    "print(mat)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Sliced matrix\n",
      "[[11 12]\n",
      " [21 22]]\n",
      "\n",
      "Change the sliced matrix\n"
     ]
    }
   ],
   "source": [
    "mat_slice = mat[:2,:2]\n",
    "print (\"\\nSliced matrix\")\n",
    "print(mat_slice)\n",
    "print (\"\\nChange the sliced matrix\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1000   12]\n",
      " [  21   22]]\n"
     ]
    }
   ],
   "source": [
    "mat_slice[0,0] = 1000\n",
    "print (mat_slice)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "But the original matrix? WHOA! It got changed too!\n",
      "[[11 12 13]\n",
      " [21 22 23]\n",
      " [31 32 33]]\n"
     ]
    }
   ],
   "source": [
    "print(\"\\nBut the original matrix? WHOA! It got changed too!\")\n",
    "print(mat)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Doing it again little differently now...\n",
      "\n",
      "Original matrix\n",
      "[[11 12 13]\n",
      " [21 22 23]\n",
      " [31 32 33]]\n"
     ]
    }
   ],
   "source": [
    "# Little different way to create a copy of the slixed matrix\n",
    "print (\"\\nDoing it again little differently now...\\n\")\n",
    "mat = np.array([[11,12,13],[21,22,23],[31,32,33]])\n",
    "print(\"Original matrix\")\n",
    "print(mat)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Sliced matrix\n",
      "[[11 12]\n",
      " [21 22]]\n"
     ]
    }
   ],
   "source": [
    "mat_slice = np.array(mat[:2,:2]) # Notice the np.array command to create a new array not just slicing\n",
    "print (\"\\nSliced matrix\")\n",
    "print(mat_slice)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Change the sliced matrix\n",
      "[[1000   12]\n",
      " [  21   22]]\n"
     ]
    }
   ],
   "source": [
    "print (\"\\nChange the sliced matrix\")\n",
    "mat_slice[0,0] = 1000\n",
    "print (mat_slice)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "But the original matrix? NO CHANGE this time:)\n",
      "[[11 12 13]\n",
      " [21 22 23]\n",
      " [31 32 33]]\n"
     ]
    }
   ],
   "source": [
    "print(\"\\nBut the original matrix? NO CHANGE this time:)\")\n",
    "print(mat)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Universal Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 247,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "1st Matrix of random single-digit numbers\n",
      "----------------------------------------\n",
      " [[3 3 9]\n",
      " [6 1 8]\n",
      " [5 9 1]]\n",
      "\n",
      "2nd Matrix of random single-digit numbers\n",
      "----------------------------------------\n",
      " [[3 5 7]\n",
      " [4 4 9]\n",
      " [1 2 5]]\n"
     ]
    }
   ],
   "source": [
    "mat1 = np.array(ri(1,10,9)).reshape(3,3)\n",
    "mat2 = np.array(ri(1,10,9)).reshape(3,3)\n",
    "print(\"\\n1st Matrix of random single-digit numbers\\n----------------------------------------\\n\",mat1)\n",
    "print(\"\\n2nd Matrix of random single-digit numbers\\n----------------------------------------\\n\",mat2)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 248,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 9, 15, 63],\n",
       "       [24,  4, 72],\n",
       "       [ 5, 18,  5]])"
      ]
     },
     "execution_count": 248,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mat1*mat2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 249,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Multiplication\n",
      "------------------\n",
      " [[ 30  45  93]\n",
      " [ 30  50  91]\n",
      " [ 52  63 121]]\n"
     ]
    }
   ],
   "source": [
    "#print(\"\\nAddition\\n------------------\\n\", mat1+mat2)\n",
    "print(\"\\nMultiplication\\n------------------\\n\", mat1@mat2)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 251,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Division\n",
      "------------------\n",
      " [[inf inf inf]\n",
      " [inf inf inf]\n",
      " [inf inf inf]]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/sudhanshukumar/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:1: RuntimeWarning: divide by zero encountered in true_divide\n",
      "  \"\"\"Entry point for launching an IPython kernel.\n"
     ]
    }
   ],
   "source": [
    "print(\"\\nDivision\\n------------------\\n\", mat1/0)\n",
    "#print(\"\\nLineaer combination: 3*A - 2*B\\n-----------------------------\\n\", 3*mat1-2*mat2)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 252,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Addition of a scalar (100)\n",
      "-------------------------\n",
      " [[103 103 109]\n",
      " [106 101 108]\n",
      " [105 109 101]]\n"
     ]
    }
   ],
   "source": [
    "print(\"\\nAddition of a scalar (100)\\n-------------------------\\n\", 100+mat1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 253,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Exponentiation, matrix cubed here\n",
      "----------------------------------------\n",
      " [[ 27  27 729]\n",
      " [216   1 512]\n",
      " [125 729   1]]\n",
      "\n",
      "Exponentiation, sq-root using pow function\n",
      "-------------------------------------------\n",
      " [[ 27  27 729]\n",
      " [216   1 512]\n",
      " [125 729   1]]\n"
     ]
    }
   ],
   "source": [
    "print(\"\\nExponentiation, matrix cubed here\\n----------------------------------------\\n\", mat1**3)\n",
    "print(\"\\nExponentiation, sq-root using pow function\\n-------------------------------------------\\n\",pow(mat1,3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Broadcasting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#NumPy operations are usually done on pairs of arrays on an element-by-element basis. \n",
    "#In the simplest case, the two arrays must have exactly the same shape.\n",
    "#NumPy’s broadcasting rule relaxes this constraint when the arrays’ shapes meet certain constraints. \n",
    "#When operating on two arrays, NumPy compares their shapes element-wise. It starts with the trailing \n",
    "#dimensions, and works its way forward. Two dimensions are compatible when\n",
    "#they are equal, or one of them is 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 254,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[100., 100., 100., 100.],\n",
       "       [100., 100., 100., 100.],\n",
       "       [100., 100., 100., 100.],\n",
       "       [100., 100., 100., 100.]])"
      ]
     },
     "execution_count": 254,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "start = np.zeros((4,4))\n",
    "start= start+100\n",
    "start"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 256,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 0 2 5]\n"
     ]
    }
   ],
   "source": [
    "# create a rank 1 ndarray with 3 values\n",
    "add_rows = np.array([1, 0, 2,5])\n",
    "print(add_rows)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 257,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[101. 100. 102. 105.]\n",
      " [101. 100. 102. 105.]\n",
      " [101. 100. 102. 105.]\n",
      " [101. 100. 102. 105.]]\n"
     ]
    }
   ],
   "source": [
    "y = start + add_rows  # add to each row of 'start' using broadcasting\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 262,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0]\n",
      " [1]\n",
      " [2]\n",
      " [3]]\n"
     ]
    }
   ],
   "source": [
    "# create an ndarray which is 4 x 1 to broadcast across columns\n",
    "add_cols = np.array([[0,1,2,3]])\n",
    "add_cols = add_cols.T\n",
    "print(add_cols)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 263,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[100. 100. 100. 100.]\n",
      " [101. 101. 101. 101.]\n",
      " [102. 102. 102. 102.]\n",
      " [103. 103. 103. 103.]]\n"
     ]
    }
   ],
   "source": [
    "# add to each column of 'start' using broadcasting\n",
    "y = start + add_cols \n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 264,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[200. 200. 200. 200.]\n",
      " [201. 201. 201. 201.]\n",
      " [202. 202. 202. 202.]\n",
      " [203. 203. 203. 203.]]\n"
     ]
    }
   ],
   "source": [
    "# this will just broadcast in both dimensions\n",
    "add_scalar = np.array([100])  \n",
    "print(start+y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Array Math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 265,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "1st Matrix of random single-digit numbers\n",
      "\n",
      " [[9 5 4]\n",
      " [1 7 3]\n",
      " [8 3 5]]\n",
      "\n",
      "2nd Matrix of random single-digit numbers\n",
      "------------\n",
      " [[4 8 6]\n",
      " [7 6 8]\n",
      " [4 6 5]]\n"
     ]
    }
   ],
   "source": [
    "mat1 = np.array(ri(1,10,9)).reshape(3,3)\n",
    "mat2 = np.array(ri(1,10,9)).reshape(3,3)\n",
    "print(\"\\n1st Matrix of random single-digit numbers\\n\\n\",mat1)\n",
    "print(\"\\n2nd Matrix of random single-digit numbers\\n------------\\n\",mat2)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 266,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Sq-root of 1st matrix using np\n",
      "------------------\n",
      " [[3.         2.23606798 2.        ]\n",
      " [1.         2.64575131 1.73205081]\n",
      " [2.82842712 1.73205081 2.23606798]]\n"
     ]
    }
   ],
   "source": [
    "print(\"\\nSq-root of 1st matrix using np\\n------------------\\n\", np.sqrt(mat1))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 267,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Exponential power of 1st matrix using np\n",
      " -------------------------------------------------- \n",
      " [[8.10308393e+03 1.48413159e+02 5.45981500e+01]\n",
      " [2.71828183e+00 1.09663316e+03 2.00855369e+01]\n",
      " [2.98095799e+03 2.00855369e+01 1.48413159e+02]]\n"
     ]
    }
   ],
   "source": [
    "print(\"\\nExponential power of 1st matrix using np\\n\",'-'*50,\"\\n\", np.exp(mat1))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 268,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "10-base logarithm on 1st matrix using np\n",
      " -------------------------------------------------- \n",
      " [[0.95424251 0.69897    0.60205999]\n",
      " [0.         0.84509804 0.47712125]\n",
      " [0.90308999 0.47712125 0.69897   ]]\n",
      "[[9 5 4]\n",
      " [1 7 3]\n",
      " [8 3 5]]\n",
      "[[4 8 6]\n",
      " [7 6 8]\n",
      " [4 6 5]]\n"
     ]
    }
   ],
   "source": [
    "print(\"\\n10-base logarithm on 1st matrix using np\\n\",'-'*50,\"\\n\", np.log10(mat1))\n",
    "print(mat1)\n",
    "print(mat2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 270,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Modulo reminder using np\n",
      " -------------------------------------------------- \n",
      " [[1 5 4]\n",
      " [1 1 3]\n",
      " [0 3 0]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[1, 5, 4],\n",
       "       [1, 1, 3],\n",
       "       [0, 3, 0]])"
      ]
     },
     "execution_count": 270,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(\"\\nModulo reminder using np\\n\",'-'*50,\"\\n\", np.fmod(mat1,mat2))\n",
    "mat1%mat2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Combination of functions by shwoing exponetial decay of a sine wave\n",
      " ----------------------------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "print(\"\\nCombination of functions by shwoing exponetial decay of a sine wave\\n\",'-'*70)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 207,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.linspace(0,12*np.pi,1001)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 208,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.        ,  0.03769911,  0.07539822, ..., 37.62371362,\n",
       "       37.66141273, 37.69911184])"
      ]
     },
     "execution_count": 208,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}