03_Numpy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy is the fundamental package for scientific computing with Python. It contains among other things:\n",
    "\n",
    "  * a powerful N-dimensional array object <== today's subject\n",
    "  * sophisticated (broadcasting) functions <== today's subject\n",
    "  * tools for integrating C/C++ and Fortran code <== not treated \n",
    "  * random number <== today's subject\n",
    "  * linear algebra, Fourier transform, etc. <== later in the course \n",
    "\n",
    "Besides its obvious scientific uses, NumPy can also be used as an efficient multi-dimensional container of generic data. Arbitrary data-types can be defined and this allows NumPy to seamlessly and speedily integrate with a wide variety of projects\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np # importing convention"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Arrays\n",
    "\n",
    "A numpy array is a grid of values, **all of the same type**, and is indexed by a tuple of nonnegative integers\n",
    "\n",
    "With respect to standard python lists, Numpy provides:\n",
    "* extension package to Python for multi-dimensional arrays\n",
    "* closer to hardware (efficiency)\n",
    "* designed for scientific computation (convenience)\n",
    "* Also known as array oriented computing\n",
    "\n",
    "\n",
    "All standard data types are available:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# type can be set\n",
    "a=np.array([1, 2, 3],'float64')\n",
    "print (a,a.dtype,'\\n')\n",
    "a=np.array([1, 2, 3],'uint32')\n",
    "print (a,a.dtype,'\\n')\n",
    "\n",
    "# or inferred: \n",
    "\n",
    "# complex\n",
    "a=np.array([1+2j, 3+4j, 5+6*1j])\n",
    "print (a,a.dtype,'\\n')\n",
    "\n",
    "# bool\n",
    "a = np.array([True, False, False, True])\n",
    "print (a,a.dtype,'\\n')\n",
    "\n",
    "# string\n",
    "a=np.array(['bonjour messieurs dames', 'Hello', 'Hallo'])\n",
    "print (a,a.dtype,'\\n')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Arrays are memory-efficient container that provides fast numerical operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# standard python\n",
    "L = range(1000)\n",
    "%timeit [i**2 for i in L]\n",
    "\n",
    "# numpy\n",
    "a = np.arange(1000)\n",
    "%timeit a**2\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dimensions\n",
    "\n",
    "The number of dimensions is the rank of the array; the shape of an array is a tuple of integers giving the size of the array along each dimension.\n",
    "\n",
    "1D containers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a1 = np.array([0, 1, 2, 3])\n",
    "print (a1)\n",
    "print (\"array dimensions (rank):\", a1.ndim)\n",
    "print (\"shape of the array:\", a1.shape)\n",
    "print (\"size of the first dimension (axis):\", len(a1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2D, 3D and so on"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a2_3 = np.array([[0, 1, 2], [3, 4, 5]])    # 2 x 3 array (dim x raws x columns)\n",
    "print (\"2 x 3 array:\") \n",
    "print (a2_3)\n",
    "print (\"array dimensions (rank):\", a2_3.ndim)\n",
    "print (\"shape of the array:\", a2_3.shape)\n",
    "print (\"size of the first dimension (axis):\", len(a2_3))\n",
    "\n",
    "print (\"\")\n",
    "\n",
    "a3_2_2 = np.array([[[1,10], [2,20], [3,30]], [[4,40], [5,50], [6,60]]])# 2 x 3 x 2 array (dim x raws x columns)\n",
    "print (\"2 x 3 x 2 array:\")\n",
    "print (a3_2_2)\n",
    "print (\"array dimensions (rank):\", a3_2_2.ndim)\n",
    "print (\"shape of the array:\", a3_2_2.shape)\n",
    "print (\"size of the first dimension (axis):\", len(a3_2_2))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Generating arrays\n",
    "\n",
    "back an forth from a list (i.e. a numpy array is NOT a list):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l = [0, 1, 2, 3]\n",
    "a = np.array(l)\n",
    "print (a.tolist(), type(a.tolist()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Copies and views:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=np.array([1,2,3])\n",
    "b=a # a view\n",
    "c=a.copy() # a copy\n",
    "a[0]=7\n",
    "print (a,b,c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# evenly spaced:\n",
    "print (np.arange(1,9,2)) # same as \"range\": start, end (exclusive), step\n",
    "\n",
    "# or by number of points:\n",
    "print (np.linspace(0, 1, 20)) # start, end, num-points (to be used for plotting f(x))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 3x3 matrix of 1's\n",
    "ones = np.ones((3, 3))\n",
    "print (ones,'\\n')\n",
    "\n",
    "# 2x2 matrix of 0's\n",
    "zeros = np.zeros((2, 2))\n",
    "print (zeros,'\\n')\n",
    "\n",
    "# 3x3 unitary matrix\n",
    "unity3d = np.eye(3)\n",
    "print (unity3d,'\\n')\n",
    "\n",
    "# generic diagonal matrix\n",
    "diagonal = np.diag(np.array([1, 20, 3, 4]))\n",
    "print (diagonal,'\\n')\n",
    "\n",
    "# from lists\n",
    "array = np.array([(i,j) for i in range(2) for j in range(3)])\n",
    "print (array,'\\n')\n",
    "\n",
    "# from a function\n",
    "fromfunct = np.fromfunction(lambda i, j: (i-2)**2+(j-i)**2, (5,5))\n",
    "print (fromfunct,'\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## more on random later!\n",
    "\n",
    "# Setting the random seed\n",
    "np.random.seed(1235)        \n",
    "\n",
    "# filling an array with random numers\n",
    "uniform = np.random.rand(4) # 4 random numbers in [0,1]\n",
    "print (uniform,'\\n')\n",
    "\n",
    "gaussian = np.random.randn(5) # 5 random numbers drawn from a gaussian with mean=0 and sigma=1\n",
    "print (gaussian,'\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reshaping"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=np.arange(0,6)\n",
    "m=a.reshape(3,2) \n",
    "print (\"original=\", a,'\\n')\n",
    "print (\"3x2 matrix:\",'\\n', m,'\\n')\n",
    "# is m a view or a copy??\n",
    "\n",
    "a_from_m = m.flatten()\n",
    "print (\"flattening it out (back to original)=\", a_from_m,'\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1D concatenation\n",
    "a = np.array([1,2])\n",
    "b = np.array([3,4,5,6])\n",
    "c = np.array([7,8,9])\n",
    "print (\"1D concatenation:\", np.concatenate((a, b, c)),'\\n')\n",
    "\n",
    "# nD concatenation\n",
    "a = np.array([[1, 2], [3, 4]])\n",
    "b = np.array([[5, 6], [7,8]])\n",
    "# if no axis is defined, concatenations occurs on the 1st dimension\n",
    "print (\"default 2D concatenation:\",'\\n', np.concatenate((a,b)),'\\n')\n",
    "\n",
    "print (\"concatenation along the first axis:\",'\\n',np.concatenate((a,b), axis=0),'\\n')\n",
    "print (\"concatenation along the second axis:\",'\\n',np.concatenate((a,b), axis=1),'\\n')\n",
    "\n",
    "# adding a dimension, useful for linear algebra\n",
    "a = np.array([1,2,3])\n",
    "print (a[:,np.newaxis])\n",
    "print (a[np.newaxis,:])\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Indexing and slicing\n",
    "\n",
    "The items of an array can be accessed and assigned to the same way as other Python sequences (e.g. lists):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.arange(10)\n",
    "print (a[0], a[2], a[-1])\n",
    "\n",
    "# reminder: the [start:stop:step] works as well. \n",
    "# step can be negative and a reverse sequence is thus obtained\n",
    "print (a[2:9:3])\n",
    "print (a[::-1])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.display import Image\n",
    "Image(\"numpy_indexing.png\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For multidimensional arrays, indexes are tuples of integers.\n",
    "\n",
    "Note:\n",
    "* in 2D, the first dimension corresponds to rows, the second to columns.\n",
    "* for multidimensional a, a[0] is interpreted by taking all elements in the unspecified dimensions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A slicing operation creates a view on the original array, which is just a way of accessing array data. Thus the original array is not copied in memory. You can use `np.may_share_memory()` to check if two arrays share the same memory block. Note however, that this uses heuristics and may give you false positives.\n",
    "\n",
    "When modifying the view, the original array is modified as well, watch out!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.diag(np.arange(3))\n",
    "print (a,'\\n')\n",
    "print (a[1,1],'\\n')\n",
    "print (a[2],'\\n')\n",
    "\n",
    "# assignment\n",
    "a[2, 1] = 10 # third line, second column\n",
    "print (a,'\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fancy indexing\n",
    "\n",
    "NumPy arrays can be indexed with slices, but also with boolean or integer arrays (masks). This method is called fancy indexing. It creates copies not views."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.random.randint(0, 21, 15)\n",
    "print (\"original array:\", a,'\\n')\n",
    "\n",
    "mask = (a % 3 == 0)\n",
    "print (\"the mask:\", mask,'\\n')\n",
    "\n",
    "filtered_a = a[mask]\n",
    "# equivalent to a[a%3==0]\n",
    "print (\"the filtered array:\", filtered_a,'\\n')\n",
    "\n",
    "# Indexing with a mask can be very useful to assign a new value to a sub-array:\n",
    "a[a % 3 == 0] = -1\n",
    "print (\"the modified array:\", a,'\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Indexing can be done with an array of integers, where the same index can be repeated several times. Note the notation!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.arange(0, 100, 10)\n",
    "l = [2, 3, 2, 4, 2] #a python list  \n",
    "print (\"selection of indexes: \",a[l],'\\n')  # note: [2, 3, 2, 4, 2] is a Python list\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When a new array is created by indexing with an array of integers, the new array has the same shape as the array of integers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=np.arange(0,20,2)\n",
    "idx = np.array([[3,4],[9,7]]) # note the shape and the ordering\n",
    "print (a[idx])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# an exstensive example\n",
    "from IPython.display import Image\n",
    "Image(\"numpy_fancy_indexing.png\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Universal functions\n",
    "\n",
    "usual functions are available.\n",
    "In the following the first hints on visualization with `matplotlib`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt # everybody imports it that way\n",
    "\n",
    "%matplotlib inline \n",
    "# tell jupyter to plot inline\n",
    "\n",
    "xs = np.linspace(0, 2*np.pi, 100)\n",
    "ys = np.sin(xs) # np.sin is a universal function\n",
    "plt.plot(xs, ys);\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "image = np.random.rand(30, 30)\n",
    "plt.imshow(image, cmap=plt.cm.hot)    \n",
    "plt.colorbar()    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Elementwise operations\n",
    "\n",
    "### Basic operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# operations with scalars\n",
    "a=np.arange(4)\n",
    "print (a+5,'\\n')\n",
    "print (2**a,'\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# operations among 1D \"vectors\". All is elementwise\n",
    "a=np.arange(4)\n",
    "b = np.ones(4) + 1\n",
    "print (\"a-b:\", a-b)\n",
    "print (\"a*b:\", a*b)\n",
    "\n",
    "# all is much faster than in plain python\n",
    "%timeit np.arange(10000) + 1\n",
    "%timeit [i+1 for i in range(10000)] "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Array multiplication is not matrix multiplication!!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ones = np.ones((3,3))\n",
    "print ('the original matrix:','\\n',ones,'\\n')\n",
    "\n",
    "print ('the \"*\" product: ','\\n',ones*ones,'\\n')\n",
    "\n",
    "print ('the actual matrix product: ','\\n',ones.dot(ones),'\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Other operations\n",
    "\n",
    "comparisons, logical, functions "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# elementwise\n",
    "print ('equal?:',np.array([1,3,2,5])==np.array([3,1,2,1]))\n",
    "print ('greater than?:',np.array([1,3,2,5])>np.array([3,1,2,1]))\n",
    "\n",
    "# array-wise\n",
    "np.array_equal(np.array([1,3,2,5]),np.array([3,1,2,1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# logical\n",
    "a=np.array([1,1,0,0],bool)\n",
    "b=np.array([1,0,1,0],bool)\n",
    "print (\"logical or:\", np.logical_or(a,b))\n",
    "print (\"logical and:\", np.logical_and(a,b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# functions\n",
    "a=np.arange(8)\n",
    "print (\"sin:\", np.sin(a))\n",
    "print (\"log:\", np.log(a))\n",
    "\n",
    "# works in whatever dimension\n",
    "m=a.reshape(2,4)\n",
    "print (m)\n",
    "print (\"exp:\", np.exp(m))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# extracting off-diagonal terms\n",
    "a= np.tril(np.arange(16).reshape(4,4), -1) # play with the last parameter!\n",
    "#a= np.triu(np.arange(16).reshape(4,4), -1) # play with the last parameter (sign and value)!\n",
    "print (\"a:\", '\\n', a , '\\n')\n",
    "\n",
    "print (\"transpose:\", '\\n', a.T , '\\n') #a.T is a view!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "N.B.: a linear algebra package exists in numpy, `numpy.linalg`, but performance-wise the scipy one, `scipy.linalg`, is way better, we will see that later"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reductions\n",
    "\n",
    "Operations on the elements of an array returning a (set of) scalar are available either as methods of the array class or as numpy functions.\n",
    "\n",
    "In dimensions higher than one, the axis have to be specified"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=np.arange(1,7)\n",
    "# just to mess it up (for random see later)\n",
    "np.random.shuffle(a)\n",
    "print (a)\n",
    "print (\"sum:\", a.sum(), np.sum(a))\n",
    "print (\"min:\", a.min(), np.min(a))\n",
    "print (\"max:\", a.max(), np.max(a))\n",
    "print (\"index of the minimum argument:\", a.argmin(), np.argmin(a))\n",
    "print (\"index of the maximum argument:\", a.argmax(), np.argmax(a))\n",
    "print (\"mean:\", a.mean(), np.mean(a))\n",
    "print (\"median:\", np.median(a)) # so weird, median is not a method of the array class..\n",
    "print (\"standard deviation:\", a.std(), np.std(a))\n",
    "# and many others\n",
    "\n",
    "\n",
    "# giving you a \"chicca\" here:\n",
    "#for function in ['sum','min','argmin','mean','median','std']:\n",
    "#    print (function, getattr(np, function)(a))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# all those things wors as well in higher dimensions\n",
    "\n",
    "m=a.reshape(3,2)\n",
    "print (m,'\\n')\n",
    "\n",
    "print (\"sum along the columns:\", m.sum(axis=0))\n",
    "print (\"sum along the rows:\", m.sum(axis=1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Broadcasting\n",
    "\n",
    "So far we have seen elementwise operations on arrays, which works only on arrays of the same size/shape (Verify that out!!).\n",
    "\n",
    "Nevertheless, It’s also possible to do operations on arrays of different\n",
    "sizes if NumPy can transform these arrays so that they all have\n",
    "the same size: this conversion is called broadcasting."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.display import Image\n",
    "Image(\"numpy_broadcasting.png\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.tile(np.arange(0, 40, 10), (3, 1)).T # check what exactly np.tile does! \n",
    "print (\"original array:\",'\\n',a,'\\n')\n",
    "print (\"broadcasted sum :\",'\\n',a+np.arange(3),'\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## More on shape manipulation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# adding a dimension (useful for linear algebra)\n",
    "print (\"new dim along axis 1:\",'\\n', np.arange(1,4)[:,np.newaxis],'\\n')\n",
    "print (\"new dim along axis 0:\",'\\n', np.arange(1,4)[np.newaxis,:],'\\n')\n",
    "\n",
    "# resizing\n",
    "print (\"resizing:\",'\\n', np.resize(np.arange(4),(8,)),'\\n')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Random numbers\n",
    "\n",
    "There are two modules for (pseudo) random numbers that are commonly used. When all you need is to generate random numbers from some distribtuion, the `numpy.random` moodule is the simplest to use. When you need more information realted to a disttribution such as quantiles or the PDF, you can use the `scipy.stats` module, which will see later in the course."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy.random as npr\n",
    "npr.seed(123) # fix seed for reproducible result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Random data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# random values from a uniform distrubtion in [0.0, 1.0) for a given shape\n",
    "print (\"uniform:\",'\\n', npr.rand(3,4),'\\n') # shape=(3,4)\n",
    " \n",
    "# random values from a standard normal distrubtion  for a given shape\n",
    "print (\"normal:\",'\\n', npr.randn(2,5),'\\n') # shape=(2,5)\n",
    "\n",
    "# random integers between \"low\" and \"high\" edges for a given shape (size)\n",
    "print (\"integers:\",'\\n', npr.randint(1,5,size=(3,6)),'\\n') # shape=(3,6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Operations on arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# randomly shuffling a vector\n",
    "x = np.arange(10)\n",
    "npr.shuffle(x)\n",
    "print (\"reshuffling:\",'\\n', x,'\\n')\n",
    "# npr.permutation works similarly\n",
    "\n",
    "# Generates a random sample from a given 1-D array (without replacement)\n",
    "x = np.arange(10,20)\n",
    "print (\"choice w/o replace\",'\\n',npr.choice(x, 10, replace=False),'\\n')\n",
    "\n",
    "# Generates a random sample of a given dimension from a given 1-D array\n",
    "print (\"choice w/o replace\",'\\n',npr.choice(x, (5, 10), replace=True),'\\n') # this is default\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Probability Density Functions\n",
    "\n",
    "numbers can be drawn from basically any common PDF (normal, binomial, chisquare, etc..)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# exponential\n",
    "print (\"exponential:\",'\\n', npr.exponential(10, size=(3,2)),'\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# tossing a dice\n",
    "roll = 1./6\n",
    "x = npr.multinomial(20000, [roll]*6, size=2)\n",
    "print (\"frequencies of 6-faces dice tossing (two players):\",'\\n', x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# toy example - estimating pi inefficiently\n",
    "n = int(1e6)\n",
    "x = npr.uniform(-1,1,(n,2))\n",
    "4.0*np.sum(x[:,0]**2 + x[:,1]**2 < 1)/n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# uniformly distributed numbers in 2D\n",
    "x = npr.uniform(-1, 1, (100, 2))\n",
    "plt.scatter(x[:,0], x[:,1], s=50)\n",
    "plt.axis([-1.05, 1.05, -1.05, 1.05]);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}