{ "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": [ "