Notebooks/intro_numpy.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fri Jun 30 12:59:47 2017\n",
      "3.6.1 \n"
     ]
    }
   ],
   "source": [
    "# The following is to know when this notebook has been run and with which python version.\n",
    "import time, sys\n",
    "print(time.ctime())\n",
    "print(sys.version.split('|')[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# B Numpy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is part of the Python lecture given by Christophe Morisset at IA-UNAM."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Import numpy first"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# You need first to import the numpy library (must be installed on your computer ;-) )\n",
    "# As it will be widely used, better to give it a nickname, or an alias. Traditionnaly, it's \"np\":\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.12.1\n"
     ]
    }
   ],
   "source": [
    "print(np.__version__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tutorials"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "http://nbviewer.ipython.org/github/jrjohansson/scientific-python-lectures/blob/master/Lecture-2-Numpy.ipynb AND\n",
    "http://nbviewer.ipython.org/gist/rpmuller/5920182 AND http://www.astro.washington.edu/users/vanderplas/Astr599/notebooks/11_EfficientNumpy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The ARRAY class"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Create an array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6]\n",
      "[1 2 3 4 5 6]\n",
      "<class 'numpy.ndarray'>\n",
      "[1 2 3]\n"
     ]
    }
   ],
   "source": [
    "# Easy to create a numpy array (the basic class) from a list\n",
    "l = [1,2,3,4,5,6]\n",
    "print(l)\n",
    "a = np.array([1,2,3,4,5,6])\n",
    "print(a)\n",
    "print(type(a))\n",
    "# Works with tuples also:\n",
    "b = np.array((1,2,3))\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numpy arrays are efficiently connected to the computer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "379 µs ± 3.8 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n",
      "2.25 µs ± 37.8 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
     ]
    }
   ],
   "source": [
    "L = range(1000)\n",
    "%timeit L2 = [i**2 for i in L] # Notice the use of timeit, a magic function (starts with %)\n",
    "A = np.arange(1000)\n",
    "%timeit A2 = A**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "int64\n",
      "[1 2 3 4]\n"
     ]
    }
   ],
   "source": [
    "L = [1, 2, 3, 4]\n",
    "a = np.array(L)\n",
    "print(a.dtype)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "float64\n",
      "[ 1.  2.  3.  4.]\n"
     ]
    }
   ],
   "source": [
    "L = [1,2,3,4.]\n",
    "a = np.array(L)\n",
    "print(a.dtype)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4.0, 'a']\n",
      "<U32\n",
      "['1' '2' '3' '4.0' 'a']\n"
     ]
    }
   ],
   "source": [
    "L = [1,2,3,4.,'a']\n",
    "a = np.array(L)\n",
    "print(L) # Different types can coexist in a python list\n",
    "print(a.dtype)\n",
    "print(a) # NOT in a numpy array. The array is re-typed to the highest type, here string."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once the type of an array is defined, one can insert values of type that can be transformed to the type of the array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5 6]\n",
      "[1 2 3 4 2 6]\n",
      "[ 1  2  3 20  2  6]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([1,2,3,4,5,6]) \n",
    "print(a)\n",
    "a[4] = 2.56 # will be transformed to int(2.56)\n",
    "print(a)\n",
    "a[3] = '20' # will be tranformed to int('20')\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "invalid literal for int() with base 10: '3.2'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-10-2af1cc391cb1>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0ma\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'3.2'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m: invalid literal for int() with base 10: '3.2'"
     ]
    }
   ],
   "source": [
    "a[2] = '3.2'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "invalid literal for int() with base 10: 'tralala'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-11-f6467d624e31>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0ma\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'tralala'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m: invalid literal for int() with base 10: 'tralala'"
     ]
    }
   ],
   "source": [
    "a[2] = 'tralala'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1D, 2D, 3D, ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(6,) (2, 2) (2, 2, 1)\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "a = np.array([1,2,3,4,5,6])\n",
    "b = np.array([[1,2],[1,4]])\n",
    "c = np.array([[[1], [2]], [[3], [4]]])\n",
    "print(a.shape, b.shape, c.shape)\n",
    "print(a[0]) # no error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6 2 2\n"
     ]
    }
   ],
   "source": [
    "print(len(a), len(b), len(c)) # size of the first dimension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3\n"
     ]
    }
   ],
   "source": [
    "print(a.ndim, b.ndim, c.ndim) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mean: 3.5, max: 6, shape: (6,)\n"
     ]
    }
   ],
   "source": [
    "a = np.array([1,2,3,4,5,6])\n",
    "print('mean: {0}, max: {1}, shape: {2}'.format(a.mean(), a.max(), a.shape))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "mean and max are methods (functions) of the array class, they need ()s. shape is an atribute (like a variable)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<built-in method mean of numpy.ndarray object at 0x7fa7a0455a30>\n"
     ]
    }
   ],
   "source": [
    "print(a.mean) # this is printing information about the function, NOT the result of the function!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.5\n"
     ]
    }
   ],
   "source": [
    "mm = a.mean # We assign to mn the function. Then we can call it directly, but still need for the ()s:\n",
    "print(mm())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [1 4]]\n",
      "2.0\n",
      "[ 1.  3.]\n",
      "[ 1.5  2.5]\n",
      "2.0\n"
     ]
    }
   ],
   "source": [
    "print(b)\n",
    "print(b.mean()) # mean over the whole array\n",
    "print(b.mean(axis=0)) # mean over the first axis (columns)\n",
    "print(b.mean(1)) # mean over the raws\n",
    "print(np.mean(b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Creating arrays from scratch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4 5 6 7 8 9]\n"
     ]
    }
   ],
   "source": [
    "print(np.arange(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0.          0.11111111  0.22222222  0.33333333  0.44444444  0.55555556\n",
      "  0.66666667  0.77777778  0.88888889  1.        ]\n",
      "--------------------------------\n",
      "[ 0.   0.1  0.2  0.3  0.4  0.5  0.6  0.7  0.8  0.9  1. ]\n",
      "--------------------------------\n",
      "[ 0.   0.1  0.2  0.3  0.4  0.5  0.6  0.7  0.8  0.9]\n"
     ]
    }
   ],
   "source": [
    "print(np.linspace(0, 1, 10)) # start, stop (included), number of points\n",
    "print('--------------------------------')\n",
    "print(np.linspace(0, 1, 11)) # start, stop (included), number of points\n",
    "print('--------------------------------')\n",
    "print(np.linspace(0, 1, 10, endpoint=False)) # Not including the stop point"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[   1.            1.66810054    2.7825594     4.64158883    7.74263683\n",
      "   12.91549665   21.5443469    35.93813664   59.94842503  100.        ]\n"
     ]
    }
   ],
   "source": [
    "print(np.logspace(0, 2, 10)) # from 10**start to 10**stop, with 10 values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0.  0.]\n",
      "--------------------------------\n",
      "[[ 0.  0.  0.]\n",
      " [ 0.  0.  0.]]\n",
      "--------------------------------\n",
      "[1 1 1 1 1 1]\n",
      "--------------------------------\n",
      "[ 3.  3.  3.  3.  3.  3.]\n",
      "--------------------------------\n",
      "[1 1 1]\n"
     ]
    }
   ],
   "source": [
    "print(np.zeros(2)) # Filled with 0.0\n",
    "print('--------------------------------')\n",
    "print(np.zeros((2,3))) # a 2D array, also filled with 0.0\n",
    "print('--------------------------------')\n",
    "print(np.ones_like(a)) # This is very usefull: using an already created array (or list or tuple) as example for the shape of the new one.\n",
    "print('--------------------------------')\n",
    "print(np.zeros_like(a, dtype=float)+3) # Can define a value to fille the array when creating it. Or latter...\n",
    "print('--------------------------------')\n",
    "print(np.ones_like([1,2,3]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5 6]\n",
      "-------------\n",
      "[[1 2]\n",
      " [3 4]\n",
      " [5 6]]\n"
     ]
    }
   ],
   "source": [
    "b = a.reshape((3,2)) # This does NOT change the shape of a\n",
    "print(a)\n",
    "print('-------------')\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5 6]\n",
      "[1 2 3 4 5 6]\n"
     ]
    }
   ],
   "source": [
    "print(b.ravel())\n",
    "print(b.reshape(b.size))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[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",
      "------------------------------------\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": [
    "# create 2 2D arrays (coordinates matrices), one describing how x varies, the other for y.\n",
    "x, y = np.mgrid[0:5, 0:10] # This is not a function!!! notice the []\n",
    "print(x)\n",
    "print('------------------------------------')\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 4 7]\n",
      " [1 2 4 7]\n",
      " [1 2 4 7]]\n",
      "--------------------------------\n",
      "[[ 0.1  0.1  0.1  0.1]\n",
      " [ 0.2  0.2  0.2  0.2]\n",
      " [ 0.3  0.3  0.3  0.3]]\n"
     ]
    }
   ],
   "source": [
    "# coordinates matrices using user-defined x- and y-vectors\n",
    "x, y = np.meshgrid([1,2,4,7], [0.1, 0.2, 0.3])\n",
    "print(x)\n",
    "print('--------------------------------')\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 1 1]\n",
      " [2 2 2]\n",
      " [4 4 4]\n",
      " [7 7 7]]\n",
      "-----------------------------------------\n",
      "[[ 0.1  0.2  0.3]\n",
      " [ 0.1  0.2  0.3]\n",
      " [ 0.1  0.2  0.3]\n",
      " [ 0.1  0.2  0.3]]\n"
     ]
    }
   ],
   "source": [
    "x, y = np.meshgrid([1,2,4,7], [0.1, 0.2, 0.3], indexing='ij') # the other order...\n",
    "print(x)\n",
    "print('-----------------------------------------')\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### WARNING arrays share memory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(6,) (3, 2)\n"
     ]
    }
   ],
   "source": [
    "b = a.reshape((3,2))\n",
    "print(a.shape, b.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  1   2]\n",
      " [  3 100]\n",
      " [  5   6]]\n"
     ]
    }
   ],
   "source": [
    "b[1,1] = 100 # modify a value in the array\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[  1   2   3 100   5   6]\n"
     ]
    }
   ],
   "source": [
    "print(a) # !!! a and b are sharing the same place in the memory, they are pointing to the same values. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(100, 100)"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b[1,1], a[3] # same value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a is b # a and b are different"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(b[1,1] == a[3])\n",
    "print(b[1,1] is a[3]) # Even if the values are the same, the \"is\" does not tell it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "c = a.reshape((2,3)).copy() # This is the solution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[  1   2   3 100   5   6]\n",
      "---------------\n",
      "[[  1   2   3]\n",
      " [100   5   6]]\n"
     ]
    }
   ],
   "source": [
    "print(a)\n",
    "print('---------------')\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[  1   2   3 100   5   6]\n",
      "---------------\n",
      "[[8888    2    3]\n",
      " [ 100    5    6]]\n"
     ]
    }
   ],
   "source": [
    "c[0,0] = 8888\n",
    "print(a)\n",
    "print('---------------')\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0.7882152   0.99241912  0.79943269  0.78337017  0.59978395]\n",
      "-----------------------------\n",
      "[-0.63970449 -0.57141457 -1.23728057  0.4390936   2.09181458]\n",
      "-----------------------------\n",
      "[[ 1.32569953 -0.21616863  0.87488409 -0.3893075  -0.38488923]\n",
      " [-1.10055984  1.15529923 -0.0193641   1.96576883 -0.63892173]\n",
      " [-1.58490005  0.43689955  0.66755566  0.50236483 -1.03943212]\n",
      " [-1.33942681 -0.35644385 -1.78784832  0.29479541  0.63027842]\n",
      " [ 0.89684588  0.63669925 -0.12266564 -2.58324896 -0.72706483]]\n"
     ]
    }
   ],
   "source": [
    "ran_uniform = np.random.rand(5) # between 0 and 1\n",
    "ran_normal = np.random.randn(5) # Gaussian mean 0 variance 1\n",
    "print(ran_uniform)\n",
    "print('-----------------------------')\n",
    "print(ran_normal)\n",
    "print('-----------------------------')\n",
    "ran_normal_2D = np.random.randn(5,5) # Gaussian mean 0 variance 1\n",
    "print(ran_normal_2D)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[  4.17022005e-01   7.20324493e-01   1.14374817e-04   3.02332573e-01\n",
      "   1.46755891e-01]\n",
      "[  4.17022005e-01   7.20324493e-01   1.14374817e-04   3.02332573e-01\n",
      "   1.46755891e-01]\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(1)\n",
    "print(np.random.rand(5))\n",
    "np.random.seed(1)\n",
    "print(np.random.rand(5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Timing on 2D array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "N = 100\n",
    "A = np.random.rand(N, N)\n",
    "B = np.zeros_like(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.19 ms ± 78.1 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "for i in range(N):\n",
    "    for j in range(N):\n",
    "        B[i,j] = A[i,j]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30.3 ns ± 0.244 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "B = A # very faster ! It does NOT copy..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.02 µs ± 21 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit \n",
    "B = (A.copy()) # Takes more time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7.2 ms ± 38.1 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "for i in range(N):\n",
    "    for j in range(N):\n",
    "        B[i,j] = A[i,j]**2 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7.94 µs ± 48.9 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "B = A**2 # very faster ! Does a copy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15.2 µs ± 203 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit  B = (A.copy())**2 # Takes a little bit more time"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Slicing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4 5 6 7 8 9]\n",
      "[1 4 7]\n"
     ]
    }
   ],
   "source": [
    "a = np.arange(10)\n",
    "print(a)\n",
    "print(a[1:8:3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4 5 6]\n"
     ]
    }
   ],
   "source": [
    "print(a[:7])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4 5 6 7 8 9]\n"
     ]
    }
   ],
   "source": [
    "print(a[4:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 2 4 6 8]\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "print(a[::2])\n",
    "print(a[::2][2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[9 8 7 6 5 4 3 2 1 0]\n"
     ]
    }
   ],
   "source": [
    "# Revert the array:\n",
    "print(a[::-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Assignment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[  0   1   2   3   4 999 999 999 999 999]\n"
     ]
    }
   ],
   "source": [
    "a[5:] = 999\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4 4 3 2 1 0]\n"
     ]
    }
   ],
   "source": [
    "a[5:] = a[4::-1]\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4 4 3 2 1 0]\n",
      "[[0]\n",
      " [1]\n",
      " [2]\n",
      " [3]\n",
      " [4]\n",
      " [4]\n",
      " [3]\n",
      " [2]\n",
      " [1]\n",
      " [0]]\n",
      "(10,) (10, 1)\n",
      "[[0 1 2 3 4 4 3 2 1 0]] (1, 10)\n"
     ]
    }
   ],
   "source": [
    "print(a)\n",
    "b = a[:, np.newaxis] # create a new empty dimension\n",
    "print(b)\n",
    "print(a.shape, b.shape)\n",
    "c = a[np.newaxis, :]\n",
    "print(c, c.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  0,  0,  0,  0,  0,  0,  0,  0,  0],\n",
       "       [ 0,  1,  2,  3,  4,  4,  3,  2,  1,  0],\n",
       "       [ 0,  2,  4,  6,  8,  8,  6,  4,  2,  0],\n",
       "       [ 0,  3,  6,  9, 12, 12,  9,  6,  3,  0],\n",
       "       [ 0,  4,  8, 12, 16, 16, 12,  8,  4,  0],\n",
       "       [ 0,  4,  8, 12, 16, 16, 12,  8,  4,  0],\n",
       "       [ 0,  3,  6,  9, 12, 12,  9,  6,  3,  0],\n",
       "       [ 0,  2,  4,  6,  8,  8,  6,  4,  2,  0],\n",
       "       [ 0,  1,  2,  3,  4,  4,  3,  2,  1,  0],\n",
       "       [ 0,  0,  0,  0,  0,  0,  0,  0,  0,  0]])"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b*c # Cross product, see below (broadcasting)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Using an array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4 4 3 2 1 0]\n",
      "[   0    1 -999    3 -999    4 -999    2    1    0]\n"
     ]
    }
   ],
   "source": [
    "print(a)\n",
    "a[[2,4,6]] = -999\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 1 1 1 1 1 1 1 1 1]\n"
     ]
    }
   ],
   "source": [
    "# a = 1 would turn a to be 1, but if we want to assign 1 to every value in a one must do:\n",
    "a[:] = 1\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using masks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[81 86 52 39 52 13  9 98 78 46 26 63 86  2 96 45 13 67 37 36]\n"
     ]
    }
   ],
   "source": [
    "a = np.random.randint(0, 100, 20) # min, max, N\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False, False, False,  True, False,  True,  True, False, False,\n",
       "        True,  True, False, False,  True, False,  True,  True, False,\n",
       "        True,  True], dtype=bool)"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a < 50"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "mask = (a < 50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mask.sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([39, 13,  9, 46, 26,  2, 45, 13, 37, 36])"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[mask]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[81 86 52 39 52 13  9 98 78 46 26 63 86  2 96 45 13 67 37 36]\n",
      "[81 86 52 50 52 50 50 98 78 50 50 63 86 50 96 50 50 67 50 50]\n"
     ]
    }
   ],
   "source": [
    "b = a.copy() # do NOT use b = a\n",
    "b[mask] = 50 # \n",
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[81 86 52  0 52  0  0 98 78  0  0 63 86  0 96  0  0 67  0  0]\n"
     ]
    }
   ],
   "source": [
    "b = a.copy()\n",
    "b[b <= 50] = 0 # shortest way. Not matter if not even one element fit the test\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[39 13  9 46 26  2 45 13 37 36]\n",
      "[81 86 52 52 98 78 63 86 96 67]\n"
     ]
    }
   ],
   "source": [
    "print(a[mask])\n",
    "print(a[~mask]) # complementary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False, False, False,  True, False,  True,  True, False, False,\n",
       "        True,  True, False, False,  True, False,  True,  True, False,\n",
       "        True,  True], dtype=bool)"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mask"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[False False False False False False False False False False False False\n",
      " False False False False False False False False]\n"
     ]
    }
   ],
   "source": [
    "mask = np.zeros_like(a, dtype=bool)\n",
    "print(mask)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "mask[[2,3,4]] = True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False, False,  True,  True,  True, False, False, False, False,\n",
       "       False, False, False, False, False, False, False, False, False,\n",
       "       False, False], dtype=bool)"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mask"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([52, 39, 52])"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[mask]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "143"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[mask].sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### combining masks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[81 86 52 39 52 13  9 98 78 46 26 63 86  2 96 45 13 67 37 36]\n",
      "-------------------------------------\n",
      "[52 39 52 46 63 45 67 37 36]\n",
      "-------------------------------------\n",
      "[81 86 13  9 98 78 26 86  2 96 13]\n"
     ]
    }
   ],
   "source": [
    "print(a)\n",
    "mask_low = a > 30\n",
    "mask_high = a < 70\n",
    "print('-------------------------------------')\n",
    "print(a[mask_low & mask_high]) # both conditions are filled\n",
    "print('-------------------------------------')\n",
    "print(a[~mask_low | ~mask_high]) # complementary, using the | for OR"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### the where function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[81 86 52 39 52 13  9 98 78 46 26 63 86  2 96 45 13 67 37 36]\n",
      "(array([ 0,  1,  2,  3,  4,  7,  8,  9, 11, 12, 14, 15, 17, 18, 19]),)\n"
     ]
    }
   ],
   "source": [
    "tt = np.where(a > 30)\n",
    "print(a)\n",
    "print(tt) # tt is a tuple of arrays, one for each dimension of the condition, \n",
    "# containing the indices where the condition is filled in that dimension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([ 0,  1,  2,  3,  4,  7,  8,  9, 11, 12, 14, 15, 17, 18, 19]),)"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(a > 30).nonzero() # \"where\" is the same than condition.nonzero(). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# the indices where the condition is filled are in the first element of the tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2,  3,  4,  7,  8,  9, 11, 12, 14, 15, 17, 18, 19])"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tt[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# faster once you know that the condition is 1D\n",
    "tt = np.where(a > 30)[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2,  3,  4,  7,  8,  9, 11, 12, 14, 15, 17, 18, 19])"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tt # the array containing the indices where the condition is filled"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([81, 86, 52, 39, 52, 98, 78, 46, 63, 86, 96, 45, 67, 37, 36])"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[tt] # the values where the condition is filled"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[81 86 52 39 52 13  9 98 78 46 26 63 86  2 96 45 13 67 37 36]\n",
      "[ 81.  86.  52.  nan  52.  nan  nan  98.  78.  nan  nan  63.  86.  nan  96.\n",
      "  nan  nan  67.  nan  nan]\n",
      "[ True  True  True False  True False False  True  True False False  True\n",
      "  True False  True False False  True False False]\n"
     ]
    }
   ],
   "source": [
    "# The where function can take 3 arguments. \n",
    "b = np.where(a < 50, np.nan, a)\n",
    "print(a)\n",
    "print(b)\n",
    "print(np.isfinite(b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[81 86 52 39 52 13  9 98 78 46 26 63 86  2 96 45 13 67 37 36]\n",
      "[False False False  True False  True  True False False  True  True False\n",
      " False  True False  True  True False  True  True]\n"
     ]
    }
   ],
   "source": [
    "b = np.where(a < 50, True, False)\n",
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[81 86 52 39 52 13  9 98 78 46 26 63 86  2 96 45 13 67 37 36]\n",
      "[100 100 100   0 100   0   0 100 100   0   0 100 100   0 100   0   0 100\n",
      "   0   0]\n"
     ]
    }
   ],
   "source": [
    "b = np.where(a < 50, 0, 100)\n",
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Some operations with arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([81, 86, 52, 39, 52, 13,  9, 98, 78, 46, 26, 63, 86,  2, 96, 45, 13,\n",
       "       67, 37, 36])"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([82, 87, 53, 40, 53, 14, 10, 99, 79, 47, 27, 64, 87,  3, 97, 46, 14,\n",
       "       68, 38, 37])"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1600884, 1915564,  424528,  179478,  424528,    6760,    2268,\n",
       "       2833180, 1429740,  294124,   53404,  754110, 1915564,      28,\n",
       "       2663424,  275400,    6760,  906778,  153328,  141264])"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a**2 + 3*a**3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# look for the integers I so that i**2 + (i+1)**2 = (i+2)**2\n",
    "i = np.arange(30)\n",
    "b = i**2 + (i+1)**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "c = (i+2)**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[   1    5   13   25   41   61   85  113  145  181  221  265  313  365  421\n",
      "  481  545  613  685  761  841  925 1013 1105 1201 1301 1405 1513 1625 1741]\n",
      "[  4   9  16  25  36  49  64  81 100 121 144 169 196 225 256 289 324 361\n",
      " 400 441 484 529 576 625 676 729 784 841 900 961]\n"
     ]
    }
   ],
   "source": [
    "print(b)\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False, False, False,  True, False, False, False, False, False,\n",
       "       False, False, False, False, False, False, False, False, False,\n",
       "       False, False, False, False, False, False, False, False, False,\n",
       "       False, False, False], dtype=bool)"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b == c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3])"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "i[b==c]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "i[b==c][0] # the result is an array. To obtain the first value (here the only one), use [0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numpy manages almost any mathematical operation. log, trigo, etc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17]\n",
      "[       -inf  0.          0.30103     0.47712125  0.60205999  0.69897\n",
      "  0.77815125  0.84509804  0.90308999  0.95424251  1.          1.04139269\n",
      "  1.07918125  1.11394335  1.14612804  1.17609126  1.20411998  1.23044892]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/morisset/anaconda2/envs/py3k6/lib/python3.6/site-packages/ipykernel_launcher.py:3: RuntimeWarning: divide by zero encountered in log10\n",
      "  This is separate from the ipykernel package so we can avoid doing imports until\n"
     ]
    }
   ],
   "source": [
    "a = np.arange(18)\n",
    "print(a)\n",
    "print(np.log10(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " 0 -inf  0.00 1.00e+00\n",
      " 1 0.00  0.84 2.72e+00\n",
      " 2 0.30  0.91 7.39e+00\n",
      " 3 0.48  0.14 2.01e+01\n",
      " 4 0.60 -0.76 5.46e+01\n",
      " 5 0.70 -0.96 1.48e+02\n",
      " 6 0.78 -0.28 4.03e+02\n",
      " 7 0.85  0.66 1.10e+03\n",
      " 8 0.90  0.99 2.98e+03\n",
      " 9 0.95  0.41 8.10e+03\n",
      "10 1.00 -0.54 2.20e+04\n",
      "11 1.04 -1.00 5.99e+04\n",
      "12 1.08 -0.54 1.63e+05\n",
      "13 1.11  0.42 4.42e+05\n",
      "14 1.15  0.99 1.20e+06\n",
      "15 1.18  0.65 3.27e+06\n",
      "16 1.20 -0.29 8.89e+06\n",
      "17 1.23 -0.96 2.42e+07\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/morisset/anaconda2/envs/py3k6/lib/python3.6/site-packages/ipykernel_launcher.py:2: RuntimeWarning: divide by zero encountered in log10\n",
      "  \n"
     ]
    }
   ],
   "source": [
    "for aa in a:\n",
    "    print('{0:2} {1:4.2f} {2:5.2f} {3:8.2e}'.format(aa, np.log10(aa), np.sin(aa), np.exp(aa)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "sum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "153\n",
      "153.0\n"
     ]
    }
   ],
   "source": [
    "print(a.sum())\n",
    "print(17*18/2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 4, 3)\n",
      "24\n"
     ]
    }
   ],
   "source": [
    "a = np.random.rand(2, 4, 3)\n",
    "print(a.shape)\n",
    "print(a.size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2 planes, 4 rows, 3 columns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A small comment on the order of the elements in arrays in Python: There is two ways arrays can be stored: row- or column major. It has a direct impact on the way one has to loop on the arrays. IDL is like Fortran (column major) and Python is like C (row major). It means that in Python, as you move linearly through the memory of an array, the second dimension (rightmost) changes the fastest, while in IDL the first (leftmost) dimension changes the fastest. Consequence on the loop order in Python:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.660518893775\n",
      "-----\n",
      "0.293911298631\n",
      "-----\n",
      "0.444763908363\n",
      "-----\n",
      "0.831897448682\n",
      "-----\n",
      "0.900511773191\n",
      "-----\n",
      "0.318277757182\n",
      "-----\n",
      "0.17908201684\n",
      "-----\n",
      "0.458741347231\n",
      "-----\n",
      "0.678980933538\n",
      "-----\n",
      "0.414421162986\n",
      "-----\n",
      "0.0565193550914\n",
      "-----\n",
      "0.854027011068\n",
      "-----\n",
      "0.885621908519\n",
      "-----\n",
      "0.88823776014\n",
      "-----\n",
      "0.477196646584\n",
      "-----\n",
      "0.779967013628\n",
      "-----\n",
      "0.399219321332\n",
      "-----\n",
      "0.266255324504\n",
      "-----\n",
      "0.271085651875\n",
      "-----\n",
      "0.647189178778\n",
      "-----\n",
      "0.0402554039138\n",
      "-----\n",
      "0.384413914535\n",
      "-----\n",
      "0.682927667015\n",
      "-----\n",
      "0.693636309673\n",
      "-----\n"
     ]
    }
   ],
   "source": [
    "for plane in a:\n",
    "    for row in plane:\n",
    "        for col in row:\n",
    "            print(col)\n",
    "            print('-----')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.318277757182\n"
     ]
    }
   ],
   "source": [
    "print(a[0,1,2]) # a[p, r, c]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12.507659007074615"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.5461408 ,  1.18214906,  0.92196055],\n",
       "       [ 1.61186446,  1.29973109,  0.58453308],\n",
       "       [ 0.45016767,  1.10593053,  0.71923634],\n",
       "       [ 0.79883508,  0.73944702,  1.54766332]])"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.sum(0) # from 3D to 2D. Generate an \"image\" of the sum, i.e. the \"projection\" on the x-axis of the 3D array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4, 3)"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.sum(0).shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 4.40700801,  4.3272577 ,  3.77339329])"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.sum(0).sum(0) # from 3D to 1D. From the image, make the sum in each row."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.66051889,  0.2939113 ,  0.44476391],\n",
       "       [ 0.77996701,  0.39921932,  0.26625532],\n",
       "       [ 0.17908202,  0.45874135,  0.0402554 ],\n",
       "       [ 0.38441391,  0.05651936,  0.69363631]])"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.min(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.66051889,  0.2939113 ,  0.44476391,  0.83189745,  0.90051177,\n",
       "        0.31827776,  0.17908202,  0.45874135,  0.67898093,  0.41442116,\n",
       "        0.05651936,  0.85402701,  0.88562191,  0.88823776,  0.47719665,\n",
       "        0.77996701,  0.39921932,  0.26625532,  0.27108565,  0.64718918,\n",
       "        0.0402554 ,  0.38441391,  0.68292767,  0.69363631])"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.ravel()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "i_min = a.argmin() # return the index of where the minimum is. It uses the 1D index.\n",
    "print(i_min)\n",
    "b = np.array([10,2,3,4,5,2])\n",
    "b.argmin() # only the first occurence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(24,)"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.ravel().shape # 1D "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.040255403913796117"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.ravel()[i_min] # Check where the minimum is."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 2\n",
      "0.0402554039138\n"
     ]
    }
   ],
   "source": [
    "z = i_min // 12\n",
    "y = (i_min - 12*z) // 3\n",
    "x = i_min - 12*z - 3*y\n",
    "print(z, y, x)\n",
    "print(a[z, y, x])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def decompose_ravel(arr, i):\n",
    "    shapes = arr.shape\n",
    "    idx = i\n",
    "    res = []\n",
    "    for i in np.arange(arr.ndim):\n",
    "        subdims = np.prod(shapes[i+1:])\n",
    "        n = int(idx // subdims)\n",
    "        #print n, subdims, idx\n",
    "        idx = idx - subdims*n\n",
    "        res.append(n)\n",
    "    return tuple(res)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0402554039138\n",
      "(1, 2, 2)\n",
      "0.0402554039138\n"
     ]
    }
   ],
   "source": [
    "res = decompose_ravel(a, i_min)\n",
    "print(a.min())\n",
    "print(res)\n",
    "print(a[res])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.17908202,  0.05651936,  0.0402554 ])"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.min(0).min(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0.66051889  0.88562191]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.66051889377460848"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(a[:,0,0])\n",
    "a[:,0,0].min()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.7730704 ,  0.59107453,  0.46098028],\n",
       "       [ 0.80593223,  0.64986555,  0.29226654],\n",
       "       [ 0.22508383,  0.55296526,  0.35961817],\n",
       "       [ 0.39941754,  0.36972351,  0.77383166]])"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.mean(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.53747003,  0.37632632,  0.56187242],\n",
       "       [ 0.58219046,  0.66505842,  0.37172599]])"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.median(a, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.26165147397684535"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.std()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.3121861425445312"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.percentile(a, 25)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0.66051889  0.2939113   0.44476391]\n",
      " [ 0.88562191  0.88823776  0.47719665]]\n",
      "[ 0.66051889  0.95443019  1.3991941   2.28481601  3.17305377  3.65025042]\n"
     ]
    }
   ],
   "source": [
    "print(a[0:4,0])\n",
    "print(np.cumsum(a[0:100,0])) # axis is a keyword. If absent, applied on the ravel(), e.g. 1D array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "b = np.arange(1000).reshape(10,10,10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(10, 10, 10)"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[400, 401, 402, 403, 404, 405, 406, 407, 408, 409],\n",
       "       [410, 411, 412, 413, 414, 415, 416, 417, 418, 419],\n",
       "       [420, 421, 422, 423, 424, 425, 426, 427, 428, 429],\n",
       "       [430, 431, 432, 433, 434, 435, 436, 437, 438, 439],\n",
       "       [440, 441, 442, 443, 444, 445, 446, 447, 448, 449],\n",
       "       [450, 451, 452, 453, 454, 455, 456, 457, 458, 459],\n",
       "       [460, 461, 462, 463, 464, 465, 466, 467, 468, 469],\n",
       "       [470, 471, 472, 473, 474, 475, 476, 477, 478, 479],\n",
       "       [480, 481, 482, 483, 484, 485, 486, 487, 488, 489],\n",
       "       [490, 491, 492, 493, 494, 495, 496, 497, 498, 499]])"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b[4,:,:] # hundreds digits = 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 20,  21,  22,  23,  24,  25,  26,  27,  28,  29],\n",
       "       [120, 121, 122, 123, 124, 125, 126, 127, 128, 129],\n",
       "       [220, 221, 222, 223, 224, 225, 226, 227, 228, 229],\n",
       "       [320, 321, 322, 323, 324, 325, 326, 327, 328, 329],\n",
       "       [420, 421, 422, 423, 424, 425, 426, 427, 428, 429],\n",
       "       [520, 521, 522, 523, 524, 525, 526, 527, 528, 529],\n",
       "       [620, 621, 622, 623, 624, 625, 626, 627, 628, 629],\n",
       "       [720, 721, 722, 723, 724, 725, 726, 727, 728, 729],\n",
       "       [820, 821, 822, 823, 824, 825, 826, 827, 828, 829],\n",
       "       [920, 921, 922, 923, 924, 925, 926, 927, 928, 929]])"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b[:,2,:] # tens digit = 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  7,  17,  27,  37,  47,  57,  67,  77,  87,  97],\n",
       "       [107, 117, 127, 137, 147, 157, 167, 177, 187, 197],\n",
       "       [207, 217, 227, 237, 247, 257, 267, 277, 287, 297],\n",
       "       [307, 317, 327, 337, 347, 357, 367, 377, 387, 397],\n",
       "       [407, 417, 427, 437, 447, 457, 467, 477, 487, 497],\n",
       "       [507, 517, 527, 537, 547, 557, 567, 577, 587, 597],\n",
       "       [607, 617, 627, 637, 647, 657, 667, 677, 687, 697],\n",
       "       [707, 717, 727, 737, 747, 757, 767, 777, 787, 797],\n",
       "       [807, 817, 827, 837, 847, 857, 867, 877, 887, 897],\n",
       "       [907, 917, 927, 937, 947, 957, 967, 977, 987, 997]])"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b[:,:,7] # unity digit = 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9],\n",
       "       [10, 11, 12, 13, 14, 15, 16, 17, 18, 19],\n",
       "       [20, 21, 22, 23, 24, 25, 26, 27, 28, 29],\n",
       "       [30, 31, 32, 33, 34, 35, 36, 37, 38, 39],\n",
       "       [40, 41, 42, 43, 44, 45, 46, 47, 48, 49],\n",
       "       [50, 51, 52, 53, 54, 55, 56, 57, 58, 59],\n",
       "       [60, 61, 62, 63, 64, 65, 66, 67, 68, 69],\n",
       "       [70, 71, 72, 73, 74, 75, 76, 77, 78, 79],\n",
       "       [80, 81, 82, 83, 84, 85, 86, 87, 88, 89],\n",
       "       [90, 91, 92, 93, 94, 95, 96, 97, 98, 99]])"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.min(0) # elements with the smallest value for the hundreds digit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  0,  10,  20,  30,  40,  50,  60,  70,  80,  90],\n",
       "       [100, 110, 120, 130, 140, 150, 160, 170, 180, 190],\n",
       "       [200, 210, 220, 230, 240, 250, 260, 270, 280, 290],\n",
       "       [300, 310, 320, 330, 340, 350, 360, 370, 380, 390],\n",
       "       [400, 410, 420, 430, 440, 450, 460, 470, 480, 490],\n",
       "       [500, 510, 520, 530, 540, 550, 560, 570, 580, 590],\n",
       "       [600, 610, 620, 630, 640, 650, 660, 670, 680, 690],\n",
       "       [700, 710, 720, 730, 740, 750, 760, 770, 780, 790],\n",
       "       [800, 810, 820, 830, 840, 850, 860, 870, 880, 890],\n",
       "       [900, 910, 920, 930, 940, 950, 960, 970, 980, 990]])"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.min(2) # smallest value for the unity digit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(10, 10)"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.min(2).shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "499.5"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.median(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 450.,  451.,  452.,  453.,  454.,  455.,  456.,  457.,  458.,\n",
       "         459.],\n",
       "       [ 460.,  461.,  462.,  463.,  464.,  465.,  466.,  467.,  468.,\n",
       "         469.],\n",
       "       [ 470.,  471.,  472.,  473.,  474.,  475.,  476.,  477.,  478.,\n",
       "         479.],\n",
       "       [ 480.,  481.,  482.,  483.,  484.,  485.,  486.,  487.,  488.,\n",
       "         489.],\n",
       "       [ 490.,  491.,  492.,  493.,  494.,  495.,  496.,  497.,  498.,\n",
       "         499.],\n",
       "       [ 500.,  501.,  502.,  503.,  504.,  505.,  506.,  507.,  508.,\n",
       "         509.],\n",
       "       [ 510.,  511.,  512.,  513.,  514.,  515.,  516.,  517.,  518.,\n",
       "         519.],\n",
       "       [ 520.,  521.,  522.,  523.,  524.,  525.,  526.,  527.,  528.,\n",
       "         529.],\n",
       "       [ 530.,  531.,  532.,  533.,  534.,  535.,  536.,  537.,  538.,\n",
       "         539.],\n",
       "       [ 540.,  541.,  542.,  543.,  544.,  545.,  546.,  547.,  548.,\n",
       "         549.]])"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.median(b, axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-0.999999398446 0.99999911124\n"
     ]
    }
   ],
   "source": [
    "x = 2 * np.random.rand(100,100,100) - 1.\n",
    "print(np.min(x), np.max(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "y = 2 * np.random.rand(100,100,100) - 1.\n",
    "z = 2 * np.random.rand(100,100,100) - 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0126214002214 1.71795924809\n",
      "1.73205080757\n"
     ]
    }
   ],
   "source": [
    "r = np.sqrt(x**2 + y**2 + z**2)\n",
    "print(np.min(r), np.max(r))\n",
    "print(np.sqrt(3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.960795050103\n",
      "0.960795050103\n"
     ]
    }
   ],
   "source": [
    "print(np.mean(r))\n",
    "print(r.mean())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.98489862714318832"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.median(r)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Broadcasting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "http://arxiv.org/pdf/1102.1523.pdf"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    If the two arrays differ in their number of dimensions, the shape of the array with fewer dimensions is padded with ones on its leading (left) side.\n",
    "    If the shape of the two arrays does not match in any dimension, the array with shape equal to 1 in that dimension is stretched to match the other shape.\n",
    "    If in any dimension the sizes disagree and neither is equal to 1, an error is raised."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(5,)\n"
     ]
    }
   ],
   "source": [
    "x1 = np.array((1,2,3,4,5))\n",
    "y1 = np.array((1,2,3,4,5))\n",
    "z1 = np.array((1,2,3,4,5))\n",
    "r1 = x1 * y1 * z1\n",
    "print(r1.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x = np.array((1,2,3,4,5)).reshape(5,1,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[1]],\n",
       "\n",
       "       [[2]],\n",
       "\n",
       "       [[3]],\n",
       "\n",
       "       [[4]],\n",
       "\n",
       "       [[5]]])"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5, 1, 1)"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.ndim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[1]\n",
      "  [2]\n",
      "  [3]\n",
      "  [4]\n",
      "  [5]]]\n",
      "[[[1 2 3 4 5]]]\n"
     ]
    }
   ],
   "source": [
    "y = np.array((1,2,3,4,5)).reshape(1,5,1)\n",
    "z = np.array((1,2,3,4,5)).reshape(1,1,5)\n",
    "print(y)\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "r = x * y * z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(5, 5, 5)\n"
     ]
    }
   ],
   "source": [
    "print(r.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[  1,   2,   3,   4,   5],\n",
       "        [  2,   4,   6,   8,  10],\n",
       "        [  3,   6,   9,  12,  15],\n",
       "        [  4,   8,  12,  16,  20],\n",
       "        [  5,  10,  15,  20,  25]],\n",
       "\n",
       "       [[  2,   4,   6,   8,  10],\n",
       "        [  4,   8,  12,  16,  20],\n",
       "        [  6,  12,  18,  24,  30],\n",
       "        [  8,  16,  24,  32,  40],\n",
       "        [ 10,  20,  30,  40,  50]],\n",
       "\n",
       "       [[  3,   6,   9,  12,  15],\n",
       "        [  6,  12,  18,  24,  30],\n",
       "        [  9,  18,  27,  36,  45],\n",
       "        [ 12,  24,  36,  48,  60],\n",
       "        [ 15,  30,  45,  60,  75]],\n",
       "\n",
       "       [[  4,   8,  12,  16,  20],\n",
       "        [  8,  16,  24,  32,  40],\n",
       "        [ 12,  24,  36,  48,  60],\n",
       "        [ 16,  32,  48,  64,  80],\n",
       "        [ 20,  40,  60,  80, 100]],\n",
       "\n",
       "       [[  5,  10,  15,  20,  25],\n",
       "        [ 10,  20,  30,  40,  50],\n",
       "        [ 15,  30,  45,  60,  75],\n",
       "        [ 20,  40,  60,  80, 100],\n",
       "        [ 25,  50,  75, 100, 125]]])"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1.  1.  1.  1.  1.  1.  1.  1.  1.  1.]\n",
      " [ 1.  1.  1.  1.  1.  1.  1.  1.  1.  1.]\n",
      " [ 1.  1.  1.  1.  1.  1.  1.  1.  1.  1.]\n",
      " [ 1.  1.  1.  1.  1.  1.  1.  1.  1.  1.]\n",
      " [ 1.  1.  1.  1.  1.  1.  1.  1.  1.  1.]\n",
      " [ 1.  1.  1.  1.  1.  1.  1.  1.  1.  1.]\n",
      " [ 1.  1.  1.  1.  1.  1.  1.  1.  1.  1.]\n",
      " [ 1.  1.  1.  1.  1.  1.  1.  1.  1.  1.]\n",
      " [ 1.  1.  1.  1.  1.  1.  1.  1.  1.  1.]\n",
      " [ 1.  1.  1.  1.  1.  1.  1.  1.  1.  1.]]\n",
      "[[0]\n",
      " [1]\n",
      " [2]\n",
      " [3]\n",
      " [4]\n",
      " [5]\n",
      " [6]\n",
      " [7]\n",
      " [8]\n",
      " [9]]\n",
      "(10, 1)\n"
     ]
    }
   ],
   "source": [
    "a = np.ones((10,10))\n",
    "b = np.arange(10).reshape(10,1)\n",
    "print(a)\n",
    "print(b)\n",
    "print(b.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 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",
       "       [ 5.,  5.,  5.,  5.,  5.,  5.,  5.,  5.,  5.,  5.],\n",
       "       [ 6.,  6.,  6.,  6.,  6.,  6.,  6.,  6.,  6.,  6.],\n",
       "       [ 7.,  7.,  7.,  7.,  7.,  7.,  7.,  7.,  7.,  7.],\n",
       "       [ 8.,  8.,  8.,  8.,  8.,  8.,  8.,  8.,  8.,  8.],\n",
       "       [ 9.,  9.,  9.,  9.,  9.,  9.,  9.,  9.,  9.,  9.]])"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a * b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 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",
       "       [ 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.]])"
      ]
     },
     "execution_count": 143,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a * b.reshape(1,10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Structured arrays and RecArrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "See here: http://docs.scipy.org/doc/numpy/user/basics.rec.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A structured array in numpy is an array of records. Each record can contain one or more items which can be of different types."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1.5  2. ]\n",
      " [ 3.   4. ]]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([(1.5, 2), (3.0, 4)]) # Classical numpy array\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([( 1.5, 2), ( 3. , 4)], \n",
       "      dtype=[('x', '<f8'), ('y', '<i8')])"
      ]
     },
     "execution_count": 145,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "astru = np.array([(1.5, 2), (3.0, 4)], dtype=[('x', float), ('y', int)]) # array with named and typed columns\n",
    "astru"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1.5  3. ]\n",
      "[2 4]\n"
     ]
    }
   ],
   "source": [
    "print(astru['x'])\n",
    "print(astru['y'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'> <class 'numpy.ndarray'> <class 'numpy.recarray'>\n",
      "----------------------------------\n",
      "[[ 1.5  2. ]\n",
      " [ 3.   4. ]]\n",
      "[( 1.5, 2) ( 3. , 4)]\n",
      "[( 1.5, 2) ( 3. , 4)]\n",
      "----------------------------------\n",
      "4 2 2\n",
      "----------------------------------\n",
      "float64 [('x', '<f8'), ('y', '<i8')] (numpy.record, [('x', '<f8'), ('y', '<i8')])\n",
      "----------------------------------\n",
      "4.0 4 4\n",
      "----------------------------------\n",
      "[2 4]\n",
      "----------------------------------\n",
      "[ 1.5  3. ]\n"
     ]
    }
   ],
   "source": [
    "arec = astru.view(np.recarray)\n",
    "print(type(a), type(astru), type(arec))\n",
    "print('----------------------------------')\n",
    "print(a)\n",
    "print(astru)\n",
    "print(arec)\n",
    "print('----------------------------------')\n",
    "print(a.size, astru.size, arec.size) # not even the same sixe\n",
    "print('----------------------------------')\n",
    "print(a.dtype, astru.dtype, arec.dtype) # types tell us that ar has column names and types\n",
    "print('----------------------------------')\n",
    "print(a[1,1], astru[1][1], arec[1][1]) # one is 2D, the other is a collection of 1D\n",
    "print('----------------------------------')\n",
    "print(astru['y']) # acces by name (a litle like dictionnaries)\n",
    "print('----------------------------------')\n",
    "print(arec.x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10.6 µs ± 101 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit astru2 = np.append(astru, np.array([(5.0, 6)], dtype=astru.dtype)) # Copied all the data, may be slow"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.08 µs ± 50.9 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit astru3 = np.concatenate((astru, np.array([(5.0, 6)], dtype=astru.dtype))) # A little bit faster"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "43.7 µs ± 740 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit arec2 = np.append(arec, np.array([(5.0, 6)], dtype=astru.dtype).view(np.recarray)) # Copied all the data, may be slow"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "26.2 µs ± 299 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit arec3 = np.concatenate((arec, np.array([(5.0, 6)], dtype=astru.dtype).view(np.recarray))) # A little bit faster"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(456, 'dbe',  1.2) (  2, 'de',  1.3)]\n",
      "<class 'numpy.recarray'>\n",
      "2\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "arec4 = np.rec.fromrecords([(456,'dbe',1.2),(2,'de',1.3)],names='col1,col2,col3') # direct from data.\n",
    "print(arec4)\n",
    "print(type(arec4))\n",
    "print(arec4.col1[1])\n",
    "print(arec4[1].col1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "arec4 = np.rec.fromrecords([('etoile_15', 30.015, -0.752, 10.722), \n",
    "                            ('etoile_11', 31.163, -9.109, 10.761),\n",
    "                            ('etoile_16', 39.789, -7.716, 11.071), \n",
    "                            ('etoile_14', 35.110, 6.785, 11.176), \n",
    "                            ('etoile_31', 33.530, 9.306, 11.823), \n",
    "                            ('etoile_04', 33.480, 5.568, 11.978)\n",
    "                            ],\n",
    "                           names='name,ra,dec, mag')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('etoile_16',  39.789, -7.716,  11.071)\n",
      " ('etoile_14',  35.11 ,  6.785,  11.176)\n",
      " ('etoile_31',  33.53 ,  9.306,  11.823)\n",
      " ('etoile_04',  33.48 ,  5.568,  11.978)]\n",
      "-------------------------\n",
      "name: etoile_16 ra = 39.789 dec = -7.716 magnitude = 11.071\n",
      "name: etoile_14 ra = 35.11 dec = 6.785 magnitude = 11.176\n",
      "name: etoile_31 ra = 33.53 dec = 9.306 magnitude = 11.823\n",
      "name: etoile_04 ra = 33.48 dec = 5.568 magnitude = 11.978\n",
      "-------------------------\n",
      "name: etoile_16 ra = 39.789 dec = -7.716 magnitude = 11.071\n",
      "name: etoile_14 ra = 35.11 dec = 6.785 magnitude = 11.176\n",
      "name: etoile_31 ra = 33.53 dec = 9.306 magnitude = 11.823\n",
      "name: etoile_04 ra = 33.48 dec = 5.568 magnitude = 11.978\n"
     ]
    }
   ],
   "source": [
    "mask = arec4.mag > 11.\n",
    "print(arec4[mask])\n",
    "print('-------------------------')\n",
    "for star in arec4[mask]:\n",
    "    print('name: {0} ra = {1} dec = {2} magnitude = {3}'.format(star.name, star.ra, star.dec, star.mag))\n",
    "print('-------------------------')\n",
    "for star in arec4[mask]:\n",
    "    print('name: {0[name]} ra = {0[ra]} dec = {0[dec]} magnitude = {0[mag]}'.format(star)) # unse only one key in format"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### NaN and other ANSI values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-0.33333333 -0.5        -1.                 inf  1.          0.5       ]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/morisset/anaconda2/envs/py3k6/lib/python3.6/site-packages/ipykernel_launcher.py:2: RuntimeWarning: divide by zero encountered in true_divide\n",
      "  \n"
     ]
    }
   ],
   "source": [
    "a = np.array([-3, -2., -1., 0., 1., 2.])\n",
    "b = 1./a\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-3.0\n",
      "inf\n"
     ]
    }
   ],
   "source": [
    "print(a.sum())\n",
    "print(b.sum()) # NaN and others are absorbant elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ True  True  True False  True  True]\n",
      "-0.333333333333\n"
     ]
    }
   ],
   "source": [
    "mask = np.isfinite(b)\n",
    "print(mask)\n",
    "print(b[mask].sum())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "False\n",
      "False\n",
      "True\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "for elem in b:\n",
    "    print(np.isinf(elem))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-2. -1.  1.  2.  3.]\n",
      "[        nan         nan  0.          0.30103     0.47712125]\n",
      "[False False  True  True  True]\n",
      "0.6\n",
      "nan\n",
      "0.259383750128\n",
      "0.259383750128\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/morisset/anaconda2/envs/py3k6/lib/python3.6/site-packages/ipykernel_launcher.py:2: RuntimeWarning: invalid value encountered in log10\n",
      "  \n"
     ]
    }
   ],
   "source": [
    "a = np.array([-2, -1, 1., 2, 3])\n",
    "b = np.log10(a)\n",
    "mask = np.isfinite(b)\n",
    "print(a)\n",
    "print(b)\n",
    "print(mask)\n",
    "print(a.mean())\n",
    "print(b.mean())\n",
    "print(b[mask].mean())\n",
    "print(np.nanmean(b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Roundish values of floats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.000000000000004, 30.0, 31.000000000000004, 32.0, 33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.00000000000001, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.00000000000001, 48.0, 49.0, 50.0, 51.00000000000001, 52.0, 53.0, 54.0, 55.00000000000001, 56.0, 57.0, 58.00000000000001, 59.00000000000001, 60.0, 61.0, 62.00000000000001, 63.0, 64.0, 65.0, 66.0, 67.0, 68.0, 69.0, 70.0, 71.0, 72.0, 73.0, 74.0, 75.0, 76.0, 77.0, 78.00000000000001, 79.0, 80.0, 81.0, 82.0, 83.0, 84.0, 85.0, 86.0, 87.0, 88.0, 89.0, 90.0, 91.0, 92.0, 93.00000000000001, 94.00000000000001, 95.00000000000001, 96.0, 97.0, 98.0, 99.0]\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "res = []\n",
    "for i in range(100): \n",
    "    res.append(math.log(2 ** i, 2)) # The second argument is the base of the log. The result should be i.\n",
    "print(res)\n",
    "# We can see that sometimes the value of log2(2**i) is NOT i."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, False, True, False, True, True, True, True, True, True, True, False, True, True, True, True, True, True, True, False, True, True, True, False, True, True, True, False, True, True, False, False, True, True, False, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, False, True, True, True, True, True, True, True, True, True, True, True, True, True, True, False, False, False, True, True, True, True]\n"
     ]
    }
   ],
   "source": [
    "res2 = []\n",
    "for i in range(100): \n",
    "    res2.append(float(round(math.log(2**i, 2))) == math.log(2 ** i, 2))\n",
    "print(res2)\n",
    "# An equivalent result is obtained when comparing the round value. This should be always True."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0, 33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0, 49.0, 50.0, 51.0, 52.0, 53.0, 54.0, 55.0, 56.0, 57.0, 58.0, 59.0, 60.0, 61.0, 62.0, 63.0, 64.0, 65.0, 66.0, 67.0, 68.0, 69.0, 70.0, 71.0, 72.0, 73.0, 74.0, 75.0, 76.0, 77.0, 78.0, 79.0, 80.0, 81.0, 82.0, 83.0, 84.0, 85.0, 86.0, 87.0, 88.0, 89.0, 90.0, 91.0, 92.0, 93.0, 94.0, 95.0, 96.0, 97.0, 98.0, 99.0]\n",
      "[True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True]\n"
     ]
    }
   ],
   "source": [
    "res = []\n",
    "for i in range(100): \n",
    "    res.append(np.log2(2.**i)) # The second argument is the base of the log. The result should be i.\n",
    "print(res)\n",
    "\n",
    "res_np = []\n",
    "for i in range(100): \n",
    "    res_np.append(float(round(np.log2(2.**i))) == np.log2(2.**i))\n",
    "print(res_np)\n",
    "# No problemes with the numpy log function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In case of doubdts, one can use the close function from numpy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True]\n"
     ]
    }
   ],
   "source": [
    "res_np2 = []\n",
    "for i in range(100): \n",
    "    res_np2.append(np.isclose(float(round(math.log(2 ** i, 2))), math.log(2 ** i, 2)))\n",
    "print(res_np2)\n",
    "# The isclose "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "np.isclose?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "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.6.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}