Numpy+Training.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Numpy training and examples\n",
    "\n",
    "### Author: Samyakh Tukra (2017/18)\n",
    "\n",
    "#### The following shows the basics of creating arrays and the formatting of arrays:\n",
    "\n",
    "Remember the following: \n",
    "• Numpy is the fundamental package for working with N-dimensional\n",
    "array objects (vector, matrix, tensor, …)\n",
    "\n",
    "• But what is the difference between vector, matrix and a tensor, well the following image explains it:\n",
    "well a vector is a 1d tensor, i.e. a column of numbers. A Matrix is a 2d tensor i.e. a 3 (rows) by 3(columns) square matrix of numbers. A Tensor is nd (i.e. 3d and above) its like a cube/3d rectangle."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Basic Numpy datatypes\n",
    "\n",
    "''' So first import numpy and rename it as np'''\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.13.3\n"
     ]
    }
   ],
   "source": [
    "# to get the version of numpy we are using:\n",
    "print(np.__version__)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3]\n",
      "[4 5 6]\n",
      "[[1 2 3]\n",
      " [4 5 6]\n",
      " [7 8 9]]\n"
     ]
    }
   ],
   "source": [
    "#very similar to lists:\n",
    "\n",
    "# to create an array simply use the following function: np.array()\n",
    "\n",
    "a= np.array([1,2,3]) # notice how () are used to start the functions, but\n",
    "# the array is defined by a square brackets and separated by commas\n",
    "print a\n",
    "\n",
    "u= np.array ([4,5,6]) # so each element in [] defines the row i.e. x.... hence\n",
    "# this matrix is a 1 by 3 matrix\n",
    "\n",
    "# to make a bigger matrix we simply add more rows.... i.e.\n",
    "x= np.array([[1,2,3],[4,5,6],[7,8,9]]) # notice we have one big square brackets that engulfs the individual\n",
    "'''small square brackets in the function... this is to define the matrix as a whole\n",
    " the individual square brackets defines the individual rows i.e. x's\n",
    " Hence, each of the [1,2,3] is a row... in the function'''\n",
    "\n",
    "print u\n",
    "print x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 3,  6,  8,  0, 19, 10])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We can also turn our lists into values i.e.\n",
    "my_list= [3,6,8,0,19,10]\n",
    "# now convertting it into a numpy array uses the same function\n",
    "my_array= np.array(my_list)\n",
    "my_array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 30,  60,  80,   0, 190, 100])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# to multiply the array by a scalar 10 simply multiply!\n",
    "my_array*10\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<type 'list'>\n"
     ]
    }
   ],
   "source": [
    "# to see what type of array we have, simply use the type() function\n",
    "print(type(my_list))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<type 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "print(type(my_array))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3L, 3L)\n",
      "(2L, 5L)\n"
     ]
    }
   ],
   "source": [
    "# In addition to type we can also get the shape, i.e. is the matrix 1by 3 or 2by3\n",
    "# to do this, we simply use the shape function array_name.shape\n",
    "\n",
    "g= np.array([[4,5,6,7,8],[10,11,12,13,14]])\n",
    "\n",
    "print(np.shape(x)) # this is a 3by3 matrix\n",
    "print(np.shape(g)) # this is a 2 by 5 matrix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### The Following are some functions built into numpy that you must know:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4 5 6]\n",
      "[ 1.   1.5  2.   2.5  3.   3.5  4.   4.5]\n"
     ]
    }
   ],
   "source": [
    "### Other functions you should know:\n",
    "np.arange(7) # the arange() function (pronounces a-range) it creates an array of a\n",
    "# range of integers. This range starts with 0 up until but not including the final\n",
    "# parameter. i.e. evenly spaced values in a given interval\n",
    "''' the function parameters are as follows: np.arange([start],[stop],[dtype])\n",
    "so start value by default is 0, hence no need to state it unless you want the\n",
    "matrix to begin at 1 or 3 or any number of choice, stop is the end of the interval\n",
    "i.e. the interval will not include this number. finally dtype is the data type \n",
    "you want i.e. float32 or int16 another parameter that you can use after stop is\n",
    "step... which defines the spacing between the values'''\n",
    "print np.arange(7)\n",
    "print np.arange(1,5,0.5) # dtype is automatically crerated based on your other\n",
    "# inputs\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(np.arange(1,5,0.2)) # len helps us find the length i.e. size of the array\n",
    "# i.e. how many elements there are\n",
    "\n",
    "# numpy also has a function that let's me find the total no. of elements its\n",
    "# called, size()\n",
    "i= np.arange(1,5,0.2)\n",
    "i.size\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  5.  ,   6.25,   7.5 ,   8.75,  10.  ,  11.25,  12.5 ,  13.75,  15.  ])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "### Another function to create array that are linearly spaced is using\n",
    "# linspace() which creates a group of integers linearly spaced (evenly)\n",
    "'''np.linspace(start,stop,num,endpoint=True,retstep=True)\n",
    "so start and stop are the same as arange our value boundaries, num is the number\n",
    "of samples you want to generates (default is 50), endpoint is a boolean,\n",
    "so if True (default) the stop is the value of the last sample, retstep\n",
    "which is a boolean if set to True allows you to see the step size (increments)'''\n",
    "# As opposed ot the arange() the last number is included in the array!\n",
    "np.linspace(5,15,9) # 5 to 15 (including last num) numbers in 9 total elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  1.        ,   1.18367347,   1.36734694,   1.55102041,\n",
       "         1.73469388,   1.91836735,   2.10204082,   2.28571429,\n",
       "         2.46938776,   2.65306122,   2.83673469,   3.02040816,\n",
       "         3.20408163,   3.3877551 ,   3.57142857,   3.75510204,\n",
       "         3.93877551,   4.12244898,   4.30612245,   4.48979592,\n",
       "         4.67346939,   4.85714286,   5.04081633,   5.2244898 ,\n",
       "         5.40816327,   5.59183673,   5.7755102 ,   5.95918367,\n",
       "         6.14285714,   6.32653061,   6.51020408,   6.69387755,\n",
       "         6.87755102,   7.06122449,   7.24489796,   7.42857143,\n",
       "         7.6122449 ,   7.79591837,   7.97959184,   8.16326531,\n",
       "         8.34693878,   8.53061224,   8.71428571,   8.89795918,\n",
       "         9.08163265,   9.26530612,   9.44897959,   9.63265306,\n",
       "         9.81632653,  10.        ])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linspace(1,10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  1.,   2.,   3.,   4.,   5.,   6.,   7.,   8.,   9.,  10.])"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linspace(1,10,10) # will generate 10 samples! equally spaced"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([  1.,   2.,   3.,   4.,   5.,   6.,   7.,   8.,   9.,  10.]), 1.0)"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linspace(1,10,10,retstep=True) # the last component should be 1.0 i.e.\n",
    "# the elements will go up in increments of 1.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.,  0.,  0.,  0.,  0.])"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "### zeros() function will essentially create an array filled with zeros.\n",
    "np.zeros(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.,  0.,  0.,  0.,  0.],\n",
       "       [ 0.,  0.,  0.,  0.,  0.],\n",
       "       [ 0.,  0.,  0.,  0.,  0.],\n",
       "       [ 0.,  0.,  0.,  0.,  0.],\n",
       "       [ 0.,  0.,  0.,  0.,  0.]])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros((5,5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.,  0.,  0.,  0.,  0.,  0.],\n",
       "       [ 0.,  0.,  0.,  0.,  0.,  0.],\n",
       "       [ 0.,  0.,  0.,  0.,  0.,  0.],\n",
       "       [ 0.,  0.,  0.,  0.,  0.,  0.],\n",
       "       [ 0.,  0.,  0.,  0.,  0.,  0.],\n",
       "       [ 0.,  0.,  0.,  0.,  0.,  0.],\n",
       "       [ 0.,  0.,  0.,  0.,  0.,  0.],\n",
       "       [ 0.,  0.,  0.,  0.,  0.,  0.],\n",
       "       [ 0.,  0.,  0.,  0.,  0.,  0.],\n",
       "       [ 0.,  0.,  0.,  0.,  0.,  0.]])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros((10,6))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.,  1.,  1.,  1.],\n",
       "       [ 1.,  1.,  1.,  1.]])"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Similarly same can be done with ones using the ones() function:\n",
    "np.ones((2,4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 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",
       "\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",
       "\n",
       "       [[ 0.,  0.,  0.],\n",
       "        [ 0.,  0.,  0.],\n",
       "        [ 0.,  0.,  0.],\n",
       "        [ 0.,  0.,  0.]]])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "''' Now create a 3 dimensional array, rememebr when I said each [] entry is a\n",
    "row... i.e. it is a one dimension matrix, the external box [] makes it a 2d \n",
    "matrix constituted of 1d parts. Well to get it in 3d we simply add in a \n",
    "3rd parameter'''\n",
    "\n",
    "np.zeros((5,4,3))# first component 5 says we have 5 2d arrays, 2nd component\n",
    "# says we have 4 groups of matrices and the last component says we have 3 columns\n",
    "# Hence why there are 3 outer brackets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(5L, 4L, 3L)\n",
      "60\n"
     ]
    }
   ],
   "source": [
    "f= np.zeros((5,4,3))\n",
    "print f.shape\n",
    "print np.size(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('float64')"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# You can also get the data type of the actual array\n",
    "f.dtype\n",
    "# you can have different dtypes... even complex matrices by setting\n",
    "# dtype = complex"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2  3  4]\n",
      " [ 5  6  7  8]\n",
      " [ 9 10 11 12]\n",
      " [13 14 15 16]]\n"
     ]
    }
   ],
   "source": [
    "j=np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]])\n",
    "print j"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[7]])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "j[1:2,2:3]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[7]]\n"
     ]
    }
   ],
   "source": [
    "print(j[1:2,2:3])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "j[1][2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "j[1,2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2, 3],\n",
       "       [6, 7]])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "j[:2,1:3]# remember it never includes the last row/column only the start number\n",
    "# and the last-1 number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 6,  7],\n",
       "       [10, 11]])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "j[1:3,1:3]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 6,  7,  8],\n",
       "       [10, 11, 12],\n",
       "       [14, 15, 16]])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "j[1:4,1:4]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2  3  4]\n",
      " [ 5  6  7  8]\n",
      " [ 9 10 11 12]\n",
      " [13 14 15 16]]\n"
     ]
    }
   ],
   "source": [
    "b= np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]])\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3, 4]])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b[0:1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b[0,0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 5])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b[0:2,0]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  2,  3,  4],\n",
       "       [ 5,  6,  7,  8],\n",
       "       [ 9, 10, 11, 12],\n",
       "       [13, 14, 15, 16]])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b[0:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5, 6, 7, 8])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b[-3] # simply taking out the row and counting from the bottom"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4, 4)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int32')"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  4],\n",
       "       [ 5,  6,  7,  8,  9],\n",
       "       [10, 11, 12, 13, 14],\n",
       "       [15, 16, 17, 18, 19],\n",
       "       [20, 21, 22, 23, 24],\n",
       "       [25, 26, 27, 28, 29],\n",
       "       [30, 31, 32, 33, 34]])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new_array=np.arange(35)\n",
    "new_array.shape=(7,5)\n",
    "new_array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Broadcasting Arrays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 0,  1,  2,  3,  4],\n",
       "        [ 5,  6,  7,  8,  9],\n",
       "        [10, 11, 12, 13, 14],\n",
       "        [15, 16, 17, 18, 19],\n",
       "        [20, 21, 22, 23, 24],\n",
       "        [25, 26, 27, 28, 29],\n",
       "        [30, 31, 32, 33, 34]],\n",
       "\n",
       "       [[35, 36, 37, 38, 39],\n",
       "        [40, 41, 42, 43, 44],\n",
       "        [45, 46, 47, 48, 49],\n",
       "        [50, 51, 52, 53, 54],\n",
       "        [55, 56, 57, 58, 59],\n",
       "        [60, 61, 62, 63, 64],\n",
       "        [65, 66, 67, 68, 69]]])"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# now I am going to consider slicing a tensor:\n",
    "# this is simply creating 3d arrays:\n",
    "TD_array= np.arange(70)\n",
    "TD_array.shape= (2,7,5) # 7 rows, 5 columns and 2 layers in (2*7=14 *5 = 70)\n",
    "TD_array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 7, 5)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "TD_array.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "70\n",
      "int32\n"
     ]
    }
   ],
   "source": [
    "# The following will give the no of dimensions using the ndim function:\n",
    "print(TD_array.ndim) # result  = 3 i.e. 3 dimensions\n",
    "print(TD_array.size) # tells me the size.... i.e. the no of elements should be 70\n",
    "print(TD_array.dtype) # gives me the data type for each element... i.e. int32: 32 bit integers\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[35, 36, 37, 38, 39],\n",
       "       [40, 41, 42, 43, 44],\n",
       "       [45, 46, 47, 48, 49],\n",
       "       [50, 51, 52, 53, 54],\n",
       "       [55, 56, 57, 58, 59],\n",
       "       [60, 61, 62, 63, 64],\n",
       "       [65, 66, 67, 68, 69]])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "TD_array[1] # this will obtain a single layer of the 2 dimensional tensor in\n",
    "# the case below it obtains the second layer since the first layer begins with 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([50, 51, 52, 53, 54])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "TD_array[1,3] # this gives us the second layer (i.e. layer indexed 1) and the 4th\n",
    "# row of that layer\n",
    "# thus slicing tensors= [layer, row, column]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "52"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "TD_array[1,3,2]# will give me a single element\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[  0,   1,   2,   3,   4],\n",
       "        [  5,   6,   7,   8,   9],\n",
       "        [ 10,  11,  12,  13,  14],\n",
       "        [ 15,  16,  17,  18,  19],\n",
       "        [ 20,  21,  22,  23,  24],\n",
       "        [ 25,  26,  27,  28,  29],\n",
       "        [ 30,  31,  32,  33,  34]],\n",
       "\n",
       "       [[ 35,  36,  37,  38,  39],\n",
       "        [ 40,  41,  42,  43,  44],\n",
       "        [ 45,  46,  47,  48,  49],\n",
       "        [ 50,  51, 111,  53,  54],\n",
       "        [ 55,  56,  57,  58,  59],\n",
       "        [ 60,  61,  62,  63,  64],\n",
       "        [ 65,  66,  67,  68,  69]]])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# to change the values of a row or element simply refernce that part using the same\n",
    "#slicing methods and then assign a different value: i.e.\n",
    "TD_array[1,3,2] = 111\n",
    "TD_array\n",
    "# assiging the above element 52 a different value of 111"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[  0,   1,   2,   3,   4],\n",
       "        [  5,   6,   7,   8,   9],\n",
       "        [ 10,  11,  12,  13,  14],\n",
       "        [ 15,  16,  17,  18,  19],\n",
       "        [ 20,  21,  22,  23,  24],\n",
       "        [ 25,  26,  27,  28,  29],\n",
       "        [ 30,  31,  32,  33,  34]],\n",
       "\n",
       "       [[ 35,  36,  37,  38,  39],\n",
       "        [ 40,  41,  42,  43,  44],\n",
       "        [ 45,  46,  47,  48,  49],\n",
       "        [111, 112, 113, 114, 115],\n",
       "        [ 55,  56,  57,  58,  59],\n",
       "        [ 60,  61,  62,  63,  64],\n",
       "        [ 65,  66,  67,  68,  69]]])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "TD_array[1,3]=[111,112,113,114,115]\n",
    "TD_array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### So remember, to slice an array you use square brakets [ ] and to create an array you use simple brackets ( ) i.e. np.array([1,2,3],[1,2,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "this is the x array [[1 2 3]\n",
      " [4 5 6]\n",
      " [7 8 9]\n",
      " [9 1 4]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[1],\n",
       "       [4]])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x= np.array([[1,2,3],[4,5,6],[7,8,9],[9,1,4]])\n",
    "print('this is the x array {}'.format(x))\n",
    "x[:2,:1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  4,  5],\n",
       "       [ 6,  7,  8,  9, 10, 11],\n",
       "       [12, 13, 14, 15, 16, 17],\n",
       "       [18, 19, 20, 21, 22, 23],\n",
       "       [24, 25, 26, 27, 28, 29]])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u= np.arange(30)\n",
    "u.reshape(5,6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Boolean Mask Arrays\n",
    "\n",
    "### This is essentially to do with indexing an array using some logic operators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 4, 5, 6])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a= np.arange(10)\n",
    "a[(a>2)&(a<7)] # getting all values from the a vector that are bigger than 2 AND less than seven.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[~(a>7)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.89558154, 0.34275186, 0.6315173 , 0.39276864, 0.77649587],\n",
       "       [0.81201938, 0.78151105, 0.21028946, 0.97544788, 0.91719646],\n",
       "       [0.61041654, 0.15365853, 0.88206642, 0.45047208, 0.61200536],\n",
       "       [0.79725858, 0.88623563, 0.24606758, 0.01385505, 0.35204651]])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.rand(4,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "x= np.random.rand(3,2)\n",
    "y= np.random.rand(2,3)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 0 ns\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[0.56592587, 0.36247042, 0.36107794],\n",
       "       [0.47644484, 0.35639552, 0.31700806],\n",
       "       [0.71528397, 0.57191416, 0.4852902 ]])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%time np.dot(x,y)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.56592587, 0.47644484, 0.71528397],\n",
       "       [0.36247042, 0.35639552, 0.57191416],\n",
       "       [0.36107794, 0.31700806, 0.4852902 ]])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z=np.dot(x,y)\n",
    "np.transpose(z)\n"
   ]
  },
  {
   "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.5.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}