JNotebooks/tutorial02-numpy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to NumPy \n",
    "\n",
    "Numerical Python (*NumPy*) is a very powerful library that allows efficent multi-dimensional array processing. Most image processing and machine learning applications are built upon NumPy arrays (*ndarray*).\n",
    "\n",
    "The goals of this tutorial are:\n",
    "  - Introduce the NumPy library.\n",
    "  - Learn to declare multidimensional arrays and perform basic operations.\n",
    "  - Perform slicing operations.\n",
    "  - Manipulate array indexes.\n",
    "  - Understand arrays deep and shallow copies.\n",
    "\n",
    "\n",
    "## ndarray data type\n",
    "\n",
    "The ndarray data type, or simply array, is a N-dimensional arangement of items of the same type. Its elements are indexed by a tuple of N integers. ndarrays are defined by 3 essential information: data type (dtype), shape of each of the N dimensions, and its values.\n",
    "\n",
    "See an example of how to define a 1D ndarray and extract its essential information:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape of the array: a.shape= (6,)\n",
      "Data type= int64\n",
      "Printing the array: a=\n",
      "[ 2  3  4 -1  3 -2]\n"
     ]
    }
   ],
   "source": [
    "# Display plots within (inline) the notebook\n",
    "%matplotlib inline \n",
    "import matplotlib.pylab as plt # Graphics library\n",
    "import numpy as np # importing Numpy library with a nickname (np)\n",
    "\n",
    "a = np.array( [2,3,4,-1,3,-2] ) # defining a 1-dimensional array\n",
    "print('Shape of the array: a.shape=', a.shape)\n",
    "print('Data type=', a.dtype)\n",
    "print('Printing the array: a=')\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The same example, but now defining a 2D array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape of the array, b.shape= (2, 3)\n",
      "Data type, b.dtype float64\n",
      "Number of columns: 3\n",
      "Number of lines: 2\n",
      "Elements, b=\n",
      "[[1.5 2.3 5.2]\n",
      " [4.2 5.6 4.4]]\n"
     ]
    }
   ],
   "source": [
    "b = np.array( [ [1.5, 2.3, 5.2],\n",
    "                [4.2, 5.6, 4.4] ] )\n",
    "print('Shape of the array, b.shape=', b.shape)\n",
    "print('Data type, b.dtype', b.dtype)\n",
    "print('Number of columns:', b.shape[-1]) # b.shape[1] is equivalent\n",
    "print('Number of lines:', b.shape[-2]) # b.shape[0] is equivalent\n",
    "print('Elements, b=')\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ndarray manipulation\n",
    "\n",
    "### Creating arrays with initialized values\n",
    "\n",
    "It is possible to create arrays of 0s, 1s, and empty using the following functions: **zeros**, **ones** and **empty**. The array dimensions are a mandatory input, they are given by an input tuple. The data type is optional, the default value is float.\n",
    "\n",
    "The code below illustrates how to create initialized arrays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0s Array:\n",
      "[0. 0. 0. 0.]\n",
      "float64\n",
      "(4,)\n",
      "\n",
      "\n",
      "1s Array:\n",
      "[[1 1]\n",
      " [1 1]\n",
      " [1 1]]\n",
      "int16\n",
      "(3, 2)\n",
      "\n",
      "\n",
      "Non-initialized array:\n",
      "[[[1.83723093e-316 0.00000000e+000]\n",
      "  [0.00000000e+000 0.00000000e+000]\n",
      "  [0.00000000e+000 0.00000000e+000]]\n",
      "\n",
      " [[0.00000000e+000 0.00000000e+000]\n",
      "  [0.00000000e+000 0.00000000e+000]\n",
      "  [0.00000000e+000 0.00000000e+000]]]\n",
      "float64\n",
      "(2, 3, 2)\n"
     ]
    }
   ],
   "source": [
    "d = np.zeros( (4) ) #1-dimensional\n",
    "print('0s Array:')\n",
    "print(d)\n",
    "print(d.dtype)\n",
    "print(d.shape)\n",
    "print(\"\\n\")\n",
    "\n",
    "d = np.ones( (3,2), dtype='int16' ) # 2-dimensional   \n",
    "print('1s Array:')\n",
    "print(d)\n",
    "print(d.dtype)\n",
    "print(d.shape)\n",
    "print(\"\\n\")\n",
    "\n",
    "d = np.empty( (2,3,2), 'float')  # 3-dimensional. The values are random residuals in memory\n",
    "print('Non-initialized array:')\n",
    "print(d)\n",
    "print(d.dtype)\n",
    "print(d.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating arrays with sequential values (linspace and arange)\n",
    "\n",
    "The NumPy functions **linspace** and **arange** have the same goal: create **ndarrays** linearly spaced between a range of values. The major differences between them are how the range of values is interpreted and how the increments (steps) are computed. **Arange** does not include the last value of the interval, while **linspace** includes. **Arange** receives the step parameter as input, while **linspace** receives the number of elements of the output array and computes the step from that.\n",
    "\n",
    "See some examples below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "np.arange( 10) =  [0 1 2 3 4 5 6 7 8 9]\n",
      "np.arange( 3, 8) =  [3 4 5 6 7]\n",
      "np.arange( 0, 2, 0.5) =  [0.  0.5 1.  1.5]\n",
      "np.linspace( 0, 2, 5 ) =  [0.  0.5 1.  1.5 2. ]\n"
     ]
    }
   ],
   "source": [
    "print('np.arange( 10) = ', np.arange(10)) # final valued not included in the sequence\n",
    "print('np.arange( 3, 8) = ', np.arange(3,8))\n",
    "print('np.arange( 0, 2, 0.5) = ', np.arange(0, 2, 0.5)) \n",
    "print('np.linspace( 0, 2, 5 ) = ', np.linspace( 0, 2, 5 )) # final value included"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1D slicing\n",
    "\n",
    "\n",
    "A powerful NumPy resource is the slicing operation, which allows you to access a subset of values from the array. The slicing operation defines which indexes of the array will be accessed by defining the initial index, the final index and the step using the following syntax: my_array_[begin:end:step]. All slicing parameters are optional. The syntax is similar to slicing Python lists.\n",
    "\n",
    "In the simple example below, we access the odd inexes starting in 1 and ending in 13:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1D slicing a[1:15:2]\n",
      "[ 1  3  5  7  9 11 13]\n"
     ]
    }
   ],
   "source": [
    "a = np.arange(20) # the indexes match the values of the array\n",
    "print('1D slicing a[1:15:2]')\n",
    "print(a[1:15:2]) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Slicing using negative indexes\n",
    "\n",
    "The code below accesses the odd elements, except for the last:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a[1:-1:2]\n",
      "[ 1  3  5  7  9 11 13 15 17]\n",
      "Observe that the last odd element (19) is not included\n"
     ]
    }
   ],
   "source": [
    "a = np.arange(20)\n",
    "print('a[1:-1:2]')\n",
    "print(a[1:-1:2])\n",
    "print('Observe that the last odd element (19) is not included') "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Inverting the array order"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a=\n",
      "[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19]\n",
      "\n",
      "\n",
      "a inverted\n",
      "[19 18 17 16 15 14 13 12 11 10  9  8  7  6  5  4  3  2  1  0]\n"
     ]
    }
   ],
   "source": [
    "a = np.arange(20)\n",
    "print(\"a=\")\n",
    "print(a)\n",
    "print(\"\\n\")\n",
    "print(\"a inverted\")\n",
    "print(a[::-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1D slicing cheat sheet\n",
    "\n",
    "\n",
    "\n",
    "|Full syntax      | Short syntax |\n",
    "|-----------------|--------------|\n",
    "|a[0:len(a):1]    | a[:]         |\n",
    "|a[0:10:1]        | a[:10]       |\n",
    "|a[0:10:2]        | a[:10:2]     |\n",
    "|a[2:len(a):1]    | a[2::]       |\n",
    "|a[2:len(a):2]    | a[2::2]      |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2D array slicing\n",
    "\n",
    "### Initializing an array and changing its shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a =\n",
      "[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19]\n",
      "\n",
      "a.reshape(4,5) =\n",
      "[[ 0  1  2  3  4]\n",
      " [ 5  6  7  8  9]\n",
      " [10 11 12 13 14]\n",
      " [15 16 17 18 19]]\n"
     ]
    }
   ],
   "source": [
    "a = np.arange(20) # 1D array with 20 elements\n",
    "print('a =') \n",
    "print(a)\n",
    "print()\n",
    "\n",
    "a = a.reshape(4,5) # Reshape. Now a is a 4x5 2D array\n",
    "print('a.reshape(4,5) =')\n",
    "print(a) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Accessing lines and columns of an array\n",
    "\n",
    "The \"**:**\" operator indicates that all elements in that array dimension\n",
    "will be accessed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2nd line of a:\n",
      "[5 6 7 8 9]\n",
      "First column of a:\n",
      "[ 0  5 10 15]\n"
     ]
    }
   ],
   "source": [
    "print('2nd line of a:')\n",
    "print(a[1,:])  # Don't forget: second line is index 1\n",
    "\n",
    "print('First column of a:')\n",
    "print(a[:,0]) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Slicing specific rows and columns of an array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Getting every other line a[0::2,:]=\n",
      "[[ 0  1  2  3  4]\n",
      " [10 11 12 13 14]]\n",
      "Getting every other line and column starting at line 0 and column 1,a[0::2,1::2]\n",
      "[[ 1  3]\n",
      " [11 13]]\n"
     ]
    }
   ],
   "source": [
    "print('Getting every other line a[0::2,:]=')\n",
    "print(a[0::2,:]) \n",
    "\n",
    "print('Getting every other line and column starting at line 0 and column 1,a[0::2,1::2]')\n",
    "print(a[0::2,1::2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2D slicing with inverted indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Getting the last 2 lines in reverse order, b = a[-1:-3:-1,:] =\n",
      "[[15 16 17 18 19]\n",
      " [10 11 12 13 14]]\n",
      "Getting the element in the last line and column, a[-1,-1] =\n",
      "19\n",
      "Inverting array lines: c = a[::-1,:] =\n",
      "[[15 16 17 18 19]\n",
      " [10 11 12 13 14]\n",
      " [ 5  6  7  8  9]\n",
      " [ 0  1  2  3  4]]\n"
     ]
    }
   ],
   "source": [
    "b = a[-1:-3:-1,:]\n",
    "print('Getting the last 2 lines in reverse order, b = a[-1:-3:-1,:] =')\n",
    "print(a[-1:-3:-1,:])\n",
    "\n",
    "print('Getting the element in the last line and column, a[-1,-1] =')\n",
    "print(a[-1,-1])\n",
    "\n",
    "c = a[::-1,:] \n",
    "print('Inverting array lines: c = a[::-1,:] =')\n",
    "print(a[::-1,:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Copying ndarray variables\n",
    "\n",
    "\n",
    "The ndarray data structure was designed for enabling optimized access to large amounts of numerical data. There are 2 main types of ndarray copy operations: the shallow copy and the deep copy. Shallow copies create a new variable that points to the same data as the original variable, i.e. the same data are shared by the 2 variables. The deep copy creates a new variable with its own data. The data is initialized to the same values as the values of the data it was copied from.\n",
    "\n",
    "\n",
    "|Type                 |  Example           |\n",
    "|---------------------|--------------------|\n",
    "|Shallow copy         | a = b              |\n",
    "|Deep copy            | a = b.copy()       |\n",
    "\n",
    "### Shallow copy example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a =\n",
      "[0 1 2 3 4 5]\n",
      "b =\n",
      "[0 1 2 3 4 5]\n",
      "Shape of a = (2, 3)\n",
      "a =\n",
      " [[-1  1  2]\n",
      " [ 3  4  5]]\n",
      "id =  139779947184576\n",
      "id =  139779947184576\n",
      "np.may_share_memory(a,b): True\n"
     ]
    }
   ],
   "source": [
    "a = np.arange(6) \n",
    "b = a\n",
    "print(\"a =\")\n",
    "print(a)\n",
    "print(\"b =\") \n",
    "print(b)\n",
    "\n",
    "b.shape = (2,3)                     # if you change the shape of b\n",
    "print(\"Shape of a =\",a.shape)        # you are also altering the shape of a\n",
    "\n",
    "b[0,0] = -1                         # changing one element of b\n",
    "print(\"a =\\n\",a)                     # also changes the value in a  \n",
    "\n",
    "print(\"id = \",id(a))                # id is a number that identifies an object\n",
    "print(\"id = \",id(b))                # a and b have the same id\n",
    "\n",
    "print('np.may_share_memory(a,b):',np.may_share_memory(a,b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that even defining a function to do the copy, may result in a shallow copy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "id de a =  139779947184576\n",
      "id de b =  139779947184576\n",
      "np.may_share_memory(a,b): True\n"
     ]
    }
   ],
   "source": [
    "def cc(a):\n",
    "  return a\n",
    "b = cc(a)\n",
    "print(\"id de a = \",id(a))\n",
    "print(\"id de b = \",id(b))\n",
    "print('np.may_share_memory(a,b):',np.may_share_memory(a,b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Shallow copies are very useful. It can be used when you want to see your data in a different dimensionality and/or shape, but you don't want to make a copy of the data. This optimizes the access to the elements of the ndarray. Shallow copies currently occur through the following operations:\n",
    "\n",
    " - 1) reshape -> you view the array with a different shape and/or dimensionality\n",
    " - 2) Getting a subset of the original array through the slicing procedure, e.g a = b[::2]\n",
    " - 3) When you transpose the array\n",
    " - 4) When you linearize the array using the *ravel* function, among others.\n",
    "\n",
    "### Reshape\n",
    "\n",
    "The following example shows how to reshape a 1D array into 2D and 3D arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a =\n",
      "[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23\n",
      " 24 25 26 27 28 29]\n",
      "b =\n",
      "[[ 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]]\n",
      "a =\n",
      "[-1  1  2  3  4  5 -1  7  8  9 10 11 -1 13 14 15 16 17 -1 19 20 21 22 23\n",
      " -1 25 26 27 28 29]\n",
      "c =\n",
      "[[[-1  1  2  3  4]\n",
      "  [ 5 -1  7  8  9]\n",
      "  [10 11 -1 13 14]]\n",
      "\n",
      " [[15 16 17 -1 19]\n",
      "  [20 21 22 23 -1]\n",
      "  [25 26 27 28 29]]]\n",
      "c.base is a:\n",
      "True\n",
      "np.may_share_memory(a,c):\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "a = np.arange(30)\n",
    "print(\"a =\")\n",
    "print(a)\n",
    "b = a.reshape( (5, 6))\n",
    "print(\"b =\")\n",
    "print(b)\n",
    "b[:, 0] = -1\n",
    "print(\"a =\")\n",
    "print(a)\n",
    "c = a.reshape((2, 3, 5)) \n",
    "print(\"c =\")\n",
    "print(c)\n",
    "print('c.base is a:')\n",
    "print(c.base is a)\n",
    "print('np.may_share_memory(a,c):')\n",
    "print(np.may_share_memory(a,c))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Shallow copies generated by slicing a larger array\n",
    "\n",
    "The following example shows how shallow copies generated using the slicing operation work."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'> (5, 6) float64 0.0 0.0\n",
      "<class 'numpy.ndarray'> (3, 3) float64 0.0 0.0\n",
      "b=\n",
      "[[1. 1. 1.]\n",
      " [1. 1. 1.]\n",
      " [1. 1. 1.]]\n",
      "a=\n",
      "[[1. 0. 1. 0. 1. 0.]\n",
      " [0. 0. 0. 0. 0. 0.]\n",
      " [1. 0. 1. 0. 1. 0.]\n",
      " [0. 0. 0. 0. 0. 0.]\n",
      " [1. 0. 1. 0. 1. 0.]]\n",
      "b.base is a:\n",
      "True\n",
      "np.may_share_memory(a,b):\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "a = np.zeros( (5, 6))\n",
    "print('%s %s %s %s %s' % (type(a), np.shape(a), a.dtype, a.min(), a.max()))\n",
    "b = a[::2,::2]\n",
    "print('%s %s %s %s %s' % (type(b), np.shape(b), b.dtype, b.min(), b.max()))\n",
    "b[:,:] = 1. #assigns 1s to every other elemnt in a\n",
    "print('b=')\n",
    "print(b)\n",
    "print('a=')\n",
    "print(a)\n",
    "print('b.base is a:')\n",
    "print(b.base is a)\n",
    "print('np.may_share_memory(a,b):')\n",
    "print(np.may_share_memory(a,b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following example shows how to process a single column of an array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a=\n",
      "[[ 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",
      "b=\n",
      "[ 0  5 10 15 20]\n",
      "b=\n",
      "[0 1 2 3 4]\n",
      "a=\n",
      "[[ 0  1  2  3  4]\n",
      " [ 1  6  7  8  9]\n",
      " [ 2 11 12 13 14]\n",
      " [ 3 16 17 18 19]\n",
      " [ 4 21 22 23 24]]\n"
     ]
    }
   ],
   "source": [
    "a = np.arange(25).reshape((5,5))\n",
    "print('a=')\n",
    "print(a)\n",
    "b = a[:,0]\n",
    "print('b=')\n",
    "print(b)\n",
    "b[:] = np.arange(5) # This assignment  changes the values of the first column of a\n",
    "print('b=')\n",
    "print(b)\n",
    "print('a=')\n",
    "print(a) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Transpose\n",
    "\n",
    "\n",
    "The transpose of an array exchanges the order of its axis (dimensions). The transpose operation creates a shallow copy of the array. See the following example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a:\n",
      "[[ 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",
      "at:\n",
      "[[ 0  6 12 18]\n",
      " [ 1  7 13 19]\n",
      " [ 2  8 14 20]\n",
      " [ 3  9 15 21]\n",
      " [ 4 10 16 22]\n",
      " [ 5 11 17 23]]\n",
      "np.may_share_memory(a,at):\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "a = np.arange(24).reshape((4,6))\n",
    "print('a:')\n",
    "print(a)\n",
    "at = a.T\n",
    "print('at:')\n",
    "print(at)\n",
    "print('np.may_share_memory(a,at):')\n",
    "print(np.may_share_memory(a,at))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "See the transpose operation on a 3-dimensional array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a.shape= (1, 2, 9)\n",
      "[[[ 0  1  2  3  4  5  6  7  8]\n",
      "  [ 9 10 11 12 13 14 15 16 17]]]\n",
      "a transpose shape= (9, 1, 2)\n",
      "[[[ 0  9]]\n",
      "\n",
      " [[ 1 10]]\n",
      "\n",
      " [[ 2 11]]\n",
      "\n",
      " [[ 3 12]]\n",
      "\n",
      " [[ 4 13]]\n",
      "\n",
      " [[ 5 14]]\n",
      "\n",
      " [[ 6 15]]\n",
      "\n",
      " [[ 7 16]]\n",
      "\n",
      " [[ 8 17]]]\n"
     ]
    }
   ],
   "source": [
    "a = np.arange(18).reshape(1,2,9)\n",
    "print('a.shape=',a.shape)\n",
    "print(a)\n",
    "at = a.transpose(2,0,1)\n",
    "print('a transpose shape=',at.shape )   \n",
    "print(at)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ravel\n",
    "\n",
    "The ravel function creates a 1D linearized version of the array. It also generates a shallow copy of the original array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a:\n",
      "[[ 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",
      "av.shape:\n",
      "(24,)\n",
      "av:\n",
      "\n",
      "[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23]\n",
      "np.may_share_memory(a,av):\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "a = np.arange(24).reshape((4,6))\n",
    "print('a:')\n",
    "print(a)\n",
    "av = a.ravel()\n",
    "print('av.shape:')\n",
    "print(av.shape)\n",
    "print('av:\\n')\n",
    "print(av)\n",
    "print('np.may_share_memory(a,av):')\n",
    "print(np.may_share_memory(a,av))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Deep Copy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "id de a = \n",
      "139779947190112\n",
      "id de b = \n",
      "139779947188272\n",
      "id de c = \n",
      "139779947187856\n"
     ]
    }
   ],
   "source": [
    "b = a.copy() # New memory space is allocated and data is copied\n",
    "c = np.array(a, copy=True) # New memory space is allocated and data is copied\n",
    "\n",
    "print(\"id de a = \")\n",
    "print(id(a))\n",
    "print(\"id de b = \")\n",
    "print(id(b))\n",
    "print(\"id de c = \")\n",
    "print (id(c))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Matrix Operations\n",
    "\n",
    "\n",
    "One of the main advantages of working with **ndarrays** is its capacity to efficently process multidimensional arrays. To multiply all elements of an array by a scalar, for instance, you just have to type  *a$*$5*. To perform any boolean operation between arrays, you just need to type  *a $<operation>$ b*. See the examples:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a=\n",
      " [[ 0  1  2  3]\n",
      " [ 4  5  6  7]\n",
      " [ 8  9 10 11]\n",
      " [12 13 14 15]\n",
      " [16 17 18 19]]\n",
      "b=\n",
      " [[2. 2. 2. 2.]\n",
      " [2. 2. 2. 2.]\n",
      " [2. 2. 2. 2.]\n",
      " [2. 2. 2. 2.]\n",
      " [2. 2. 2. 2.]]\n",
      "c=\n",
      " [[12 11 10]\n",
      " [ 9  8  7]\n",
      " [ 6  5  4]\n",
      " [ 3  2  1]]\n"
     ]
    }
   ],
   "source": [
    "a = np.arange(20).reshape(5,4)\n",
    "b = 2 * np.ones((5,4))    \n",
    "c = np.arange(12,0,-1).reshape(4,3)\n",
    "print('a=\\n', a)\n",
    "print('b=\\n', b)\n",
    "print('c=\\n', c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Multiplication of an array by a scalar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b5=\n",
      " [[10. 10. 10. 10.]\n",
      " [10. 10. 10. 10.]\n",
      " [10. 10. 10. 10.]\n",
      " [10. 10. 10. 10.]\n",
      " [10. 10. 10. 10.]]\n"
     ]
    }
   ],
   "source": [
    "b5 = 5 * b\n",
    "\n",
    "print('b5=\\n', b5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Adding two arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "amb=\n",
      " [[ 2.  3.  4.  5.]\n",
      " [ 6.  7.  8.  9.]\n",
      " [10. 11. 12. 13.]\n",
      " [14. 15. 16. 17.]\n",
      " [18. 19. 20. 21.]]\n"
     ]
    }
   ],
   "source": [
    "amb = a + b\n",
    "\n",
    "print('amb=\\n', amb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  Matrix multiplication\n",
    "\n",
    "Matrix multiplications are done using the **dot** function. In order  for the multiplication to be feasible, the number of columns of the first array must be equal to the number of lines of the second array. See the example below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a.shape: (2, 3)\n",
      "c.shape: (3, 2)\n",
      "a=\n",
      " [[0 1 2]\n",
      " [3 4 5]]\n",
      "c=\n",
      " [[1. 1.]\n",
      " [1. 1.]\n",
      " [1. 1.]]\n",
      "ac=\n",
      " [[ 3.  3.]\n",
      " [12. 12.]]\n",
      "ac.shape: (2, 2)\n"
     ]
    }
   ],
   "source": [
    "a = np.arange(6).reshape(2,3)\n",
    "c = np.ones((3,2))\n",
    "ac = np.dot(a,c)\n",
    "\n",
    "print('a.shape:',a.shape)\n",
    "print('c.shape:',c.shape)\n",
    "print('a=\\n',a)\n",
    "print('c=\\n',c)\n",
    "print('ac=\\n', ac)\n",
    "print('ac.shape:',ac.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## indices and meshgrid functions\n",
    "\n",
    "The functions **indices** and **meshgrid** are useful for creating synthetic images and they are useful for understanding the **NumPy** array programming style, which avoids the use of explicit loops in the code.\n",
    "\n",
    "### Indices: small numerical examples\n",
    "\n",
    "The **indices** function receives as input parameter a tuple with the dimensions of a n-dimensional array, e.g. (d1,d2,..,dn). The output of the function is a tuple (the sample length as the input tuple), where each element of the tuple is an array of indexes with the same shape defined by the input tuple. See the 2D example below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "r=\n",
      " [[0 0 0 0 0 0 0 0 0 0]\n",
      " [1 1 1 1 1 1 1 1 1 1]\n",
      " [2 2 2 2 2 2 2 2 2 2]\n",
      " [3 3 3 3 3 3 3 3 3 3]\n",
      " [4 4 4 4 4 4 4 4 4 4]]\n",
      "c=\n",
      " [[0 1 2 3 4 5 6 7 8 9]\n",
      " [0 1 2 3 4 5 6 7 8 9]\n",
      " [0 1 2 3 4 5 6 7 8 9]\n",
      " [0 1 2 3 4 5 6 7 8 9]\n",
      " [0 1 2 3 4 5 6 7 8 9]]\n"
     ]
    }
   ],
   "source": [
    "r,c = np.indices( (5, 10) )\n",
    "print('r=\\n', r)\n",
    "print('c=\\n', c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that *r* is an array where each of its elements represent their line coordinate, while *c* is an array where each of its elements  represent their column coordinate. Therefore, any operation performed in *r* and *c* represents an operation in the indexes that you use to acces an array 5x10. You can use this knowledge to create synthetic images from mathematical functions that involve the elements' coordinates. Let's implement a mathematical function that returns the sum of the coordinates of each element in an array, $f(r,c) = r + c$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "f=\n",
      " [[ 0  1  2  3  4  5  6  7  8  9]\n",
      " [ 1  2  3  4  5  6  7  8  9 10]\n",
      " [ 2  3  4  5  6  7  8  9 10 11]\n",
      " [ 3  4  5  6  7  8  9 10 11 12]\n",
      " [ 4  5  6  7  8  9 10 11 12 13]]\n"
     ]
    }
   ],
   "source": [
    "f = r + c\n",
    "print('f=\\n', f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or the difference between the row and column coordinates, $f(r,c) = r - c$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "f=\n",
      " [[ 0 -1 -2 -3 -4 -5 -6 -7 -8 -9]\n",
      " [ 1  0 -1 -2 -3 -4 -5 -6 -7 -8]\n",
      " [ 2  1  0 -1 -2 -3 -4 -5 -6 -7]\n",
      " [ 3  2  1  0 -1 -2 -3 -4 -5 -6]\n",
      " [ 4  3  2  1  0 -1 -2 -3 -4 -5]]\n"
     ]
    }
   ],
   "source": [
    "f = r - c\n",
    "print('f=\\n', f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another possible function is the remainder of the division given by  $f(r,c) = (r + c) \\% 2$, where  % is the division remainder operation. The output is an array that looks like a cheesborad:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "f=\n",
      " [[0 1 0 1 0 1 0 1 0 1]\n",
      " [1 0 1 0 1 0 1 0 1 0]\n",
      " [0 1 0 1 0 1 0 1 0 1]\n",
      " [1 0 1 0 1 0 1 0 1 0]\n",
      " [0 1 0 1 0 1 0 1 0 1]]\n"
     ]
    }
   ],
   "source": [
    "f = (r + c) % 2\n",
    "print('f=\\n', f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The line function, $f(r,c) = (r = \\frac{1}{2}c)$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "f=\n",
      " [[ True  True False False False False False False False False]\n",
      " [False False  True  True False False False False False False]\n",
      " [False False False False  True  True False False False False]\n",
      " [False False False False False False  True  True False False]\n",
      " [False False False False False False False False  True  True]]\n"
     ]
    }
   ],
   "source": [
    "f = (r == c//2)\n",
    "print('f=\\n', f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Circle with radius 4, $f(r,c) = (r^2 + c^2 < 4^2)$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "f=\n",
      " [[1 1 1 1 0 0 0 0 0 0]\n",
      " [1 1 1 1 0 0 0 0 0 0]\n",
      " [1 1 1 1 0 0 0 0 0 0]\n",
      " [1 1 1 0 0 0 0 0 0 0]\n",
      " [0 0 0 0 0 0 0 0 0 0]]\n"
     ]
    }
   ],
   "source": [
    "f = ((r**2 + c**2) < 4**2)\n",
    "print('f=\\n', f * 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## indices function for generating synthetic images\n",
    "\n",
    "We illustrate here the same examples as above, but displaying the outputs as images."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "r,c = np.indices( (200, 300) )\n",
    "plt.subplot(121)\n",
    "plt.imshow(r,cmap = 'gray')\n",
    "plt.title(\"Lines\")\n",
    "plt.axis('off')\n",
    "plt.subplot(122)\n",
    "plt.imshow(c,cmap = 'gray')\n",
    "plt.axis('off')\n",
    "plt.title(\"Columns\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sum of coordinates\n",
    "\n",
    "$f(r,c) = r + c$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "f = r + c\n",
    "plt.imshow(f,cmap = 'gray')\n",
    "plt.title(\"r+c\")\n",
    "plt.axis(\"off\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Subtraction of Coordinates\n",
    "\n",
    "$f(r,c) = r - c$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "f = r - c\n",
    "plt.imshow(f,cmap = 'gray')\n",
    "plt.title(\"r-c\")\n",
    "plt.axis(\"off\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Chessboard Function\n",
    "\n",
    "Squares with dimensions equal 8: \n",
    "\n",
    "$f(r,c) = \\frac{(r + c)}{8} \\% 2$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "f = (r//8 + c//8) % 2\n",
    "plt.imshow(f,cmap = 'gray')\n",
    "plt.title(\"(r+c)%2\")\n",
    "plt.axis(\"off\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Line Function\n",
    "\n",
    "$f(r,c) = (r = \\frac{1}{2} c)$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "f = (r == c//2)\n",
    "plt.imshow(f,cmap = 'gray')\n",
    "plt.title('r == c//2')\n",
    "plt.axis(\"off\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Circle Function\n",
    "\n",
    "Circle with radius 190:\n",
    "\n",
    "$f(r,c) = (r^2 + c^2 < 190^2)$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "f = (((r-100)**2 + (c-100)**2) < 19**2)\n",
    "plt.imshow(f,cmap = 'gray')\n",
    "plt.title('((r-100)**2 + (c-100)**2) < 19**2')\n",
    "plt.axis(\"off\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## meshgrid\n",
    "\n",
    "The **meshgrid** function is similar to the *indices* function. The main difference is that **meshgrid** is capable of generating negative indexes, while **indices** can only generate positive indexes. See below a simple **meshgrid** example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "r=\n",
      " [[-1.5 -1.5 -1.5 -1.5 -1.5 -1.5]\n",
      " [-1.  -1.  -1.  -1.  -1.  -1. ]\n",
      " [-0.5 -0.5 -0.5 -0.5 -0.5 -0.5]\n",
      " [ 0.   0.   0.   0.   0.   0. ]\n",
      " [ 0.5  0.5  0.5  0.5  0.5  0.5]]\n",
      "c=\n",
      " [[-20 -10   0  10  20  30]\n",
      " [-20 -10   0  10  20  30]\n",
      " [-20 -10   0  10  20  30]\n",
      " [-20 -10   0  10  20  30]\n",
      " [-20 -10   0  10  20  30]]\n"
     ]
    }
   ],
   "source": [
    "r, c = np.meshgrid( np.array([-1.5, -1.0, -0.5, 0.0, 0.5]),\\\n",
    "                   np.array([-20, -10, 0, 10, 20, 30]), indexing='ij')\n",
    "print('r=\\n',r)\n",
    "print('c=\\n',c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## resize\n",
    "\n",
    "The **resize** function changes the shape of an array. In case the new array is larger than the original it is filled with copies of the initial array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a = \n",
      " [[0 1]\n",
      " [2 3]]\n",
      "\n",
      "np.resize(a,(1,7)) = \n",
      " [[0 1 2 3 0 1 2]]\n",
      "\n",
      "np.resize(a,(2,5)) = \n",
      " [[0 1 2 3 0]\n",
      " [1 2 3 0 1]]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([[0,1],[2,3]])\n",
    "\n",
    "print('a = \\n', a)   \n",
    "print()\n",
    "\n",
    "print('np.resize(a,(1,7)) = \\n', np.resize(a,(1,7)))\n",
    "print()\n",
    "\n",
    "\n",
    "print('np.resize(a,(2,5)) = \\n', np.resize(a,(2,5)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## clip\n",
    "\n",
    "The **clip** function clips the array elements at specified lower and upper thresholds."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a =  [11  1  2  3  4  5 12 -3 -4  7  4]\n",
      "\n",
      "np.clip(a,0,10) =  [10  1  2  3  4  5 10  0  0  7  4]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([11,1,2,3,4,5,12,-3,-4,7,4])\n",
    "print('a = ',a)\n",
    "print('\\nnp.clip(a,0,10) = ', np.clip(a,0,10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Formatting floating point arrays for printing\n",
    "\n",
    "Floating point arrays may have many decimal points:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A: \n",
      " [[3.68390306e-04 5.06993321e-04 6.97744275e-04 9.60263289e-04\n",
      "  1.32155235e-03 1.81877265e-03 2.50306691e-03 3.44481975e-03]\n",
      " [4.74089730e-03 6.52461051e-03 8.97942724e-03 1.23578432e-02\n",
      "  1.70073529e-02 2.34061923e-02 3.22125283e-02 4.43321564e-02]\n",
      " [6.10116684e-02 8.39666729e-02 1.15558259e-01 1.59035850e-01\n",
      "  2.18871431e-01 3.01219527e-01 4.14550236e-01 5.70520443e-01]\n",
      " [7.85172815e-01 1.08058591e+00 1.48714510e+00 2.04666794e+00\n",
      "  2.81670543e+00 3.87646151e+00 5.33493976e+00 7.34215526e+00]]\n"
     ]
    }
   ],
   "source": [
    "A = np.exp(np.linspace(0.1,10,32)).reshape(4,8)/3000.\n",
    "print('A: \\n', A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Therefore, you may supress some decimal houses using the **set_printoption** function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A: \n",
      " [[0.    0.001 0.001 0.001 0.001 0.002 0.003 0.003]\n",
      " [0.005 0.007 0.009 0.012 0.017 0.023 0.032 0.044]\n",
      " [0.061 0.084 0.116 0.159 0.219 0.301 0.415 0.571]\n",
      " [0.785 1.081 1.487 2.047 2.817 3.876 5.335 7.342]]\n"
     ]
    }
   ],
   "source": [
    "np.set_printoptions(suppress=True, precision=3)\n",
    "\n",
    "print('A: \\n', A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Where to learn NumPy?\n",
    "\n",
    "The best way to become a NumPy expert is by studying its documentation and examples. See some interesting links:\n",
    "\n",
    "- [NumPy documentation](http://www.numpy.org/)\n",
    "- [Tentative NumPy Tutorial](https://scipy.github.io/old-wiki/pages/Tentative_NumPy_Tutorial)\n"
   ]
  }
 ],
 "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.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}