math_with_python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "401d8984",
   "metadata": {},
   "source": [
    "## Using python to solve lots of math problems all at once"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ab76727",
   "metadata": {},
   "source": [
    "A python notebook is a great desktop calculator. Lets try it out."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4686f228",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 358.45\n",
    "y = x*24.21\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b6c52a7",
   "metadata": {},
   "source": [
    "#### Exercise 1: Your little sister is gonna pay you 20 dollars to do her math homework. Use the blank cell below to solve the following math problems: a) $\\frac{1047.2}{22.3}$ b) $1.29^{14}$ c) $1.73-3.21$ d) $11.8 \\times 230.4$\n",
    "Bonus: Use google or another search engine to look up the python symbol to raise a number to a power. Even if you already know it, searching online for the answers to coding questions is a key skill!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "45d7a08d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "2c6a8cda",
   "metadata": {},
   "source": [
    "The numpy package is often used for scientific computing-- or solving lots of math problems all at once. Lets try it out! First lets import numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "86ce41f2",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f07b67fe",
   "metadata": {},
   "source": [
    "The numpy functions can now be accessed with the _np_ name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "16fa7432",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 10.42\n",
    "y = np.sqrt(x)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "31914ab9",
   "metadata": {},
   "source": [
    "#### Exercise 2: Your little brother is gonna pay you 30 dollars to do her math homework. Use the blank cell below to solve the following math problems: a) $\\sqrt({1.14})$ b) $\\exp({0.5})$ c) $\\cos({2.0})$ \n",
    "Try to figure out and use the numpy functions: e.g. sin(x) in numpy is np.sin(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0bd51420",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "3627334d",
   "metadata": {},
   "source": [
    "## Arrays\n",
    "To solve a lot of math problems at once, we need _arrays_. Arrays are a type of list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7ae541a3",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.array([  0. ,   0.1,   0.2,   0.3,   0.4,   0.5,   0.6,   0.7,   0.8,\n",
    "         0.9,   1. ,   1.1,   1.2,   1.3,   1.4,   1.5,   1.6,   1.7,\n",
    "         1.8,   1.9,   2., 2.1, 2.2, 2.3, 2.4, 2.5, 2.6, 2.7, 2.8, 2.9, 3.0])\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d77bb02",
   "metadata": {},
   "source": [
    "We can now solve a math problem on the entire array at once. Note the"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6272b814",
   "metadata": {},
   "outputs": [],
   "source": [
    "y = 1.-.5*x**2+.05*x**4\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "90cc2613",
   "metadata": {},
   "source": [
    "Would be great if we could visualize this! For that there is the matplotlib package"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1c3aec2a",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "plt.plot(x,y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d1561a7",
   "metadata": {},
   "source": [
    "#### Excercise 3: Edit the code in the cell below to plot your own choice of mathematical function, over your choice of x-values. \n",
    "You can make polynomials, or search on google for different math functions. Some ideas are np.cos, np.exp, np.abs, ... Can you plot y=np.abs(x) with x an array of 20 values from -1 to 1? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "52a6e27f",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.linspace(-5.,5.,101) #make an array from -5. to 5. with 101 evenly spaced entries\n",
    "y = np.sin(x)\n",
    "plt.plot(x,y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f2388835",
   "metadata": {},
   "source": [
    "### 2D arrays\n",
    "An array can come in many _shapes_."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1e9269ad",
   "metadata": {},
   "outputs": [],
   "source": [
    "Z = np.array([[1.,0.,0.],[0.,1.,0.],[0.,0.,1.]])\n",
    "print(Z)\n",
    "print('Array shape:')\n",
    "print(Z.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b8fd89c",
   "metadata": {},
   "source": [
    "A 2D array is like an image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9dfb63db",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.imshow(Z)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "15d41ad1",
   "metadata": {},
   "source": [
    "#### Excersize 4: Edit the array below and try to play tic-tac-toe against yourself. Re-run the cell each turn to see the results. A blank square is 0, X is 1, and O is 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e0ce9083",
   "metadata": {},
   "outputs": [],
   "source": [
    "Z = np.array([[0,0,0],[0,0,0],[0,0,0]])\n",
    "plt.imshow(Z)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2205ed45",
   "metadata": {},
   "source": [
    "## 2D functions\n",
    "Functions like y=sin(x) also can be defined in 2D"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3cdcf82d",
   "metadata": {},
   "outputs": [],
   "source": [
    "xx = np.linspace(-5.,5.,101) #1D array of x-positions\n",
    "yy = np.linspace(-5.,5.,101) #1D array of y-positions\n",
    "XX,YY = np.meshgrid(xx,yy) #2D arrays of xy coordinates\n",
    "print(XX)\n",
    "print('2D grid shape:')\n",
    "print(XX.shape)\n",
    "plt.scatter(XX.flatten(),YY.flatten(),s=1,c='black',marker='.') #scatter plot of grid points, flatten is used to make the 2D arrays into 1D arrays to show the grid of points\n",
    "ax=plt.gca()\n",
    "ax.axis('equal')\n",
    "plt.xlabel('x')\n",
    "plt.ylabel('y')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b13ef568",
   "metadata": {},
   "source": [
    "We can now evaluate functions over the 2D array of grid points"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c3013d97",
   "metadata": {},
   "outputs": [],
   "source": [
    "Z = np.cos(XX) + np.sin(YY)\n",
    "plt.imshow(Z)\n",
    "ax=plt.gca()\n",
    "ax.axis('equal')\n",
    "plt.axis('off')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8158fa3b",
   "metadata": {},
   "source": [
    "#### Excersize 5: Plot some 2D functions in the cell below. Play the x and y value ranges, different functions, and colors! Search online for functions and colormaps (cm), some colormaps are jet, prism, and gnuplot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "edc4018f",
   "metadata": {},
   "outputs": [],
   "source": [
    "xx = np.linspace(-5.,5.,101) #x-value range\n",
    "yy = np.linspace(-5.,5,101) #y-value range\n",
    "XX,YY = np.meshgrid(xx,yy) #make 2D arrays of x and y gridpoints\n",
    "Z = np.sin(XX) + np.cos(YY) #evaluate functions on the 2D space\n",
    "plt.contourf(XX,YY,Z,cmap=plt.cm.jet) #contour plot of a 2D function\n",
    "ax=plt.gca()\n",
    "ax.axis('equal')\n",
    "plt.xlabel('x')\n",
    "plt.ylabel('y')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6771aa8e",
   "metadata": {},
   "source": [
    "## Complexity from simple rules\n",
    "With just a few more ingredients we can observe very complicated behavior arising out of solving (lots) of simple math problems! This emergence of complexity out of simple rules is fundamental to biology."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d677663",
   "metadata": {},
   "source": [
    "#### Complex numbers\n",
    "A complex number is like a regular number but it obeys a different multiplication rule: Multiply two complex numbers and you get a negative number!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0654df08",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 0. + 1.j #complex number has a real part plus imaginary part (j)\n",
    "print(np.real(x*x))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "118e3599",
   "metadata": {},
   "source": [
    "#### Complex functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5b88b0e5",
   "metadata": {},
   "outputs": [],
   "source": [
    "xx = np.linspace(-2.,2.,101) #x-value range\n",
    "yy = np.linspace(-2.,2,101) #y-value range\n",
    "c = -.4 + 0.6j\n",
    "XX,YY = np.meshgrid(xx,yy) #make 2D arrays of x and y gridpoints\n",
    "Z = XX+YY*1.j #evaluate functions on the 2D space\n",
    "Z = Z*Z+c\n",
    "levels=np.linspace(-4,1,20)\n",
    "plt.contourf(XX,YY,np.abs(Z),cmap=plt.cm.prism,levels=levels) #we look at the absolute value of z to combine the real and complex parts\n",
    "ax=plt.gca()\n",
    "ax.axis('equal')\n",
    "plt.xlabel('x')\n",
    "plt.ylabel('y')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb05fd7e",
   "metadata": {},
   "source": [
    "### Complex dynamics of Z*Z+c\n",
    "When Z*Z+c is solved over and over, complex behavior emerges!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cab15a93",
   "metadata": {},
   "outputs": [],
   "source": [
    "xx = np.linspace(-2,2,101) #x-value range\n",
    "yy = np.linspace(-2,2,101) #y-value range\n",
    "XX,YY = np.meshgrid(xx,yy) #2d grid of points\n",
    "c = -0.4 + .6j\n",
    "Z = XX + YY*1.j\n",
    "levels=np.linspace(-4,1,20)\n",
    "for i in range(12):\n",
    "    Z = Z*Z + c #evaluate function on the 2D space\n",
    "    Z[np.abs(Z) > 2] = np.nan #numbers that get too big \"escape\" so we ignore them by making them NAN (not a number)\n",
    "    plt.contourf(XX,YY,np.abs(Z),cmap=plt.cm.prism,levels=levels)\n",
    "    cbar = plt.colorbar()\n",
    "    cbar.set_label('|Z|')\n",
    "    plt.title('evaluated '+str(i+1)+' times')\n",
    "    ax=plt.gca()\n",
    "    ax.axis('equal')\n",
    "    plt.xlabel('x')\n",
    "    plt.ylabel('y')\n",
    "    plt.pause(.1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b6c01525",
   "metadata": {},
   "source": [
    "#### Excersize 6: Try changing the grid (xmin, xmax, ymin, ymax), the value of the parameter c, the function (replace Z*Z with sin(Z) or anything else), and any other variables / plot styles / etc. What are your observations? This crazy looking object is related to the Julia set, a famous mathematical fractal-- see what happens if you zoom in around one little area, like x from .03 to .065, and y from .71 to .74.\n",
    "Note: Expect a runtime warning because here we plot the log of an array (for visual purposes) and the array may contain zeros."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6486d84d",
   "metadata": {},
   "outputs": [],
   "source": [
    "npix = 100 #linear number of points to evaluate function\n",
    "xmin = -1.5 #xmin,xmax,ymin,ymax are the min/max values specifying the 2D grid\n",
    "xmax = 1.5\n",
    "ymin = -1.5\n",
    "ymax = 1.5\n",
    "xx = np.linspace(xmin,xmax,npix) #x-value range\n",
    "yy = np.linspace(ymin,ymax,npix) #y-value range\n",
    "XX,YY = np.meshgrid(xx,yy) #2d grid of points\n",
    "c = -0.4 + .6j # some other cool ones: 0.+0.8j, -0.7269 + 0.1889j\n",
    "maxevals = 1000 # number of times to evaluate the function \n",
    "Z = XX + YY*1.j\n",
    "ZN = np.zeros(XX.shape)\n",
    "for i in range(maxevals):\n",
    "    Z = Z*Z + c #evaluate function on the 2D space. Can try other functions, like Z = np.sin(Z)+c, may require new grid min/max\n",
    "    ZN[np.abs(Z) > 2] = i #Now we are going to count how may evaluations it takes to exceed 2\n",
    "    Z[np.abs(Z) > 2] = np.nan #numbers that get too big \"escape\" so we ignore them by making them NAN (not a number)\n",
    "\n",
    "plt.figure(figsize=(8,6))\n",
    "plt.contourf(XX,YY,np.log(ZN),cmap=plt.cm.jet) #take the log to compress the range of values for visual purposes\n",
    "cbar=plt.colorbar()\n",
    "cbar.set_label('log(number of evals before escape)')\n",
    "plt.title('evaluated '+str(i+1)+' times')\n",
    "ax=plt.gca()\n",
    "ax.axis('equal')\n",
    "plt.xlabel('x')\n",
    "plt.ylabel('y')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9e4d0629",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}