Introduction.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "title: Introduction to Python for the practicing neuroscientist\n",
    "project:\n",
    "  type: website\n",
    "format:\n",
    "  html:\n",
    "    code-fold: true\n",
    "    code-tools: true\n",
    "jupyter: python 3\n",
    "number-sections: false\n",
    "filters:\n",
    "    - pyodide\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To be frank:  this notebook is rather boring.  In this class, we will use the software package <a href=\"https://www.python.org/\" rel=\"external\">Python</a>. The best way to learn new software (and probably most things) is when motivated by a particular problem.  Would you read assembly instructions for furniture you do not plan to own?  Probably not. In other notebooks we will pursue specific questions driven by neuronal data, and use our desire to understand these data to motivate the development and application of computational methods.  But not in this notebook.  Here, we focus on basic coding techniques and principles in Python in the abstract, without motivation.  You - poor learner - must trust that these ideas and techniques will eventually be useful.  We begin by dipping our toe into the Python pool, and learning the basic strokes;  the fun and interesting parts in the \"real world\" of neuronal data happen later."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us delay no further.  In the following examples, you are asked to execute code in Python.  If your Python experience is limited, you should actually *do* this, not just read the text below.  If you intend to ignore this advice - and not execute the code in Python - then instead walk to the local coffee shop, get a double espresso, and return to attempt these examples.\n",
    "\n",
    "This notebook follows in spirit and sometimes in detail notebook 2 of <a href=\"https://www.elsevier.com/books/matlab-for-neuroscientists/wallisch/978-0-12-383836-0\" rel=\"external\">MATLAB for Neuroscientists</a>, an excellent reference for learning to use MATLAB in neuroscience with many additional examples.  If you have not used Python before, there are many excellent resources online (e.g., the <a href=\"https://jakevdp.github.io/PythonDataScienceHandbook/\" rel=\"external\">Python Data Science Handbook</a>)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Starting Python\n",
    "\n",
    "There are two ways to interact with this notebook.  First, you could run it locally on your own computer using <a href=\"https://jupyter.org/\" rel=\"external\">Jupyter</a>. This is an excellent choice, because you'll be able to read, edit, and excute the Python code directly and you can save any changes you make or notes that you want to record.  The second way is to open this notebook in your browser and execute the examples directly in your browser, without installing additional software on your computer. In any case, we encourage you to execute each line of code in this file!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "::: {.callout-note}\n",
    "Throughout this notebook, we assume that you are running <a href=\"https://www.python.org/download/releases/3.0/\" rel=\"external\">Python 3</a>. Most of the functions used here are the same in Python 2 and 3. One noteable exception however is division. If you are using Python 2, you will find that the division operator `/` actually computes the *floor* of the division if both operands are integers (i.e., no decimal points). For example, in Python 2, `4/3` equals `1`. While, in Python 3, `4/3` equals `1.333`.\n",
    "\n",
    "We encourage you to use Python 3 for the sake of compatibility with this notebook, as well as for compatibility with future releases of Python.\n",
    ":::"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### On-ramp: analysis of neural data in Python\n",
    "We begin this notebook with an \"*on-ramp*\" to analysis in Python. The purpose of this on-ramp is to introduce you immediately to some aspects of Python. You may not understand all aspects of the Python language here, but that's not the point. Instead, the purpose of this on-ramp is to  illustrate what *can* be done. Our advice is to simply run the code below and see what happens..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{pyodide-python}\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "\n",
    "df = pd.read_csv(\"https://raw.githubusercontent.com/Mark-Kramer/BU-MA665-MA666/master/Data/Rhythms_1.csv\")\n",
    "d = np.array(df.iloc[:,0])\n",
    "t = np.array(df.iloc[:,1])\n",
    "\n",
    "# Print useful information about the data.\n",
    "print(\"Sampling frequency is \" + str( 1/(t[2]-t[1]))  + ' Hz.')\n",
    "print(\"Total duration of recording is \" + str(t[-1]) + ' s.')\n",
    "print(\"Dimensions of data are \" + str(np.shape(d)) + ' data points.')\n",
    "\n",
    "# Choose an initial interval of time, from onset to 5 s,\n",
    "initial_time_interval = t < 5        \n",
    "\n",
    "# ... and plot it.\n",
    "plt.plot(t[initial_time_interval], d[initial_time_interval])\n",
    "plt.xlabel('Time [s]')\n",
    "plt.ylabel('Data')\n",
    "plt.title('Initial interval of data');\n",
    "plt.show()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "::: {.callout}\n",
    "**Q:** Try to read the code above. Can you see how it loads data, extracts useful information to print, then selects an interval of data to plot?\n",
    "\n",
    "**A:** If you've never used Python before, that's an especially difficult question. Please continue on to learn more!\n",
    ":::"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example 1: Python is a calculator\n",
    "\n",
    "Execute the following commands in Python:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{pyodide-python}\n",
    "4+9\n",
    "````"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{pyodide-python}\n",
    "4/3\n",
    "````"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "::: {.callout}\n",
    "**Q:**  What does Python return?  Does it make sense?\n",
    "::::"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example 2.  Python can compute complicated quantities.\n",
    "\n",
    "Enter the following command in Python:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{pyodide-python}\n",
    "4/10**2\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "::: {.callout}\n",
    "**Q:** Does this answer make sense?\n",
    ":::"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "::: {.callout}\n",
    "**Q:** Can you use parentheses to change the answer?\n",
    ":::"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Example 3.  Python has useful built in functions.\n",
    "\n",
    "A function is a program that operates on arguments. Standard math functions and variables (and other useful things) can be accessed from the `math` and `numpy` modules. To use the `math` and `numpy` modules, we must first import both:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{pyodide-python}\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import math\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "::: {.callout-note}\n",
    "In this style, we indicate which module, or *namespace*, contains the function we want to call: `x = np.arange(10)` or `plt.plot(x, y)`.\n",
    ":::"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You will often begin your data analysis with `import` statements, to load the functionality you need. We can now call functions from math using `numpy.*`.  For example,"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{pyodide-python}\n",
    "np.sin(2*np.pi)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Above, `sin` is the sine function.  It operates on the argument `2*pi`.  Notice that, once we have imported the `numpy` module, Python knows the value of `pi`. Here's another example function that operates on arguments:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{pyodide-python}\n",
    "math.atan(2*np.pi)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "::: {.callout}\n",
    "**Q:**  What is `math.atan`?\n",
    "\n",
    "**A:** To answer this, try using Python Help.  To start the Python Help, simply put a `?` at the end of `math.atan` and then run this code block. \n",
    ":::"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "math.atan?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You should see a description of the function pop up at the bottom of the window."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "::: {.callout-note}\n",
    "Python Help is *extremely* useful, but may not work in a web browser.  You can always look there when you have questions about a function, or search the internet for help, i.e., <a href=\"http://www.google.com\" rel=\"external\">google it</a>.\n",
    ":::"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Example 4.  We can use Python to define lists of numbers.\n",
    "\n",
    "In Python, there are several different data structures that are designed to store more than one element. Here we will focus on the `array` data structure, but if you are curious to know how and when to use other structures, there is a good explanation <a href='http://www.physics.nyu.edu/pine/pymanual/html/chap3/chap3_arrays.html'>here</a>. Let's define an array:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{pyodide-python}\n",
    "import numpy as np\n",
    "a = np.array([[1, 2, 3, 4]])\n",
    "print(a)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Example 5.  We can manipulate arrays by scalars.\n",
    "\n",
    "A scalar is a single number.  Consider,"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{pyodide-python}\n",
    "a = np.array( [[1, 2, 3, 4]] )\n",
    "print( a * 3 )\n",
    "print( 4 * a )\n",
    "print( a + 1 )\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "::: {.callout}    \n",
    "**Q:** What do you find?\n",
    "\n",
    "**A:** Notice that the scalar operates on each element of the array.\n",
    ":::"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Example 6.  We can manipulate arrays with arrays. \n",
    "\n",
    "Let's create an array and multiply it by itself,"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{pyodide-python}\n",
    "import numpy as np\n",
    "a = np.array([1,2,3,4])\n",
    "a * a\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "::: {.callout}\n",
    "**Q:**  What does this return?\n",
    "\n",
    "**A:** We see that the operator `*` performs element-by-element multiplication of the values in array `a`.\n",
    ":::"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example 7. More examples of manipulating arrays with arrays."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{pyodide-python}\n",
    "import numpy as np\n",
    "a = 2\n",
    "b = np.array( [[0, 4, 7, 6]] )\n",
    "c = np.array( [[1, 5, 6, 8]] )\n",
    "\n",
    "print( b * c )\n",
    "print( b / c + a)\n",
    "print( np.multiply( b, c ))\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "::: {.callout}\n",
    "**Q:** What operation does `np.multiply()` perform?\n",
    ":::"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example 8.  We can probe the variables we've defined in Python.\n",
    "\n",
    "To see a list of the variables you've defined, type `who` or `whos` in a code block by themselves. Notice `whos` provides more information."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Interactive namespace is empty.\n"
     ]
    }
   ],
   "source": [
    "who"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Interactive namespace is empty.\n"
     ]
    }
   ],
   "source": [
    "whos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "::: {.callout-note}\n",
    "The functions `who` and `whos` can be *extremely* useful, but may not work in a web browser.\n",
    ":::"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example 9.  Determine the dimensions of an array\n",
    "\n",
    "To examine the dimensions of an array, we can ask for the `shape`,"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{pyodide-python}\n",
    "a = np.array([[1,2,3,4]])\n",
    "print(a.shape)\n",
    "print(np.shape(a))\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We find that the shape of `a` is `(1,4)` or 1 row and 4 columns. Notice we have two options to execute the `shape` function:\n",
    "\n",
    "- In `a.shape` we return the attribute `shape` of the variable `a`. \n",
    "\n",
    "- In `np.shape(a)` we apply the function `shape` from `numpy` to the variable `a`.\n",
    "\n",
    "The result is equivalent."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example 10. Sometimes we need to reset the workspace\n",
    "\n",
    "By doing so, we get rid of all the variables. To do so, type `%reset` and enter `y`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%reset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "::: {.callout}\n",
    "**Q.** What command could we use to confirm there are no variables in the workspace?\n",
    "\n",
    "**A.** Consider `who`.\n",
    ":::"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "who"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "::: {.callout-note}   \n",
    "The `%reset` command is an example of a *magic*. Magics are commands that start with the `%` symbol and use a language other than Python. They are only available in the notebook environment. In fact, the set of magics that is available is specific to the notebook kernel. This means that if you have a Jupyter notebook running a Ruby kernel the magics will be different.\n",
    ":::"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Example 11.  We can define matrices in Python.\n",
    "A matrix is an array with more than one dimensio.  Consider the following:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{pyodide-python}\n",
    "import numpy as np\n",
    "\n",
    "p = np.array( [[1,2,3],[4,5,6]] )\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This creates a matrix with two rows and three columns. Consider,"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{pyodide-python}\n",
    "print( p )\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "::: {.callout}\n",
    "**Q:** Can you see the two rows and three columns?\n",
    ":::"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can manipulate matrices like we manipulate vectors."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{pyodide-python}\n",
    "print( p + 2 )\n",
    "print( 2 * p )\n",
    "print( p * p )\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Example 12.  Indexing matrices and vectors.\n",
    "Matrices and vectors are arrays of numbers, and sometimes we want to\n",
    "access individual elements or small subsets of these lists.  That's\n",
    "easy to do in Python.  Consider,"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{pyodide-python}\n",
    "import numpy as np\n",
    "a = np.array( [1, 2, 3, 4, 5] )\n",
    "b = np.array( [6, 7, 8, 9, 10] )\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " Python indexes from 0 (like C, C++, Java, and unlike MATLAB and Fortran which start at 1). \n",
    " To access the 2nd element of `a` or `b`, type `a[1] / b[1]`.\n",
    " We'll be a bit fancier with our printing now to distinguish variables. \n",
    " Calling `str(a)` converts the variable `a` to a string that can be printed easily.\n",
    " Adding two strings just concatenates them: `\"hi\" + \" bye\" = \"hi bye\". `"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{pyodide-python}\n",
    "print( \"a[1] = \" + str(a[1]) )\n",
    "print( \"b[1] = \" + str(b[1]) )\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "::: {.callout}    \n",
    "**Q.**  Do the results make sense?  How would you access the 4th element of each vector?\n",
    ":::"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "  We can combine `a` and `b` to form a matrix with `a` as the first row and `b` as the second.\n",
    "  Note that we apply the function `array()` to the *list* `[a,b]`, which it converts to a matrix."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{pyodide-python}\n",
    "c = np.array([a,b])\n",
    "print( \"c = \\n\" + str(c) )    # \\n is a newline, or carriage return, which makes the printed matrix lineup better \n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "  To learn the size (or shape)\n",
    " of `c` we use `shape()`:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{pyodide-python}\n",
    "print( \"shape of c = \" + str( np.shape(c) ) )\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "  The shape of `c` is `[2 5]`.  It has two rows and five columns.  To access\n",
    "  the individual element in the 1st row and 4th column of `c`, type `c[0,3]`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{pyodide-python}\n",
    "print( \"c[0,3] = \" + str( c[0,3] ) )\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"python-note\">\n",
    "    \n",
    "We access matrices using 'row, column' notation.  So `c[0,3]` means\n",
    "print the element in row 0, column 3 of `c`.\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "::: {.callout}\n",
    "**Q.**  How would you print all rows in the 2nd column of `c`?\n",
    ":::"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Example 13:  We can find subsets of elements in matrices and vectors.\n",
    "Often we are interested in only some of the elements of a matrix or vector. For example, we might want to look at the data from a single experimental trial which is stored in a particular row of a matrix. Alternatively, we might want to find out when the values in a time series cross a given boundary. Doing this is simple in Python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Slicing\n",
    "*Slicing* means that we want to look at a specific portion of a vector or matrix, for example, the first row of a matrix. We will continue with the matrix `c` from the previous example. The notation '`:`' means '*all indices*'. To access all columns in the entire first row of `c`, type `c[0,:]`. To access the 2nd thru 4th columns of the first row of `c`, type `c[0,1:4]`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{pyodide-python}\n",
    "print( \"c[0,:] = \" + str( c[0,:] ) )\n",
    "print( \"2nd through 4th columns of the first row are c[0,1:4] = \" + str(c[0,1:4]) )\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "  <div class=\"python-note\">\n",
    "    \n",
    "  The notation `1:4` means *all integers from 1 up to, but not including 4*, \n",
    "  which in this case gives columns 1, 2, and 3. \n",
    "  \n",
    "  </div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Leaving out the number before the colon tells Python to start at index 0. Leaving out the number after the colon tells Python to continue all the way to the end."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{pyodide-python}\n",
    "print(\"c[0, :4] = \" + str( c[0,:4]))\n",
    "print(\"c[0, 1:] = \" + str( c[0,1:]))\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also tell Python how to step through the indices. To access only the even columns of `c`, we can use the following:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{pyodide-python}\n",
    "c[0,::2]\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This code tells Python to start at 0, continue to the end, and step by 2. The result should be the values in row 0, columns 0, 2, and 4 of `c`. We could write this explicitly as `c[0,0:5:2]`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "  #### Selecting elements that satisfy a condition\n",
    "  Sometimes we're interested in locating particular values within a\n",
    "  matrix or vector.  As an example, let's first define a vector."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{pyodide-python}\n",
    "a = np.arange(1,10)    # this creates a vector of increasing values from 1 to 9\n",
    "a = 2*a \n",
    "\n",
    "print( \"a = \" + str(a) )\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "::: {.callout}\n",
    "**Q.**  Calculate the shape of `a`.  What is the maximum value of `a`? \n",
    "*Hint:* Use the `max()` function.\n",
    ":::"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "  Now let's find all values in `a` that exceed 10."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{pyodide-python}\n",
    "a[a > 10]\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is called logical indexing, let's look at what `a>10` returns:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{pyodide-python}\n",
    "lgIdx = a > 10\n",
    "lgIdx\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When we index `a` using this array `lgIdx` we get back only the entries \n",
    "in `a` corresponding to `True`, as above:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{pyodide-python}\n",
    "a[lgIdx]\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes we want to know the actual indices in a where `a > 10`.\n",
    "We can get them using the `nonzero()` array method, which returns the\n",
    "index of all entries that were `True`, or non-zero."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{pyodide-python}\n",
    "lgIdx.nonzero()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"python-note\">\n",
    "    \n",
    "The command `nonzero()` can be used as both a *function* and a *method*. A method is called by adding it after the object it is meant to operate on with a period in between ( `lgIdx.nonzero()` ). A function is called with the *argument* explicitly provided inside the parentheses ( `nonzero(lgIdx)` ). Basically, a function and a method do the same thing, but a function needs to be given an argument, while a method assumes that the argument is the object that the method is attached to. Note that if we use `nonzero()` as a function, we need to tell it to look in NumPy for the definition (i.e. add `` at the beginning of the function call). \n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we have another way to select the desired elements of `a`:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{pyodide-python}\n",
    "a[ (a > 10).nonzero() ]\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use these two types of indexing to change subsets of the values of `a`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{pyodide-python}\n",
    "print(\"a = \" + str(a))\n",
    "a[a > 10] = 100\n",
    "print(\"a = \" + str(a))\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "::: {.callout}\n",
    "**Q:** How does `a` change in the first and second print statements?\n",
    ":::"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can perform these same logical operations for a matrix,"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{pyodide-python}\n",
    "b = np.array([[1,2,3],[4,5,6],[7,8,9]])\n",
    "print( \"b = \\n\" + str(b) )\n",
    "print( \" b > 5 is \\n\" + str(b > 5) )\n",
    "print(\" b[b>5] is an array: \" + str(b[b>5]) )\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"python-note\">\n",
    "    \n",
    "Notice that the last line collapses the `True` entries to an array, \n",
    "ordered by row and then by column. If you've used MATLAB, this is \n",
    "the opposite of what it does!\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Example 14:  Plotting data in Python.\n",
    "It's not easy to look at lists of numbers and gain an intuitive\n",
    "feeling for their behavior, especially when the lists are long.  In\n",
    "these cases, it's better to visualize the lists of numbers by\n",
    "plotting them.  Consider"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{pyodide-python}\n",
    "import numpy as np\n",
    "\n",
    "x = np.linspace(0,10,11)   \n",
    "print( \"x = \" + str(x) )\n",
    "\n",
    "#   The above line constructs a vector that starts at 0, ends at 10, and\n",
    "#   has 11 entries (takes steps of size 1 from 0 to 10). Let\n",
    "\n",
    "y = np.sin(x)\n",
    "print( \"y = \" + str(y) )\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "::: {.callout}\n",
    "**Q.** Looking at the values in 'y' printed above, can you tell what's happending?\n",
    "\n",
    "**A.** Not really ... let's visualize `y` vs `x` instead.\n",
    ":::"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### matplotlib\n",
    "To visualize `y` versus `x` let's plot it. To do so, let's first import some basic plotting routines from `matplotlib`, which provides a nice <a href=\"https://matplotlib.org/\" rel=\"external\">2D plotting library</a>. We'll also tell Python to show  `matplotlib` graphics inline, in this notebook.\n",
    "\n",
    "Let's start by plotting a simple example for `x` and `y`,"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{pyodide-python}\n",
    "import matplotlib.pyplot as plt\n",
    "x = ([1, 2, 3, 4])\n",
    "y = x\n",
    "plt.figure()\n",
    "plt.plot(x,y) \n",
    "plt.show()          # this is the plotting equivalent of print()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "::: {.callout}\n",
    "**Q.** Does the plot above make sense for the variables `x` and `y`?\n",
    ":::"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let's go back to the definitions of `x` and `y` that we started this example with and plot `y` versus `x`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{pyodide-python}\n",
    "x = np.linspace(0,10,11)   \n",
    "y = np.sin(x)\n",
    "\n",
    "plt.figure()\n",
    "plt.plot(x, y)\n",
    "plt.show()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " The plot of `x` versus `y` should look a bit jagged, and not \n",
    " smooth like a sinusoid.  To make the curve smoother,\n",
    " let's redefine `x` as,"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{pyodide-python}\n",
    "import numpy as np\n",
    "x = np.linspace(0,10, 101)\n",
    "print(x)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "::: {.callout}\n",
    "**Q.**  Compare this definition of `x` to the definition above.  How do these\n",
    "two definitions differ?\n",
    ":::"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "::: {.callout}    \n",
    "**Q.**  What is the size of `x`?  Does this make sense?\n",
    ":::"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's replot the sine function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{pyodide-python}\n",
    "y = np.sin(x)\n",
    "plt.figure()\n",
    "plt.plot(x,y,'k')   # the 'k' we've added makes the curve black instead of blue\n",
    "plt.show()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "::: {.callout}\n",
    "**Q.** Does this plot make sense, given your knowledge of `x`, `y`, and trigonometry?\n",
    ":::"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example 15: What if we want to compare several functions?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Continuing the example in the previous section, let’s define a second vector"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{pyodide-python}\n",
    "import numpy as np\n",
    "x = np.linspace(0,10, 101)\n",
    "z = np.cos(x)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and plot it:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{pyodide-python}\n",
    "import matplotlib.pyplot as plt\n",
    "plt.figure()\n",
    "plt.plot(x,z)\n",
    "plt.show()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We’d now like to compare the two variables `y` and `z`. To do this, let’s plot both vectors on\n",
    "the same figure, label the axes, and provide a legend,"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{pyodide-python}\n",
    "y = np.sin(x)\n",
    "plt.figure()\n",
    "plt.plot(x,z)                     # plot z vs x.\n",
    "plt.plot(x,y,'r')                 # plot y vs x in red\n",
    "plt.show()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that we’ve included a third input to the function `plot`. Here the third input tells Python to draw the curve in a particular color: `'r'` for red. There are many options we can use to plot; to see more, check out the documentation for <a href=\"https://matplotlib.org/api/_as_gen/matplotlib.pyplot.plot.html\" rel=\"external\">plot</a>.\n",
    "\n",
    "We can also label the axes, give the figure a title, and provide a legend,"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{pyodide-python}\n",
    "plt.figure()\n",
    "plt.plot(x,z)                     # plot z vs x\n",
    "plt.plot(x,y,'r')                 # plot y vs x in red\n",
    "plt.xlabel('x')                   # x-axis label\n",
    "plt.ylabel('y or z')              # y-axis label\n",
    "plt.title('y vs x and z vs x')    # title\n",
    "plt.legend(('y','z'))             # make a legend labeling each line\n",
    "plt.show()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To futher edit this plot, you might decide - for example - that the font size for the labels is too small. We can change the default with:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{pyodide-python}\n",
    "plt.figure()\n",
    "plt.plot(x,y, label='y')     # sometimes it is easier to name a trace within the plot() call\n",
    "plt.plot(x,z, label='z')     # notice without a color matplotlib will assign one\n",
    "plt.xlabel('x', fontsize=14)\n",
    "plt.ylabel('y', fontsize=14)\n",
    "plt.title('y vs x', fontsize=18)\n",
    "plt.legend(fontsize=12)\n",
    "plt.show()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Example 16:  We can make random numbers in Python.\n",
    "To generate a single Gaussian random number in Python, use the function in the NumPy `random` module."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{pyodide-python}\n",
    "import numpy as np\n",
    "\n",
    "print(\"a Gaussian random number (mean=0, variance=1): \" + str( np.random.randn() ))\n",
    "\n",
    "# a uniform random number on [0,1)\n",
    "print(\"a uniform random number from [0,1): \" + str(np.random.rand()))\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's generate a vector of 1000 Gaussian random numbers:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{pyodide-python}\n",
    "r = np.random.randn(1000)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "... and look at a histogram of the vector:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{pyodide-python}\n",
    "import matplotlib.pyplot as plt\n",
    "plt.figure()\n",
    "plt.hist(r)\n",
    "plt.show()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "::: {.callout}\n",
    "**Q.** Does this histogram make sense? Is it what you expect for a distribution of Gaussian random variables?\n",
    ":::"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"python-note\">\n",
    "    \n",
    "See Python Help (`hist?`) to learn about the function `hist()`.\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Example 17:  Repeating commands over and over and over . . . \n",
    "  Sometimes we'll want to repeat the same command over and over again.\n",
    "  For example, what if we want to plot `sin(x + k*pi/4)` where `k` varies from 1 to 5 in\n",
    "  steps of 1;  how do we do it?  Consider the following:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{pyodide-python}\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "x = np.arange(0,10,0.1) # Define a vector x that ranges from 0 to 9.9 with step 0.1.\n",
    "k = 1                # Fix k=1,\n",
    "y = np.sin(x + k*np.pi/4)  # ... and define y at this k.\n",
    "\n",
    "plt.figure()               # Make a new figure,\n",
    "plt.plot(x,y)              # ... and plot y versus x.\n",
    "\n",
    "k = 2                # Let's repeat this, for k=2,\n",
    "y = np.sin(x + k*np.pi/4)  # ... and redefine y at this k,\n",
    "plt.plot(x,y)              # ... and plot it.\n",
    "\n",
    "k = 3                      # Let's repeat this, for k=3,\n",
    "y = np.sin(x + k*np.pi/4)  # ... and redefine y at this k,\n",
    "plt.plot(x,y)              # ... and plot it.\n",
    "\n",
    "k = 4                      # Let's repeat this, for k=4,\n",
    "y = np.sin(x + k*np.pi/4)  # ... and redefine y at this k,\n",
    "plt.plot(x,y)              # ... and plot it.\n",
    "\n",
    "k = 5                      # Let's repeat this, for k=5,\n",
    "y = np.sin(x + k*np.pi/4)  # ... and redefine y at this k,\n",
    "plt.plot(x,y)              # ... and plot it.\n",
    "\n",
    "plt.show()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That's horrible code!  All I did was cut and paste the same thing four times.  As a general rule, if you're repeatedly cutting and pasting in code, what you're doing is inefficient and typically error prone.  There's a much more elegant way to do this, and it involves making a `for` loop.  Consider:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{pyodide-python}\n",
    "x = np.arange(0,10,0.1)     #First, define the vector x.\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's declare a `for` loop where `k` successively takes the values 1, then 2, then 3, ..., up to 5. Note, any code we want to execute as part of the loop must be indented one level. The first line of code that is not indented, in this case `show()` below, executes after the for loop completes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{pyodide-python}\n",
    "plt.figure()\n",
    "for k in range(1,6):               \n",
    "    y = np.sin(x + k*np.pi/4) #Define y (note the variable 'k' in sin), also note we have indented here!\n",
    "    plt.plot(x,y)             #Plot y versus x\n",
    "     \n",
    "# no indentation now, so this code follows the loop\n",
    "plt.show()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The small section of code above replaces all the cutting-and-pasting.\n",
    "  Instead of cutting and pasting, we update the definition of `y` with different values of `k` and plot it within this for-loop."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "::: {.callout}\n",
    "**Q.**  Spend some time studying this for-loop.  Does it make sense?\n",
    ":::"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "::: {.callout-note}   \n",
    "**Important:** Python uses **indentation** to define `for` loops.\n",
    ":::"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Example 18:  Defining a new function.\n",
    "We've spent some time in this notebook writing and executing code. Sometimes we'll need to write our own Python functions.  Let's do that now.\n",
    "\n",
    "Our function will do something very simple: it will take as input a\n",
    "vector and return as output the vector elements squared plus an additive\n",
    "constant.\n",
    "\n",
    "If have a vector, `v`, and a constant, `b`, we would like to call:\n",
    "\n",
    "    vsq = my_square_function(v, b)\n",
    "    \n",
    "This won't work!  We first need to define `my_square_function`. Let's do so now,"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{pyodide-python}\n",
    "def my_square_function(x, c):\n",
    "    \"\"\"Square a vector and add a constant.\n",
    "\n",
    "    Arguments:\n",
    "    x -- vector to square\n",
    "    c -- constant to add to the square of x\n",
    "    \n",
    "    Returns:\n",
    "    x*x + c\n",
    "    \"\"\"\n",
    "    \n",
    "    return x * x + c\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The function begins with the keyword `def` followed by the function name and the inputs in parentheses. Notice that this first line ends with a colon `:`. All of the function components that follow this first line should be **indented one level**. This is just like the `for` loop we applied earlier; the operations performed by the for loop were indented one leve."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"python-note\">\n",
    "    \n",
    "When defining the function, the code the function executes should be indented one level.\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The text inside triple quotes provides an optional documentation string that describes our function. While optional, including a '*doc string*' is an important part of making your code understandable and reuseable.\n",
    "\n",
    "The keyword `return` exits the function, and in this case returns the expression `x * x + c`. Note that a return statement with no arguments returns `None`, indicating the absence of a value.\n",
    "\n",
    "With the function defined, let's now call it. To do so we first define the inputs, and then run the function, as follows:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{pyodide-python}\n",
    "import numpy as np\n",
    "v = np.linspace(0.,10.,11)\n",
    "b = 2.5\n",
    "\n",
    "# Now let's run the code,\n",
    "v2 = my_square_function(v, b)\n",
    "print(\"v = \" + str(v))\n",
    "print(\"v*v+2.5 = \" + str(v2))\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "::: {.callout}\n",
    "**Q.** Try to make a function, my_power, so that \n",
    "`y = power(x,n)` evaluates $y = x^n$, \n",
    "(in Python you can use `x**n` to take the power)\n",
    ":::"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example 19: Load  data into Python\n",
    "For our last example let's load a data file on the web in the `.csv` format into Python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To do so, let's first import the `pandas` module,"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{pyodide-python}\n",
    "import pandas as pd\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let's load a data file using the function `read_csv`,"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{pyodide-python}\n",
    "df = pd.read_csv(\"https://raw.githubusercontent.com/Mark-Kramer/BU-MA665-MA666/master/Data/Rhythms_1.csv\")\n",
    "df.info()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The variable `df` that holds the loaded data is a Python [DataFrame](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.html). We can think of it as a simple table that holds our data.\n",
    "\n",
    "Let's print it,"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{pyodide-python}\n",
    "print(df)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see that the columns in the dataframe consist of two variables: `d` and `t`. Our collaborator who provided the data tells us that these correspond to the voltage recording (`d`) and a time axis (`t`) for her data.\n",
    "\n",
    "Let's define variables to hold the data corresponding to each key,"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{pyodide-python}\n",
    "import numpy as np\n",
    "d = np.array(df.iloc[:,0])  #Get the values associated with the first column of the dataframe\n",
    "t = np.array(df.iloc[:,1])  #Get the values associated with the first column of the dataframe\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "::: {.callout-note}\n",
    "Here we convert the data in each column to a numpy array, because we'd (probably) like numpy to function on these values.\n",
    ":::"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let's plot the LFP data versus the time axis,"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{pyodide-python}\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Choose a subset to plot\n",
    "t = t[0:500]\n",
    "d = d[0:500]\n",
    "\n",
    "plt.figure()\n",
    "plt.plot(t, d)\n",
    "plt.title('My plot')\n",
    "plt.xlabel('Time [s]')\n",
    "plt.ylabel('Voltage [mV]')\n",
    "plt.show()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example 20: Compute statistics and compare"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Contributed by [@mateouma](https://github.com/mateouma)\n",
    "\n",
    "Let's do some statistics. First, our standard imports."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{pyodide-python}\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With numpy, we can find the mean and standard deviation of our LFP data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{pyodide-python}\n",
    "mu = np.mean(d)\n",
    "sd = np.std(d)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let's use numpy to randomly generate numbers according to a normal distribution with the same mean and standard deviation as the LFP data. The syntax is `np.random.normal(mean, sd, size)`, where `mean`, `sd`, and `size` are variables or numbers."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{pyodide-python}\n",
    "samps = np.random.normal(mu, sd, 500)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use a histogram to compare the distribution of the data with a normal distribution with the same mean and standard deviation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{pyodide-python}\n",
    "plt.figure()\n",
    "plt.hist(samps)\n",
    "plt.hist(d)\n",
    "plt.show()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we can see, our data doesn't look normally distributed, but in practice we should use a statistical test to make this assessment."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  }
 ],
 "metadata": {
  "jupytext": {
   "formats": "ipynb,md:myst"
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.8.18"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}