Up and Running with Python - NumPy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Up and Running with Python3\n",
    "# NumPy\n",
    "\n",
    "NumPy is a fundamental package for scientific computing with Python. \n",
    "Is a Python library adding support for multi-dimensional arrays and matrices, as well as many useful mathematical functions to operate on these arrays.\n",
    "\n",
    "<img src=\"data/logos/775px-NumPy_logo.svg.png\" style=\"width: 200px;\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.17.2\n"
     ]
    }
   ],
   "source": [
    "print(np.__version__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the previous notebook, we saw how to construct lists. Now, we will start from lists, and see how we can construct numpy arrays from them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5.1100e-01, 1.0566e+02, 1.7800e+03])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "masses_list = [0.511, 105.66, 1.78e3]\n",
    "masses_array = np.array(masses_list)\n",
    "masses_array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Multiply every element by a number:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5.1100e-04, 1.0566e-01, 1.7800e+00])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "masses_array_gev = masses_array * 1e-3\n",
    "masses_array_gev"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To get the size of the array, you can use the `len()` function, or the `.size` attribute.\n",
    "\n",
    "You can get the shape of the object by using the `.shape` attribute"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "len is  3\n",
      "size is  3\n",
      "shape is  (3,)\n"
     ]
    }
   ],
   "source": [
    "# EXCERCISE: Check that len and size give the same result. What does shape return?\n",
    "print('len is ', len(masses_array))\n",
    "print('size is ', masses_array.size)\n",
    "print('shape is ', masses_array.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0.]])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# EXCERCISE: Try np.linspace, np.zeros, np.ones\n",
    "np.linspace(5, 15, 9)\n",
    "np.zeros(9)\n",
    "np.ones(9)\n",
    "np.zeros((5, 4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## NumPy DataTypes\n",
    "\n",
    "Up until this point, we have been using the default datatypes that NumPy selects for arrays. In the cases for arange and linspace, the default types are integers. \n",
    "\n",
    "In the case of zeros and ones, the default type is floating point. Each of these functions has a `dtype` parameter. For example, we can look here and we see linspace has a `dtype` parameter and its default value is set to `None`. You can use this parameter to determine the datatype for each element in an array. Remember that each element must have the same datatype. \n",
    "\n",
    "At this [link](https://docs.scipy.org/doc/numpy/user/basics.types.html) you can find all the NumPy datatypes.\n",
    "\n",
    "In the previous examples, we saw that the `ones` function and the `zeros` function return arrays that contain floating point values. \n",
    "\n",
    "You can change this and select the datatype that you want by setting a value for the `dtype` parameter. \n",
    "For example you can do `np.ones(9, dtype='int64')`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 0 0 0 0 0 0 0 0 0 0] <class 'numpy.ndarray'>\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "dtype('int64')"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# EXCERCISE: Create an array with zeros that has 11 elements, each of which is a 64-bit integer\n",
    "a = np.zeros(11, dtype='int64')\n",
    "print(a, type(a))\n",
    "a.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And...there is also the _complex_ data type!\n",
    "\n",
    "You can specify a complex type in python using `j` as imaginary number, as in `1+2j`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5.1100e-01+0.j, 1.0566e+02+0.j, 1.7800e+03+0.j, 1.0000e+00+2.j])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# EXCERCISE: Try to add an imaginary number to a numpy array and print the array\n",
    "masses_list = [0.511, 105.66, 1.78e3]\n",
    "masses_list.append(1+2j)\n",
    "masses_array = np.array(masses_list)\n",
    "masses_array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Array Indexing and Slicing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "masses_array = np.array([2.2, 4.7, 0.511, 1.28, 96, 105.66, 173e3, 4.18e3, 1.78e3, 0, 0, 91.19e3, 80.39e3, 124.97e3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can use negatixe index to start counting from the end of the array. \n",
    "\n",
    "For example, to select the last element:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "124970.0"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "masses_array[-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or to select the penultimate element:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "80390.0"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "masses_array[-2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And so on..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Slicing\n",
    "\n",
    "A basic slice syntax is `i:j:k` where `i` is the starting index, `j` is the stopping index, and `k` is the step:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 3, 5])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])\n",
    "x[1:7:2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, if `i` is not given, it defaults to 0.\n",
    "\n",
    "If `j` is not given, it defaults to the lenght of the array (call it `n`).\n",
    "\n",
    "If `k` is not given it defaults to 1.\n",
    "\n",
    "\n",
    "**Example** `i = 3`, `j` and `k` defaulted to `n` and 1:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[3:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Example** `i` defaulted to 0, `j = 4` and `k` defaulted and 1:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[:4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Example** `i` defaulted to 0, `j = 4` and `k = 2`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 2])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[:4:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Linear Algebra\n",
    "\n",
    "The `np.matrix` function returned a matrix from an array like object, or from a string of data. \n",
    "\n",
    "A matrix is a specialized 2D array that retains its 2D nature through operations. \n",
    "\n",
    "It has special operators such as asterisk for matrix multiplication, and a double asterisk for matrix power or matrix exponentiation operations.\n",
    "\n",
    "Let's contruct the a CKM matrix:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "ckm_matrix = np.matrix([[0.97427, 0.22534, 0.00351 ],\n",
    "                        [0.22520, 0.97344, 0.0412  ],\n",
    "                        [0.00867, 0.0404,  0.999146]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[0.97427 , 0.22534 , 0.00351 ],\n",
       "        [0.2252  , 0.97344 , 0.0412  ],\n",
       "        [0.00867 , 0.0404  , 0.999146]])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ckm_matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.matrix"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(ckm_matrix)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Again, we can use the `.shape` attribute to see what is the shape of this matrix:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 3)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ckm_matrix.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And also `ndim` to see the number of dimensions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ckm_matrix.ndim"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's use the `help` function to see what opetations are available:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# help(np.matrix)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's the transpose attribute `.T` to calculate the transpose of this matrix. \n",
    "\n",
    "Next we'll use another attribute, `.I`, to calculate the inverse of this matrix. Notice that the inverse is calculated on my first matrix, and not upon the transform of my first matrix. \n",
    "\n",
    "For example, is the transpose of the CKM matrix:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[0.97427 , 0.2252  , 0.00867 ],\n",
       "        [0.22534 , 0.97344 , 0.0404  ],\n",
       "        [0.00351 , 0.0412  , 0.999146]])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ckm_matrix.T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[0.999931  , 0.        , 0.        ],\n",
       "        [0.        , 0.99999997, 0.        ],\n",
       "        [0.        , 0.        , 1.00003722]])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# EXCERCISE: Check that the CKM matrix is unitary:\n",
    "result = ckm_matrix * ckm_matrix.I.T\n",
    "result[result < 1e-2] = 0\n",
    "result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## NumPy Example: MicroBooNE Cross Section Mearurement\n",
    "## $\\chi^2$ Calculation\n",
    "\n",
    "Let's start by getting the MicroBooNE extracted data cross section, as well as the predictions according to GENIE, GiBUU and NuWro, and the covariance matrix. This data is saved into txt files in the `data/` directory.\n",
    "\n",
    "The cross section is a double differential cross section calculated over 42 bins in muon mometum and angle.\n",
    "\n",
    "From [PRL 123 131801](https://journals.aps.org/prl/abstract/10.1103/PhysRevLett.123.131801)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "xsec_data    = np.loadtxt('data/ub_xsec_data.txt')\n",
    "xsec_geniev2 = np.loadtxt('data/ub_xsec_geniev2.txt')\n",
    "xsec_geniev3 = np.loadtxt('data/ub_xsec_geniev3.txt')\n",
    "xsec_gibuu   = np.loadtxt('data/ub_xsec_gibuu.txt')\n",
    "xsec_nuwro   = np.loadtxt('data/ub_xsec_nuwro.txt')\n",
    "cov_m        = np.loadtxt('data/microboone_cc_inclusive_covariance_matrix.txt')\n",
    "\n",
    "# The matrix is importes as an ndarray, let's convert it to a matrix\n",
    "cov_m = np.asmatrix(cov_m)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Covariance matrix:\n",
      "[[0.0014221  0.0024292  0.0020302  ... 0.0045393  0.0024758  0.00034129]\n",
      " [0.0024292  0.023726   0.017872   ... 0.023916   0.013979   0.0022713 ]\n",
      " [0.0020302  0.017872   0.01754    ... 0.017726   0.010885   0.0022958 ]\n",
      " ...\n",
      " [0.0045393  0.023916   0.017726   ... 0.10804    0.077947   0.010734  ]\n",
      " [0.0024758  0.013979   0.010885   ... 0.077947   0.071678   0.010127  ]\n",
      " [0.00034129 0.0022713  0.0022958  ... 0.010734   0.010127   0.00199   ]]\n"
     ]
    }
   ],
   "source": [
    "print('Covariance matrix:', cov_m, sep='\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Data-extracted cross section:\n",
      "[ 3.84353668e-02  2.53289692e-01  2.20457527e-01  4.17274526e-02\n",
      " -9.47941677e-04  1.38306972e-02  2.26293309e-01  2.89972283e-01\n",
      "  5.85665149e-02 -2.31150586e-04 -3.09318252e-02  4.70738332e-01\n",
      "  6.73681772e-01  1.34373251e-01 -1.09858630e-02  2.07742718e-01\n",
      "  7.81307488e-01  3.51045752e-01 -1.32467184e-02  2.39985567e-01\n",
      "  1.01731891e+00  6.40282893e-01  1.83263577e-02  2.50330031e-01\n",
      "  1.25424953e+00  1.12325786e+00  7.37387074e-02  1.81042697e-01\n",
      "  9.26557958e-01  1.52679070e+00  6.87849583e-01  3.37693050e-02\n",
      "  2.30655790e-01  9.60081005e-01  1.80108964e+00  1.17512054e+00\n",
      "  9.70709979e-02  1.78672667e-01  9.77337456e-01  1.69361706e+00\n",
      "  1.38792495e+00  1.94159564e-01]\n"
     ]
    }
   ],
   "source": [
    "print('Data-extracted cross section:', xsec_data, sep='\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's calculate the $\\chi^2$ between data $x_i$ and prediction $\\mu_i$ in bin $i$, and given the covariance matrix $E$: \n",
    "\n",
    "$\\chi^2 = \\sum_{ij} (x_i - \\mu_i) \\cdot E^{-1}_{ij} \\cdot (x_j - \\mu_j)$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "chi2 =  [[245.90854256]]\n"
     ]
    }
   ],
   "source": [
    "# EXCERCISE: Calculate the chi2 between data and prediction:\n",
    "\n",
    "# Difference between x_j and mu_j, elementwise:\n",
    "delta = xsec_data - xsec_geniev2\n",
    "\n",
    "# Inverse of the covariance matrix:\n",
    "cov_m_inv = cov_m.I\n",
    "\n",
    "# Matrix multiplication between E and delta\n",
    "t = cov_m_inv.dot(delta)\n",
    "\n",
    "# Final multiplication\n",
    "chi2 = delta.dot(t.T)\n",
    "\n",
    "print('chi2 = ', chi2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def chi2(data, prediction, cov_m):\n",
    "    delta = data - prediction\n",
    "    cov_m_inv = cov_m.I\n",
    "    t = cov_m_inv.dot(delta)\n",
    "    return delta.dot(t.T).item(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "245.90854256185807"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chi2(xsec_data, xsec_geniev2, cov_m)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GENIEv2 chi2 = 245.90854256185807\n",
      "GENIEv3 chi2 = 108.75939875546912\n",
      "GiBUU   chi2 = 172.91813735442392\n",
      "NuWro   chi2 = 126.43129852215583\n"
     ]
    }
   ],
   "source": [
    "print('GENIEv2 chi2 =', chi2(xsec_data, xsec_geniev2, cov_m))\n",
    "print('GENIEv3 chi2 =', chi2(xsec_data, xsec_geniev3, cov_m))\n",
    "print('GiBUU   chi2 =', chi2(xsec_data, xsec_gibuu,   cov_m))\n",
    "print('NuWro   chi2 =', chi2(xsec_data, xsec_nuwro,   cov_m))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.009037037258409e-07"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# p-value\n",
    "from scipy import stats\n",
    "1 - stats.chi2.cdf(108, 42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Conclusions\n",
    "You know, you can also fly with Python. Let's try:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import antigravity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Extras"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reshape\n",
    "\n",
    "The above array `masses_array` is a 1-D array with 14 elements in it. \n",
    "\n",
    "Numpy allows to resphape it easily. For example, we can transform it into a 2-D array with 7 columns and 2 rows.\n",
    "\n",
    "There a few ways to do this. \n",
    "\n",
    "We can either change the `.shape` attribute directly, but is usually better to use the `np.shape()` function, which returns a new, reshaped, array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2.2000e+00, 4.7000e+00],\n",
       "       [5.1100e-01, 1.2800e+00],\n",
       "       [9.6000e+01, 1.0566e+02],\n",
       "       [1.7300e+05, 4.1800e+03],\n",
       "       [1.7800e+03, 0.0000e+00],\n",
       "       [0.0000e+00, 9.1190e+04],\n",
       "       [8.0390e+04, 1.2497e+05]])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "masses_array_2d = np.reshape(masses_array, (7, 2))\n",
    "masses_array_2d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Statistics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import scipy as sp\n",
    "from scipy.stats import norm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Generated normally distributed values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "random_data_set = sp.randn(10000)\n",
    "type(random_data_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-0.005874525475690234"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "random_data_set.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0060965472758587"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "random_data_set.std()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1.02105228,  1.28686257, -0.3400309 , ..., -0.59083932,\n",
       "       -0.39471744, -0.44720252])"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "random_data_set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Boolean Masks\n",
    "Let's start with a numpy array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "vector = np.array([26, 14, 1, -28, 8, 7])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then, we create a \"mask\". We construct a list with contains True and False values, depending if the elements of `vector` are divisbile or not by 7."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "mask = 0 == (vector % 7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False,  True, False,  True, False,  True])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mask"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we can applt this mask to our vector in order to select only elements that are divisible by 7:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 14, -28,   7])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vector[mask]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}