{ "cells": [ { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "# Week 05 - Numpy II and Scipy\n", "\n", "## Today's Agenda\n", "- Numpy II\n", "- Scipy" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "# Numpy II\n", "\n", "Last time in [Week 05](https://github.com/VandyAstroML/Vanderbilt_Computational_Bootcamp/blob/master/notebooks/Week_05/05_Numpy_Matplotlib.ipynb), we covered `Numpy` and `Matplotlib`. This time we will be focusing on more advanced concepts of `Numpy`." ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "deletable": true, "editable": true }, "outputs": [], "source": [ "# Loading modules\n", "%matplotlib inline\n", "import numpy as np\n", "import matplotlib.pyplot as plt" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "## Review\n", "As a review, let's explore some of the concepts that were introduced last time, in `Numpy I`.\n", "\n", "### Create 1D-arrays\n", "We introduced how to create a 1D-array" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "collapsed": false, "deletable": true, "editable": true, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([ 1., 2., 3., 5., 6., 7., 8., 10.])" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "x = np.array([1,2,3,5,6,7,8,10],dtype=float)\n", "x" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "collapsed": false, "deletable": true, "editable": true, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "y = np.arange(10)\n", "y" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "collapsed": false, "deletable": true, "editable": true, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([ 0. , 2.04081633, 4.08163265, 6.12244898,\n", " 8.16326531, 10.20408163, 12.24489796, 14.28571429,\n", " 16.32653061, 18.36734694, 20.40816327, 22.44897959,\n", " 24.48979592, 26.53061224, 28.57142857, 30.6122449 ,\n", " 32.65306122, 34.69387755, 36.73469388, 38.7755102 ,\n", " 40.81632653, 42.85714286, 44.89795918, 46.93877551,\n", " 48.97959184, 51.02040816, 53.06122449, 55.10204082,\n", " 57.14285714, 59.18367347, 61.2244898 , 63.26530612,\n", " 65.30612245, 67.34693878, 69.3877551 , 71.42857143,\n", " 73.46938776, 75.51020408, 77.55102041, 79.59183673,\n", " 81.63265306, 83.67346939, 85.71428571, 87.75510204,\n", " 89.79591837, 91.83673469, 93.87755102, 95.91836735,\n", " 97.95918367, 100. ])" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "z = np.linspace(0,100,50)\n", "z" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "collapsed": false, "deletable": true, "editable": true, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([ 1.2125995 , 1.83486385, 0.63821859, -0.20766847, 0.16394987,\n", " 0.29579982, -1.16177048, -0.83906042, 1.05600292, -0.96406777,\n", " -1.83799388, -2.2114805 , -0.46763226, -0.28014607, -0.82671363,\n", " -0.29653933, -0.99461879, -1.05692908, -0.63431348, 0.58229083,\n", " -0.06923924, 2.56103329, 0.14558599, 0.06025412, 1.29401031,\n", " -0.9230366 , 1.01506698, 0.3772861 , -1.20513242, 1.49001138,\n", " -0.8995781 , 1.3497741 , 1.408165 , 1.23759972, 0.61076751,\n", " -0.4094068 , 0.67698797, -0.77231489, -1.56098342, -0.99862791,\n", " 1.21275181, 0.00340132, 0.77635256, 0.03975821, 1.06701466,\n", " 0.05538845, 1.00814729, -0.79890085, 0.01000337, 0.36924362,\n", " -0.79997093, -0.83036405, -0.741903 , 1.48206007, 0.3152332 ,\n", " -0.17685307, -0.17511851, 0.74958486, -1.16929455, 1.03634486,\n", " 1.71691808, 0.84479828, -0.65825241, -1.49280007, -0.90322557,\n", " 0.33369591, -0.65891918, 1.81929896, 0.22827773, 2.24103316,\n", " -0.50474291, 0.67246374, 0.57899788, 0.14338281, -0.80948219,\n", " -0.09728413, 0.8249388 , 1.44920434, -1.61984601, -0.23985288,\n", " 0.12277596, -0.73190566, 0.63827243, -0.13229476, 0.3812185 ,\n", " -1.58845796, -1.52718767, -0.10934944, -1.35275154, 0.79154503,\n", " 1.76049644, -0.26587198, -0.0231885 , -0.8432236 , 0.68359977,\n", " 2.46355285, 1.85368996, -1.49378643, -0.49819556, 0.0810053 ])" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "h = np.random.randn(100)\n", "h" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "### Handling arrays\n", "\n", "These are just a few of the different ways to __create__ numpy arrays.\n", "\n", "You can also use functions like __np.max()__ and __np.min()__ to get the maximum and minimum values, respectively." ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "collapsed": false, "deletable": true, "editable": true, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Min X: 1.000 \t Max X: 10.000\n" ] } ], "source": [ "print('Min X: {0:.3f} \\t Max X: {1:.3f}'.format(np.min(x), np.max(x)) )" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "#### Apply mathematical functions" ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "collapsed": false, "deletable": true, "editable": true, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([ 4., 28., 90., 400., 684., 1078., 1600., 3100.])" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "zz = x**2 + 3*x**3\n", "zz" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "#### Conditionals\n", "Find the indices of the elements in an array that meet some criteria.\n", "In this example, we're finding all the elements that are within 100 and 500 in array ___\"```zz```\"___." ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "collapsed": false, "deletable": true, "editable": true, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "zz_idx: [3]\n" ] }, { "data": { "text/plain": [ "array([400.])" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "zz_idx = np.where((zz>= 100)&(zz <= 500))[0]\n", "print('zz_idx: {0}'.format(zz_idx))\n", "\n", "zz[zz_idx]" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "## Manipulating Arrays\n", "There are a lot of things we can do to a _numpy array_. " ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "collapsed": false, "deletable": true, "editable": true, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([25, 26, 24, 15, 35, 24, 21, 47, 31, 22, 17, 35, 47, 30, 14, 29, 17,\n", " 17, 22, 27, 46, 26, 49, 40, 27, 30, 20, 26, 36, 38, 49, 15, 16, 29,\n", " 24, 21, 26, 47, 41, 14, 20, 37, 40, 18, 31, 29, 34, 31, 41, 42])" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "h1 = np.random.randint(10, 50, 50)\n", "h1" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "We can get the overall __size__ and __shape__ of the array.\n", "\n", "We cane use the functions `numpy.size` and `numpy.shape` to get the total number of elements in an array and the shape of the array, respectively." ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "collapsed": false, "deletable": true, "editable": true, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "50" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.size(h1)" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "collapsed": false, "deletable": true, "editable": true, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "(50,)" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "h1.shape" ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "collapsed": false, "deletable": true, "editable": true, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([[ 1, 2, 3, 4, 5],\n", " [ 6, 7, 8, 9, 10],\n", " [12, 13, 14, 16, 17],\n", " [13, 45, 67, 89, 90]])" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "A = np.array([[1,2,3,4,5],\n", " [6,7,8,9,10],\n", " [12,13,14,16,17],\n", " [13,45,67,89,90] ])\n", "A" ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "collapsed": false, "deletable": true, "editable": true, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "(4, 5)" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.shape(A)" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "You can also __transpose__ array `A`." ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "collapsed": false, "deletable": true, "editable": true, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([[ 1, 6, 12, 13],\n", " [ 2, 7, 13, 45],\n", " [ 3, 8, 14, 67],\n", " [ 4, 9, 16, 89],\n", " [ 5, 10, 17, 90]])" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "A_t = np.transpose(A)\n", "A_t" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "Why are `Numpy` arrays better than lists:\n", "- Python lists are very _general_.\n", "- Lists __do not__ support matrix and dot multiplications, etc.\n", "- `Numpy` arrays are memory _efficient_.\n", "- Numpy arrays are __statically typed__ and __homogeneous__.\n", "- They are fast at mathematical functions.\n", "- They can be used in compiled languages, e.g. _C_ and _Fortran_." ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "### Array-generating functions\n", "For large arrays it is inpractical to initialize the data manually, using normal Python lists. Instead, we can use many of the Numpy functions to generate arrays of different forms." ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "#### __numpy.arange__\n", "We use this one to create a sequence of ordered elements" ] }, { "cell_type": "code", "execution_count": 15, "metadata": { "collapsed": false, "deletable": true, "editable": true, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.arange(0,10,1)" ] }, { "cell_type": "code", "execution_count": 16, "metadata": { "collapsed": false, "deletable": true, "editable": true, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([ 0, 5, 10, 15])" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.arange(0,20,5)" ] }, { "cell_type": "code", "execution_count": 17, "metadata": { "collapsed": false, "deletable": true, "editable": true, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([-40, -30, -20, -10, 0, 10, 20])" ] }, "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.arange(-40,21,10)" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "#### linspace and logspace\n", "We use these functions to created ordered lists, separated by intervals in _real_- and _log_-space." ] }, { "cell_type": "code", "execution_count": 18, "metadata": { "collapsed": false, "deletable": true, "editable": true, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([ 0. , 1.02040816, 2.04081633, 3.06122449, 4.08163265,\n", " 5.10204082, 6.12244898, 7.14285714, 8.16326531, 9.18367347,\n", " 10.20408163, 11.2244898 , 12.24489796, 13.26530612, 14.28571429,\n", " 15.30612245, 16.32653061, 17.34693878, 18.36734694, 19.3877551 ,\n", " 20.40816327, 21.42857143, 22.44897959, 23.46938776, 24.48979592,\n", " 25.51020408, 26.53061224, 27.55102041, 28.57142857, 29.59183673,\n", " 30.6122449 , 31.63265306, 32.65306122, 33.67346939, 34.69387755,\n", " 35.71428571, 36.73469388, 37.75510204, 38.7755102 , 39.79591837,\n", " 40.81632653, 41.83673469, 42.85714286, 43.87755102, 44.89795918,\n", " 45.91836735, 46.93877551, 47.95918367, 48.97959184, 50. ])" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "B = np.linspace(0,50)\n", "B" ] }, { "cell_type": "code", "execution_count": 19, "metadata": { "collapsed": false, "deletable": true, "editable": true, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([ 0. , 5.26315789, 10.52631579, 15.78947368,\n", " 21.05263158, 26.31578947, 31.57894737, 36.84210526,\n", " 42.10526316, 47.36842105, 52.63157895, 57.89473684,\n", " 63.15789474, 68.42105263, 73.68421053, 78.94736842,\n", " 84.21052632, 89.47368421, 94.73684211, 100. ])" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "B = np.linspace(0,100, 20)\n", "B" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "Array of __25 elements__ from $10^{0}$ to $10^{3}$, with __base of 10__." ] }, { "cell_type": "code", "execution_count": 20, "metadata": { "collapsed": false, "deletable": true, "editable": true, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([ 1. , 1.33352143, 1.77827941, 2.37137371,\n", " 3.16227766, 4.21696503, 5.62341325, 7.49894209,\n", " 10. , 13.33521432, 17.7827941 , 23.71373706,\n", " 31.6227766 , 42.16965034, 56.23413252, 74.98942093,\n", " 100. , 133.35214322, 177.827941 , 237.13737057,\n", " 316.22776602, 421.69650343, 562.34132519, 749.89420933,\n", " 1000. ])" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "B = np.logspace(0,3,25)\n", "B" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "Creating an array of 11 elements from $e^{0}$ to $e^{10}$, with the ```base == numpy.e```" ] }, { "cell_type": "code", "execution_count": 21, "metadata": { "collapsed": false, "deletable": true, "editable": true, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([1.00000000e+00, 2.71828183e+00, 7.38905610e+00, 2.00855369e+01,\n", " 5.45981500e+01, 1.48413159e+02, 4.03428793e+02, 1.09663316e+03,\n", " 2.98095799e+03, 8.10308393e+03, 2.20264658e+04])" ] }, "execution_count": 21, "metadata": {}, "output_type": "execute_result" } ], "source": [ "B = np.logspace(0,10,11, base=np.e)\n", "B" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "#### Random Data" ] }, { "cell_type": "code", "execution_count": 22, "metadata": { "deletable": true, "editable": true }, "outputs": [], "source": [ "from numpy import random" ] }, { "cell_type": "code", "execution_count": 23, "metadata": { "collapsed": false, "deletable": true, "editable": true, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([[0.60426703, 0.09522098, 0.73603191, 0.41629722, 0.03830843],\n", " [0.16121388, 0.42582919, 0.97209131, 0.9586233 , 0.61308885],\n", " [0.63238237, 0.15224875, 0.0961162 , 0.91785892, 0.1275659 ],\n", " [0.9448008 , 0.01132601, 0.656943 , 0.03904403, 0.28083426],\n", " [0.80007388, 0.05710783, 0.23060248, 0.75706392, 0.14909109]])" ] }, "execution_count": 23, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Uniform random numbers in [0,1]\n", "random.rand(5,5)" ] }, { "cell_type": "code", "execution_count": 24, "metadata": { "collapsed": false, "deletable": true, "editable": true, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([24, 15, 18, 26, 19, 19, 17, 27, 22, 23, 17, 10, 28, 19, 22, 22, 18,\n", " 11, 13, 15])" ] }, "execution_count": 24, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 20 Random integers from 10 to 30\n", "random.randint(10,30,20)" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "#### Arrays of `zeros` and `ones`." ] }, { "cell_type": "code", "execution_count": 25, "metadata": { "collapsed": false, "deletable": true, "editable": true, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", " 0., 0., 0.])" ] }, "execution_count": 25, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.zeros(20)" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "You can use these to populate other arrays" ] }, { "cell_type": "code", "execution_count": 26, "metadata": { "collapsed": false, "deletable": true, "editable": true, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1.])" ] }, "execution_count": 26, "metadata": {}, "output_type": "execute_result" } ], "source": [ "nelem = 10\n", "C = np.ones(10)\n", "C" ] }, { "cell_type": "code", "execution_count": 27, "metadata": { "collapsed": false, "deletable": true, "editable": true, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([0.93317549, 0.14262875, 0.6902437 , 0.87186553, 0.53890869,\n", " 0.71245388, 0.15132051, 0.20685907, 0.39431495, 0.89131517])" ] }, "execution_count": 27, "metadata": {}, "output_type": "execute_result" } ], "source": [ "for ii in range(C.size):\n", " C[ii] = random.rand()\n", "C" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "### Diagonals\n", "You can also construct an array with another array as the diagonal" ] }, { "cell_type": "code", "execution_count": 28, "metadata": { "collapsed": false, "deletable": true, "editable": true, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([[16, 0, 0, 0, 0],\n", " [ 0, 13, 0, 0, 0],\n", " [ 0, 0, 11, 0, 0],\n", " [ 0, 0, 0, 15, 0],\n", " [ 0, 0, 0, 0, 14]])" ] }, "execution_count": 28, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.diag(random.randint(10,20,5))" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "### Indexing" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "You can choose which values to select.\n", "Normally, you select the `rows` first, and then the `cols` of a `numpy.ndarray`." ] }, { "cell_type": "code", "execution_count": 29, "metadata": { "collapsed": false, "deletable": true, "editable": true, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([[0.68677283, 0.38902045, 0.42871994, 0.81523068, 0.64483989],\n", " [0.51884508, 0.49264815, 0.99477923, 0.18455273, 0.51262224],\n", " [0.45850799, 0.66295697, 0.81406189, 0.66847916, 0.62882748],\n", " [0.652714 , 0.24415316, 0.47897214, 0.06621372, 0.27317223],\n", " [0.04435413, 0.49195189, 0.10773559, 0.85004019, 0.29236086],\n", " [0.96106373, 0.35939549, 0.75456427, 0.00273902, 0.14031911],\n", " [0.69224339, 0.46379945, 0.59234115, 0.19991018, 0.49572112],\n", " [0.30785617, 0.97237966, 0.47133784, 0.79830205, 0.54963373],\n", " [0.30952122, 0.50024043, 0.41479166, 0.51712861, 0.57509521],\n", " [0.99702942, 0.41362465, 0.44884597, 0.8832873 , 0.95066126]])" ] }, "execution_count": 29, "metadata": {}, "output_type": "execute_result" } ], "source": [ "M = random.rand(10,5)\n", "M" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "Selecting the 1st row" ] }, { "cell_type": "code", "execution_count": 30, "metadata": { "collapsed": false, "deletable": true, "editable": true, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([0.51884508, 0.49264815, 0.99477923, 0.18455273, 0.51262224])" ] }, "execution_count": 30, "metadata": {}, "output_type": "execute_result" } ], "source": [ "M[1,:]" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "The 2nd column" ] }, { "cell_type": "code", "execution_count": 31, "metadata": { "collapsed": false, "deletable": true, "editable": true, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([0.38902045, 0.49264815, 0.66295697, 0.24415316, 0.49195189,\n", " 0.35939549, 0.46379945, 0.97237966, 0.50024043, 0.41362465])" ] }, "execution_count": 31, "metadata": {}, "output_type": "execute_result" } ], "source": [ "M[:,1]" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "Select a range of columns and rows" ] }, { "cell_type": "code", "execution_count": 32, "metadata": { "collapsed": false, "deletable": true, "editable": true, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([[0.99477923, 0.18455273],\n", " [0.81406189, 0.66847916]])" ] }, "execution_count": 32, "metadata": {}, "output_type": "execute_result" } ], "source": [ "M[1:3, 2:4]" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "You can easily use this to create a __mask__, for when you are _cleaning_ your data." ] }, { "cell_type": "code", "execution_count": 33, "metadata": { "collapsed": false, "deletable": true, "editable": true, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([[ nan, 0.22709903, 0.34331486],\n", " [0.91062782, nan, 0.89461017],\n", " [0.54718005, 0.09103976, nan]])" ] }, "execution_count": 33, "metadata": {}, "output_type": "execute_result" } ], "source": [ "A = random.rand(3,3)\n", "np.fill_diagonal(A, np.nan)\n", "A" ] }, { "cell_type": "code", "execution_count": 34, "metadata": { "collapsed": false, "deletable": true, "editable": true, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([[0, 1, 2],\n", " [3, 4, 5],\n", " [6, 7, 8]])" ] }, "execution_count": 34, "metadata": {}, "output_type": "execute_result" } ], "source": [ "B = np.arange(0,9).reshape((3,3))\n", "B" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "Appying the __mask__ from $A \\to B$" ] }, { "cell_type": "code", "execution_count": 35, "metadata": { "collapsed": false, "deletable": true, "editable": true, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([[False, True, True],\n", " [ True, False, True],\n", " [ True, True, False]])" ] }, "execution_count": 35, "metadata": {}, "output_type": "execute_result" } ], "source": [ "A_mask = np.isfinite(A)\n", "A_mask" ] }, { "cell_type": "code", "execution_count": 36, "metadata": { "collapsed": false, "deletable": true, "editable": true, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([1, 2, 3, 5, 6, 7])" ] }, "execution_count": 36, "metadata": {}, "output_type": "execute_result" } ], "source": [ "B[A_mask]" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "### Binning you data\n", "This is probably one of the best functions of `Numpy`.\n", "You can use this to bin you data, and calculate __means__, __standard deviations__, etc." ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "#### numpy.digitize" ] }, { "cell_type": "code", "execution_count": 37, "metadata": { "collapsed": false, "deletable": true, "editable": true, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])" ] }, "execution_count": 37, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Creating my bin edges\n", "bins = np.arange(0,13)\n", "bins" ] }, { "cell_type": "code", "execution_count": 38, "metadata": { "collapsed": false, "deletable": true, "editable": true, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([4.99232218, 5.53702794, 5.929478 , 0.83550921, 9.96708561,\n", " 2.96031408, 2.00377163, 0.31854306, 0.48134572, 8.66035854,\n", " 9.95827216, 6.93070449, 4.47507617, 1.07392493, 8.15819131,\n", " 5.44619864, 2.53174022, 0.16471857, 8.35843109, 3.12430454,\n", " 4.99680908, 2.18259352, 9.21925301, 1.61365526, 7.83888345,\n", " 7.83650219, 8.6382215 , 8.30377063, 3.94558256, 5.31388424,\n", " 7.40166355, 2.91812888, 8.57977213, 0.4082193 , 1.4190216 ,\n", " 0.8316332 , 1.35202807, 8.28293158, 3.60098678, 6.28447875,\n", " 7.12344948, 1.13588079, 5.05358434, 0.10274816, 1.71728426,\n", " 3.30533502, 3.41941008, 9.99568425, 5.70585609, 3.95266365,\n", " 4.94809192, 9.25017982, 1.76354834, 0.16091627, 7.69585176,\n", " 5.37392259, 5.66522166, 6.62362653, 7.96742888, 2.46147816,\n", " 7.87554625, 9.54633578, 4.74731321, 5.30576571, 1.20723003,\n", " 0.03960206, 1.01701994, 1.35132563, 4.98330919, 3.84840303,\n", " 6.82422195, 0.81665793, 4.60547073, 5.82589065, 9.54330536,\n", " 6.28828892, 6.57514647, 2.24173202, 4.48154443, 9.28000871,\n", " 9.97469965, 5.7771928 , 5.75892113, 5.58329275, 7.99999175,\n", " 2.57523747, 4.55828035, 4.25558514, 6.56544173, 1.60343203,\n", " 2.30881588, 5.87116817, 7.95971268, 7.6376034 , 7.12862717,\n", " 5.01166971, 6.17339498, 6.55501683, 6.06717032, 3.18076008])" ] }, "execution_count": 38, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Generating Data\n", "data = 10*random.rand(100)\n", "data" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "Now I want to bin my data and calculate the mean for each bin" ] }, { "cell_type": "code", "execution_count": 39, "metadata": { "collapsed": false, "deletable": true, "editable": true, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([ 5, 6, 6, 1, 10, 3, 3, 1, 1, 9, 10, 7, 5, 2, 9, 6, 3,\n", " 1, 9, 4, 5, 3, 10, 2, 8, 8, 9, 9, 4, 6, 8, 3, 9, 1,\n", " 2, 1, 2, 9, 4, 7, 8, 2, 6, 1, 2, 4, 4, 10, 6, 4, 5,\n", " 10, 2, 1, 8, 6, 6, 7, 8, 3, 8, 10, 5, 6, 2, 1, 2, 2,\n", " 5, 4, 7, 1, 5, 6, 10, 7, 7, 3, 5, 10, 10, 6, 6, 6, 8,\n", " 3, 5, 5, 7, 2, 3, 6, 8, 8, 8, 6, 7, 7, 7, 4])" ] }, "execution_count": 39, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Defining statistical function to use\n", "stat_func = np.nanmean\n", "# Binning the data\n", "data_bins = np.digitize(data, bins)\n", "data_bins" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "Calculating the __mean__ for each of the bins" ] }, { "cell_type": "code", "execution_count": 40, "metadata": { "collapsed": false, "deletable": true, "editable": true, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([ 0.41598935, 1.38675917, 2.46486798, 3.54718072,\n", " 4.70438024, 5.54393829, 6.4887491 , 7.67866005,\n", " 8.42595382, 9.63720271, -10. , -10. ])" ] }, "execution_count": 40, "metadata": {}, "output_type": "execute_result" } ], "source": [ "failval = -10\n", "bins_stat = np.array([stat_func(data[data_bins == ii]) \\\n", " if len(data[data_bins == ii]) > 0 \\\n", " else failval \\\n", " for ii in range(1,len(bins))])\n", "bins_stat = np.asarray(bins_stat)\n", "bins_stat" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "You can put all of this into a function that estimates errors and more..." ] }, { "cell_type": "code", "execution_count": 41, "metadata": {}, "outputs": [], "source": [ "import math\n", "\n", "def myceil(x, base=10):\n", " \"\"\"\n", " Returns the upper-bound integer of 'x' in base 'base'.\n", "\n", " Parameters\n", " ----------\n", " x: float\n", " number to be approximated to closest number to 'base'\n", "\n", " base: float\n", " base used to calculate the closest 'largest' number\n", "\n", " Returns\n", " -------\n", " n_high: float\n", " Closest float number to 'x', i.e. upper-bound float.\n", "\n", " Example\n", " -------\n", " >>>> myceil(12,10)\n", " 20\n", " >>>>\n", " >>>> myceil(12.05, 0.1)\n", " 12.10000 \n", " \"\"\"\n", " n_high = float(base*math.ceil(float(x)/base))\n", "\n", " return n_high\n", "\n", "def myfloor(x, base=10):\n", " \"\"\"\n", " Returns the lower-bound integer of 'x' in base 'base'\n", "\n", " Parameters\n", " ----------\n", " x: float\n", " number to be approximated to closest number of 'base'\n", "\n", " base: float\n", " base used to calculate the closest 'smallest' number\n", "\n", " Returns\n", " -------\n", " n_low: float\n", " Closest float number to 'x', i.e. lower-bound float.\n", "\n", " Example\n", " -------\n", " >>>> myfloor(12, 5)\n", " >>>> 10\n", " \"\"\"\n", " n_low = float(base*math.floor(float(x)/base))\n", "\n", " return n_low\n", "\n", "def Bins_array_create(arr, base=10):\n", " \"\"\"\n", " Generates array between [arr.min(), arr.max()] in steps of `base`.\n", "\n", " Parameters\n", " ----------\n", " arr: array_like, Shape (N,...), One-dimensional\n", " Array of numerical elements\n", "\n", " base: float, optional (default=10)\n", " Interval between bins\n", "\n", " Returns\n", " -------\n", " bins_arr: array_like\n", " Array of bin edges for given arr\n", "\n", " \"\"\"\n", " base = float(base)\n", " arr = np.array(arr)\n", " assert(arr.ndim==1)\n", " arr_min = myfloor(arr.min(), base=base)\n", " arr_max = myceil( arr.max(), base=base)\n", " bins_arr = np.arange(arr_min, arr_max+0.5*base, base)\n", "\n", " return bins_arr" ] }, { "cell_type": "code", "execution_count": 42, "metadata": {}, "outputs": [], "source": [ "def Mean_std_calc_one_array(x1, y1, arr_len=0, statfunc=np.nanmean,\n", " failval=np.nan, error='std',\n", " base=10.):\n", " \"\"\"\n", " Calculates statistics of two arrays, e.g. scatter,\n", " error in `statfunc`, etc.\n", " \n", " Parameters\n", " ----------\n", " x1: array-like, shape (N,)\n", " array of x-values\n", " \n", " y1: array-like, shape (N,)\n", " array of y-values\n", " \n", " arr_len: int, optional (default = 0)\n", " minimum number of elements in the bin\n", " \n", " statfunc: numpy function, optional (default = numpy.nanmean)\n", " statistical function used to evaluate the bins\n", " \n", " failval: int or float, optional (default = numpy.nan)\n", " Number to use to replace when the number of elements in the \n", " bin is smaller than `arr_len`\n", " \n", " error: string, optional (default = 'std')\n", " type of error to evaluate\n", " Options:\n", " - 'std': Evaluates the standard deviation of the bin\n", " - 'stat': Evaluates the error in the mean/median of each bin\n", " - 'none': Does not calculate the error in `y1`\n", " base: float\n", " Value of bin width in units of that of `x1`\n", " \n", " Returns\n", " --------\n", " x1_stat: array-like, shape (N,)\n", " `stat_func` of each bin in `base` spacings for x1\n", "\n", " y1_stat: array-like, shape (N,)\n", " `stat_func` of each bin in `base` spacings for y1\n", " \"\"\"\n", " x1 = np.asarray(x1)\n", " y1 = np.asarray(y1)\n", " assert((x1.ndim==1) & (y1.ndim==1))\n", " assert((x1.size >0) & (y1.size>0))\n", " n_elem = len(x1)\n", " ## Computing Bins\n", " x1_bins = Bins_array_create(x1, base=base)\n", " x1_digit = np.digitize(x1, x1_bins)\n", " ## Computing Statistics in bins\n", " x1_stat = np.array([statfunc(x1[x1_digit==ii]) \n", " if len(x1[x1_digit==ii])>arr_len \n", " else failval\n", " for ii in range(1,x1_bins.size)])\n", " y1_stat = np.array([statfunc(y1[x1_digit==ii])\n", " if len(y1[x1_digit==ii])>arr_len \n", " else failval\n", " for ii in range(1,x1_bins.size)])\n", " ## Computing error in the data\n", " if error=='std':\n", " stat_err = np.nanstd\n", " y1_err = np.array([stat_err(y1[x1_digit==ii]) \n", " if len(y1[x1_digit==ii])>arr_len \n", " else failval\n", " for ii in range(1,x1_bins.size)])\n", " if error!='none':\n", " y1_err = np.array([stat_err(y1[x1_digit==ii])/np.sqrt(len(y1[x1_digit==ii]))\n", " if len(y1[x1_digit==ii])>arr_len\n", " else failval\n", " for ii in range(1,x1_bins.size)])\n", " if (stat_func==np.median) or (stat_func==np.nanmedian):\n", " y1_err *= 1.253\n", " else:\n", " y1_err = np.zeros(y1.stat.size)\n", " \n", " return x1_stat, y1_stat, y1_err" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "__Example of using these function__:" ] }, { "cell_type": "code", "execution_count": 43, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [ "import numpy as np\n", "\n", "# Defining arrays\n", "x_arr = np.arange(100)\n", "y_arr = 50*np.random.randn(x_arr.size)\n", "\n", "# Computing mean and error in the mean for `x_arr` and `y_arr`\n", "x_stat, y_stat, y_err = Mean_std_calc_one_array(x_arr, y_arr,\n", " statfunc=np.nanmean,\n", " failval=np.nan,\n", " base=10)\n", "x_stat2, y_stat2, y_err2 = Mean_std_calc_one_array(x_arr, y_arr,\n", " statfunc=np.nanmedian,\n", " failval=np.nan,\n", " base=10)" ] }, { "cell_type": "code", "execution_count": 44, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "plt.style.use('seaborn-notebook')\n", "plt.clf()\n", "plt.close()\n", "fig = plt.figure(figsize=(12,8))\n", "ax = fig.add_subplot(111,facecolor='white')\n", "ax.plot(x_arr, y_arr, 'ro', label='Data')\n", "ax.errorbar(x_stat, y_stat, yerr=y_err, color='blue', marker='o',\n", " linestyle='--',label='Mean')\n", "ax.errorbar(x_stat2, y_stat2, yerr=y_err2, color='green', marker='o',\n", " linestyle='--',label='Median')\n", "ax.set_xlabel('X axis', fontsize=20)\n", "ax.set_ylabel('Y axis', fontsize=20)\n", "ax.set_title('Data and the Binned Data', fontsize=24)\n", "plt.legend(fontsize=20)\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "With this function, it is really easy to apply statistics on binned data, as well as to ___estimate errors___ on the data." ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "### Reshaping, resizing and stacking arrays\n", "One can always modify the shape of a `numpy.ndarray`, as well as append it to a pre-existing array." ] }, { "cell_type": "code", "execution_count": 45, "metadata": { "collapsed": false, "deletable": true, "editable": true, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([[ 0, 1, 2, 3, 4],\n", " [10, 11, 12, 13, 14],\n", " [20, 21, 22, 23, 24],\n", " [30, 31, 32, 33, 34],\n", " [40, 41, 42, 43, 44]])" ] }, "execution_count": 45, "metadata": {}, "output_type": "execute_result" } ], "source": [ "A = np.array([[n+m*10 for n in range(5)] for m in range(5)])\n", "A" ] }, { "cell_type": "code", "execution_count": 46, "metadata": { "deletable": true, "editable": true }, "outputs": [], "source": [ "n, m = A.shape" ] }, { "cell_type": "code", "execution_count": 47, "metadata": { "collapsed": false, "deletable": true, "editable": true, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([[ 0, 1, 2, 3, 4, 10, 11, 12, 13, 14, 20, 21, 22, 23, 24, 30,\n", " 31, 32, 33, 34, 40, 41, 42, 43, 44]])" ] }, "execution_count": 47, "metadata": {}, "output_type": "execute_result" } ], "source": [ "B = A.reshape((1,n*m))\n", "B" ] }, { "cell_type": "code", "execution_count": 48, "metadata": { "collapsed": false, "deletable": true, "editable": true, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([ 0, 1, 2, 3, 4, 10, 11, 12, 13, 14, 20, 21, 22, 23, 24, 30, 31,\n", " 32, 33, 34, 40, 41, 42, 43, 44])" ] }, "execution_count": 48, "metadata": {}, "output_type": "execute_result" } ], "source": [ "A_f = A.flatten()\n", "A_f" ] }, { "cell_type": "code", "execution_count": 49, "metadata": { "collapsed": false, "deletable": true, "editable": true, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([0.22546599, 0.97540312, 0.13059234, 0.60889311, 0.30114622,\n", " 0.35999722, 0.87544608, 0.22143994, 0.02629711, 0.5020551 ,\n", " 0.85802423, 0.20244432, 0.4825194 , 0.38529469, 0.79174434,\n", " 0.55720808, 0.18167695, 0.58105877, 0.41776584, 0.80677464,\n", " 0.2633001 , 0.79435708, 0.87975669, 0.94088208, 0.89088446])" ] }, "execution_count": 49, "metadata": {}, "output_type": "execute_result" } ], "source": [ "C = random.rand(A.size)\n", "C" ] }, { "cell_type": "code", "execution_count": 50, "metadata": { "collapsed": false, "deletable": true, "editable": true, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "(25,)" ] }, "execution_count": 50, "metadata": {}, "output_type": "execute_result" } ], "source": [ "C.shape" ] }, { "cell_type": "code", "execution_count": 51, "metadata": { "collapsed": false, "deletable": true, "editable": true, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([[0.00000000e+00, 2.25465989e-01],\n", " [1.00000000e+00, 9.75403121e-01],\n", " [2.00000000e+00, 1.30592337e-01],\n", " [3.00000000e+00, 6.08893110e-01],\n", " [4.00000000e+00, 3.01146219e-01],\n", " [1.00000000e+01, 3.59997225e-01],\n", " [1.10000000e+01, 8.75446079e-01],\n", " [1.20000000e+01, 2.21439941e-01],\n", " [1.30000000e+01, 2.62971117e-02],\n", " [1.40000000e+01, 5.02055104e-01],\n", " [2.00000000e+01, 8.58024231e-01],\n", " [2.10000000e+01, 2.02444322e-01],\n", " [2.20000000e+01, 4.82519404e-01],\n", " [2.30000000e+01, 3.85294690e-01],\n", " [2.40000000e+01, 7.91744345e-01],\n", " [3.00000000e+01, 5.57208079e-01],\n", " [3.10000000e+01, 1.81676951e-01],\n", " [3.20000000e+01, 5.81058773e-01],\n", " [3.30000000e+01, 4.17765837e-01],\n", " [3.40000000e+01, 8.06774642e-01],\n", " [4.00000000e+01, 2.63300096e-01],\n", " [4.10000000e+01, 7.94357085e-01],\n", " [4.20000000e+01, 8.79756686e-01],\n", " [4.30000000e+01, 9.40882076e-01],\n", " [4.40000000e+01, 8.90884459e-01]])" ] }, "execution_count": 51, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Stacking the two arrays\n", "D = np.column_stack((A_f,C))\n", "D" ] }, { "cell_type": "code", "execution_count": 52, "metadata": { "collapsed": false, "deletable": true, "editable": true, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([[ 2. , 0.13059234],\n", " [ 3. , 0.60889311],\n", " [ 4. , 0.30114622],\n", " [10. , 0.35999722],\n", " [11. , 0.87544608],\n", " [12. , 0.22143994],\n", " [13. , 0.02629711],\n", " [14. , 0.5020551 ]])" ] }, "execution_count": 52, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Selecting from 3rd to 11th row\n", "D[2:10]" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "#### np.concatenate\n", "You can also concadenate different arrays" ] }, { "cell_type": "code", "execution_count": 53, "metadata": { "deletable": true, "editable": true }, "outputs": [], "source": [ "a = np.array([[1, 2], [3, 4]])\n", "b = np.array([[5,6]])" ] }, { "cell_type": "code", "execution_count": 54, "metadata": { "collapsed": false, "deletable": true, "editable": true, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([[1, 2],\n", " [3, 4],\n", " [5, 6]])" ] }, "execution_count": 54, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.concatenate((a,b))" ] }, { "cell_type": "code", "execution_count": 55, "metadata": { "collapsed": false, "deletable": true, "editable": true, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([[1, 2, 5],\n", " [3, 4, 6]])" ] }, "execution_count": 55, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.concatenate((a,b.T), axis=1)" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "### Copy and \"Deep Copy\"\n", "Sometimes it is important to create new _copies_ of arrays and other objects. For this reason, one uses __numpy.copy__ to create _new_ copies of arrays" ] }, { "cell_type": "code", "execution_count": 56, "metadata": { "collapsed": false, "deletable": true, "editable": true, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([[1, 2],\n", " [3, 4]])" ] }, "execution_count": 56, "metadata": {}, "output_type": "execute_result" } ], "source": [ "A = np.array([[1, 2], [3, 4]])\n", "A" ] }, { "cell_type": "code", "execution_count": 57, "metadata": { "deletable": true, "editable": true }, "outputs": [], "source": [ "# `B` is now referring to the same array data as `A`\n", "B = A" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "If we make any changes to `B`, __`A` will also be affected by this change__." ] }, { "cell_type": "code", "execution_count": 58, "metadata": { "collapsed": false, "deletable": true, "editable": true, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([[10, 2],\n", " [ 3, 4]])" ] }, "execution_count": 58, "metadata": {}, "output_type": "execute_result" } ], "source": [ "B[0,0] = 10\n", "B" ] }, { "cell_type": "code", "execution_count": 59, "metadata": { "collapsed": false, "deletable": true, "editable": true, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([[10, 2],\n", " [ 3, 4]])" ] }, "execution_count": 59, "metadata": {}, "output_type": "execute_result" } ], "source": [ "A" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "To get a __completely independent, new object__, you would use:" ] }, { "cell_type": "code", "execution_count": 60, "metadata": { "collapsed": false, "deletable": true, "editable": true, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([[-5, 2],\n", " [ 3, 4]])" ] }, "execution_count": 60, "metadata": {}, "output_type": "execute_result" } ], "source": [ "B = np.copy(A)\n", "\n", "# Modifying `B`\n", "B[0,0] = -5\n", "B" ] }, { "cell_type": "code", "execution_count": 61, "metadata": { "collapsed": false, "deletable": true, "editable": true, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([[10, 2],\n", " [ 3, 4]])" ] }, "execution_count": 61, "metadata": {}, "output_type": "execute_result" } ], "source": [ "A" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "The array `A` was not affected by this changed. This is important when you're constantly re-defining new arrays" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "# Scipy - Library of Scientific Algorithms for Python" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "`SciPy` provides a large number of higher-level scientif algorithms.\n", "It includes:\n", "- Special Functions\n", "- Integration\n", "- Optimization\n", "- Interpolation\n", "- Fourier Transforms\n", "- Signal Processing\n", "- Linear Algebra\n", "- Statistics\n", "- Multi-dimensional image processing" ] }, { "cell_type": "code", "execution_count": 62, "metadata": { "deletable": true, "editable": true }, "outputs": [], "source": [ "import scipy as sc" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "## Interpolation\n", "You can use `Scipy` to interpolate your data.\n", "You would use the `interp1d` function to interpolate your function." ] }, { "cell_type": "code", "execution_count": 63, "metadata": { "deletable": true, "editable": true }, "outputs": [], "source": [ "from scipy.interpolate import interp1d" ] }, { "cell_type": "code", "execution_count": 64, "metadata": { "deletable": true, "editable": true }, "outputs": [], "source": [ "def f(x):\n", " return np.sin(x)" ] }, { "cell_type": "code", "execution_count": 65, "metadata": { "deletable": true, "editable": true }, "outputs": [], "source": [ "n = np.arange(0, 10) \n", "x = np.linspace(0, 9, 100)\n", "\n", "y_meas = f(n) + 0.1 * np.random.randn(len(n)) # simulate measurement with noise\n", "y_real = f(x)\n", "\n", "linear_interpolation = interp1d(n, y_meas)\n", "y_interp1 = linear_interpolation(x)\n", "\n", "cubic_interpolation = interp1d(n, y_meas, kind='cubic')\n", "y_interp2 = cubic_interpolation(x)" ] }, { "cell_type": "code", "execution_count": 66, "metadata": { "collapsed": false, "deletable": true, "editable": true, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "fig, ax = plt.subplots(figsize=(15,6))\n", "ax.set_facecolor('white')\n", "ax.plot(n, y_meas, 'bs', label='noisy data')\n", "ax.plot(x, y_real, 'k', lw=2, label='true function')\n", "ax.plot(x, y_interp1, 'r', label='linear interp')\n", "ax.plot(x, y_interp2, 'g', label='cubic interp')\n", "ax.legend(loc=3, prop={'size':20});\n", "ax.tick_params(axis='both', which='major', labelsize=20)\n", "ax.tick_params(axis='both', which='minor', labelsize=15)" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "### KD-Trees\n", "You can also use `SciPy` to calculate __KD-Trees__ for a set of points" ] }, { "cell_type": "code", "execution_count": 67, "metadata": { "collapsed": false, "deletable": true, "editable": true, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([[ 4.91677843, 203.53330277, 100.85634333],\n", " [ 42.6545178 , 82.63566177, 228.99066071],\n", " [232.5314 , 180.79608431, 95.0066412 ],\n", " ...,\n", " [ 76.65226267, 207.95240739, 30.11950574],\n", " [224.58498597, 221.71205368, 242.40314917],\n", " [ 30.36547633, 148.94184928, 144.29214812]])" ] }, "execution_count": 67, "metadata": {}, "output_type": "execute_result" } ], "source": [ "Lbox = 250.\n", "Npts = 1000\n", "# Creating cartesian coordinates\n", "x = np.random.uniform(0, Lbox, Npts)\n", "y = np.random.uniform(0, Lbox, Npts)\n", "z = np.random.uniform(0, Lbox, Npts)\n", "sample1 = np.vstack([x, y, z]).T\n", "sample1" ] }, { "cell_type": "code", "execution_count": 68, "metadata": { "collapsed": false, "deletable": true, "editable": true, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "(1000, 3)" ] }, "execution_count": 68, "metadata": {}, "output_type": "execute_result" } ], "source": [ "sample1.shape" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "Let's say we want to know how many points are within distances of 30 and 50 from other points. To know this, you construct a __KD-Tree__" ] }, { "cell_type": "code", "execution_count": 69, "metadata": { "deletable": true, "editable": true }, "outputs": [], "source": [ "from scipy.spatial import cKDTree" ] }, { "cell_type": "code", "execution_count": 70, "metadata": { "collapsed": false, "deletable": true, "editable": true, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [ "# Initializing KDTree\n", "KD_obj = cKDTree(sample1)" ] }, { "cell_type": "code", "execution_count": 71, "metadata": { "collapsed": false, "deletable": true, "editable": true, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Number of Neighbours: 20536\n" ] } ], "source": [ "N_neighbours = cKDTree.count_neighbors(KD_obj, KD_obj, 50) - \\\n", " cKDTree.count_neighbors(KD_obj, KD_obj, 30)\n", "print(\"Number of Neighbours: {0}\".format(N_neighbours))" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "Let's say you want to get the distances to the __Nth-nearest__ neighbor." ] }, { "cell_type": "code", "execution_count": 72, "metadata": { "collapsed": false, "deletable": true, "editable": true, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([[ 0. , 14.1577149 , 20.28848924, 22.1680788 ],\n", " [ 0. , 12.88549073, 17.92327564, 18.42130936],\n", " [ 0. , 17.05682145, 18.37226707, 25.92539045],\n", " ...,\n", " [ 0. , 17.95350521, 20.41909125, 22.79189467],\n", " [ 0. , 18.57945774, 22.80480635, 29.61321934],\n", " [ 0. , 12.66943781, 21.47467022, 27.36415359]])" ] }, "execution_count": 72, "metadata": {}, "output_type": "execute_result" } ], "source": [ "k_nearest = 4\n", "dist_k, dist_k_idx = cKDTree.query(KD_obj, sample1, k_nearest)\n", "dist_k" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "You can also get the indices" ] }, { "cell_type": "code", "execution_count": 73, "metadata": { "collapsed": false, "deletable": true, "editable": true, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([[ 0, 38, 553, 113],\n", " [ 1, 151, 855, 541],\n", " [ 2, 212, 37, 40],\n", " ...,\n", " [997, 317, 886, 688],\n", " [998, 357, 844, 163],\n", " [999, 691, 928, 497]])" ] }, "execution_count": 73, "metadata": {}, "output_type": "execute_result" } ], "source": [ "dist_k_idx" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "The first columns corresponds to _itself_." ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "You can also find pairs that are separated by at most a distance _r_" ] }, { "cell_type": "code", "execution_count": 74, "metadata": { "collapsed": false, "deletable": true, "editable": true, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "[[0, 38, 113, 306, 526, 553, 762, 856, 946],\n", " [1, 151, 541, 552, 565, 583, 855],\n", " [2, 37, 40, 212, 561, 567, 653, 742],\n", " [3, 5, 18, 102, 342, 480, 513, 570, 618],\n", " [4, 75, 109, 207, 311, 864],\n", " [3, 5, 18, 342, 480, 513, 570, 922],\n", " [6, 323, 543, 617, 638, 655, 675, 686, 842, 873, 905, 964],\n", " [7, 112, 229, 248, 440, 463, 506, 615, 865, 927],\n", " [8, 205, 275, 296, 420, 486, 589, 636, 737, 839],\n", " [9, 719, 949]]" ] }, "execution_count": 74, "metadata": {}, "output_type": "execute_result" } ], "source": [ "pairs = KD_obj.query_ball_tree(KD_obj, 30)\n", "pairs[0:10]" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "__So that's it for today's lesson__" ] }, { "cell_type": "markdown", "metadata": { "deletable": true, "editable": true }, "source": [ "# Next week:\n", "- Advanced Visualization\n", "- Seaborn" ] } ], "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.7.3" } }, "nbformat": 4, "nbformat_minor": 4 }