CA_NumPy_Inheritance.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center><h1>Testing and Documentation Notebook for Cellular Automaton Using Inheritance from NumPy NDArray</h1></center>\n",
    "This document is for testing/demonstrating a cellular automaton class, CAGrid, which inherits much of its functionality from [NumPy](http://www.numpy.org/) [array objects](https://docs.scipy.org/doc/numpy/reference/arrays.html).  The CAGrid class enables use of the array operations (implemented in C) which should make the execution speed better.  This document assumes the reader is somewhat familiar with NumPy.  It also assumes the user is somewhat familiar with classes and inheritance in Python.  If these concepts are not familiar, the following are good resources to consult.\n",
    "\n",
    "- Numpy has a [Quick Start Guide](https://docs.scipy.org/doc/numpy/user/quickstart.html).  Especially important to understanding this learning module are the concepts of [array views](https://docs.scipy.org/doc/numpy/user/quickstart.html#view-or-shallow-copy), [NumPy Data types (dtype)](https://docs.scipy.org/doc/numpy/reference/arrays.dtypes.html), and [NumPy structured arrays](https://docs.scipy.org/doc/numpy/user/basics.rec.html).\n",
    "\n",
    "- [Jessica Hamrick](http://www.jesshamrick.com/) has a great [Introduction to Classes and Inheritance (in Python)](http://www.jesshamrick.com/2011/05/18/an-introduction-to-classes-and-inheritance-in-python).  This is especially good for those who have not used object oriented programing before.\n",
    "\n",
    "- The Python Tutorial describes [classes](https://docs.python.org/3/tutorial/classes.html) in Python.  This includes [A First Look](https://docs.python.org/3/tutorial/classes.html#a-first-look-at-classes), a description of [Class and Instance Variables](https://docs.python.org/3/tutorial/classes.html#class-and-instance-variables), and a discussion of [Inheritance](https://docs.python.org/3/tutorial/classes.html#inheritance).\n",
    "\n",
    "Even for those familiar with NumPy arrays and Python classes/inheritance, the inheritance of NumPy arrays is rather unique.  The document [Subclassing ndarray](https://docs.scipy.org/doc/numpy/user/basics.subclassing.html) should be consulted to understand the inheritance of NumPy.ndarray to form the class CAGrid used in this notebook.\n",
    "\n",
    "# Results\n",
    "The video below is a game of life simulation using the code in this module.\n",
    "<video controls autoplay loop src=\"GOL_Large_Sim.mp4\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Initialization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAbQAAAEOCAYAAADhZeJVAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAElFTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7d191d0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from CellularAutomaton import *\n",
    "from IPython.display import display\n",
    "import inspect\n",
    "from math import *\n",
    "\n",
    "#for plotting in this notebook.\n",
    "%matplotlib inline\n",
    "import matplotlib\n",
    "from matplotlib import pyplot as plt\n",
    "from matplotlib import animation\n",
    "matplotlib.rc('animation', html='html5')\n",
    "matplotlib.rcParams['image.cmap'] = 'jet'   #Set matshow colors to v 1.0 style\n",
    "#set the plot aspect ratio and setup a default figure to use.\n",
    "goldenratio=1/2*(1+sqrt(5)); fsx=7; fsy=fsx/goldenratio\n",
    "MyFigure, MyAxes = plt.subplots(1,1,figsize=(fsx,fsy));\n",
    "\n",
    "#Function to return the function name, parameters and doc string.\n",
    "def InfoDocString(function):\n",
    "    \"\"\"Function to return function definition and document string.\"\"\"\n",
    "    \n",
    "    code = inspect.getsource(function)\n",
    "    docstring = inspect.getdoc(function)\n",
    "    return code[0:code.find(':')+1].lstrip() +'\\n' + docstring"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Functions to help with testing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "MyDtype = numpy.dtype([('Value','f'),('State',bool)])\n",
    "\n",
    "def setstates(grid, rows, columns, states):\n",
    "    i=0\n",
    "    for y in range(rows):\n",
    "        for x in range(columns):\n",
    "            grid[\"State\"][y][x]=states[i]\n",
    "            i = i + 1\n",
    "    grid.SetValue()\n",
    "    grid.SetBoundary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def setrandomstate(grid,ProbTrue):\n",
    "    a=numpy.random.randint(0,100,grid.shape,dtype='i8')\n",
    "    numpy.copyto(grid[\"State\"],ProbTrue>a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Background\n",
    "This document introduces cellular automaton calculations.  It demonstrates how cellular automaton calculations could be performed using a class which inherits NumPy arrays.  This class implements rules for the [Game of Life](http://web.stanford.edu/~cdebs/GameOfLife/).  This class may be used for other cellular automaton simulations by either inheriting this class and changing the update rules or by editing the update function in [the CAGrid code](CellularAutomaton.py) directly.\n",
    "## Game of Life Update Rules\n",
    "In the game of life, the cellular automaton grid is a 2D grid in which each cell is either 'alive' or 'dead.'  The cellular automaton progresses through time by updating each cell's state based on the state of its neighbor cells in the previous time step.  The game of life treats diagonal cells as neighbors so there are eight nearest neighbors.  Let $Count=\\sum\\limits_{Neighbors}State_{n-1},$ each cell's value at the 'n' time step is then:\n",
    "- $State_n\\:=\\:False\\:if\\:Count>3$ (Too much competition, cell dies)\n",
    "\n",
    "- $State_n\\:=\\:True\\:if\\:Count=3$ (Cell birth or cell stays Alive)\n",
    "\n",
    "- $State_n\\:=\\:False\\:if\\:Count<2$ (Not enough neighbors, cells dies or stays dead)\n",
    "\n",
    "- $State_n\\:=\\:Unchanged\\:if\\:Count=2$\n",
    "\n",
    "Note that the rule for $Count=2$ needs no code to implement.  The cell state can be just left unchanged from the $n-1$ state.\n",
    "# CAGrid Class Structure\n",
    "The class CAGrid (or cellular automaton grid) inherits a NumPy ndarry and adds extra functionality to specialize the array for cellular automaton simulations.  In this implementation, each cell element is an array location.  The class also creates arrays for the neighbors in each direction.  In addition to the structure and functionality provided by NumPy arrays, the array structure should allow faster simulation calculations as array operations can be executed in C using [BLAS](http://www.netlib.org/blas/) subroutines rather than interpreted Python code.  The class doc string, shown below, describes the class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "class CAGrid(numpy.ndarray):\n",
      "Class for implementing cellular automaton grid simulations.\n",
      "\n",
      "Provides a framework for implementing 2D cellular automaton (CA) simulations using NumPy arrays.\n",
      "Each instance of the class has a NumPy array for the cell data.  The class automatically creates\n",
      "boundary cells surrounding the simulation grid.  It also creates views into the simulation grid,\n",
      "boundary cells, and neighbor cells for use with NumPy array calculation calls.\n",
      "\n",
      "Since this class inherits numpy.ndarray, several unique approaches must be used (especially for\n",
      "class instance creation.)  The document at\n",
      "https://docs.scipy.org/doc/numpy/user/basics.subclassing.html explains using ndarray as a\n",
      "subclass and these special approaches.\n",
      "\n",
      "Also important is the concept of an array view.  A view to an array does not use new data in\n",
      "memory, but simply 'views' the data which already exists.  This is explained some at\n",
      "https://docs.scipy.org/doc/numpy-dev/user/quickstart.html#copies-and-views\n",
      "Because of this efficiency, this class creates many views into the grid.  These views can be\n",
      "used later for efficient calculation through NumPy calls rather than iterating over items\n",
      "through interpreted python code.\n",
      "\n",
      "Class methods and attributes Inherited:\n",
      "All the instance variables associated with Numpy ndarray such as .shape, .dtype\n",
      "A complete list of ndarray methods and attributes is available at\n",
      "https://docs.scipy.org/doc/numpy-1.10.1/reference/generated/numpy.ndarray.html#numpy.ndarray\n",
      "\n",
      "\n",
      "The new class methods are:\n",
      "__new__ -> class initialization method.\n",
      "            The array (or grid) shape must be provided.  The constructor will not take data.\n",
      "            It creates an array 2 cells (or nodes) larger (in each direction) than the shape\n",
      "            argument passed.  This allows for boundary cells in each direction.  The\n",
      "            constructor returns a NumPy array for the main simulation data. This is actually\n",
      "            a view into the data of the bigger array which also contains boundary cells.\n",
      "            The bigger array is available through .Base or .base. The constructor also\n",
      "            creates view arrays for the neighbors to the top, top right, left, bottom left ...\n",
      "\n",
      "__array_finalize_ ->  Always called after initialization.  It does not currently do anything.\n",
      "\n",
      "__init__ -> Not used since it is not always called for subclasses of ndarray.\n",
      "\n",
      "Update ->   Implements the rules of the cellular automaton\n",
      "            Currently implements a simulation using 'game of life rules.'\n",
      "            To implement other cellular automaton simulations, either:\n",
      "                1.) Change the code in this file (especially Update)\n",
      "                2.) Create a new class which inherits this class with\n",
      "                    class NewClass(CAGrid):\n",
      "                    and include in that class an update function which will replace the\n",
      "                    one here.\n",
      "\n",
      "FinishUpdate -> Completes tasks after update\n",
      "                After cell values are updated, there are several tasks which must be completed\n",
      "                to prepare the CAGrid object for display and/or the next call to update.\n",
      "                Currently, this includes calling SetValue and SetBoundary.\n",
      "\n",
      "SetValue -> Sets the 'Value' field for the structured array.\n",
      "            This function is somewhat tied to the Game of Life Simulation.\n",
      "            The purpose of this function is do a fast conversion to float values as\n",
      "            expected by matplotlib.matshow.\n",
      "\n",
      "SetBoundary ->  Sets the boundary conditions by copying cells from main simulation grid\n",
      "                to the boundary cells.\n",
      "\n",
      "New Data Attributes or Instance Variables are:\n",
      ".Base or .base ->   The large array which includes the boundary cells.\n",
      "                    .base is the normal attribute for a NumPy array.\n",
      "                        The array returned by the constructor is actually a view into the larger\n",
      "                        array.  So NumPy automatically creates this reference.\n",
      "                    .Base is created in the constructor.  It is probably not needed.  It might be\n",
      "                        needed to keep the larger array in memory.\n",
      "\n",
      ".Neighbors[]  ->    List of arrays which are views which give the cell's neighbor in a direction.\n",
      "                    In other words, one of the neighbors is TopLeft.  Accessing TopLeft[3][4]\n",
      "                    returns the grid node at [2][3].\n",
      "                    Diagonal neighbor arrays are included in the list depending on the value of\n",
      "                    the class variable CAGrid.IncludeDiagonalNeighbors.  The default for this\n",
      "                    variable is True.\n",
      "\n",
      ".Old    ->          Attribute which has the same attributes as the CAGrid object.  .Old is for\n",
      "                    storing the old state of the object before update if necessary.\n",
      ".TrueArray  ->      Array of True values for use in mask/array operations.  It is the same size\n",
      "                    as the simulation grid, not the base grid.  Used for update calculations.\n",
      "                    Declaring .TrueArray makes the code run faster because memory is not created\n",
      "                    with each update.  Since it is an instance variable, it is created and\n",
      "                    initialized only once per simulation.\n",
      ".count      ->      Used by the game of life update to count number of alive neighbors.\n",
      ".UpdateCount    ->  Tracks the number of times Update is called.\n"
     ]
    }
   ],
   "source": [
    "print(InfoDocString(CAGrid))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Update Routine\n",
    "The Update method should be called each time step.  It updates the cell (array) values to the new values.  The complete code for the update function is below.  Note that rather than stepping through each value of the grid, Update determines the new values using calls to [numpy.place](https://docs.scipy.org/doc/numpy/reference/generated/numpy.place.html).  The numpy.place routine is mostly compiled code so it executes much faster than iterating through the cells using Python loops."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    def Update(self):\n",
      "        \"\"\"Implements a single time step using Game of Life Rules\n",
      "\n",
      "        Method currently takes no arguments.\n",
      "\n",
      "        Method sums the 'Value' of the neighbor cells and then applies the game of life rules.\n",
      "        Method uses array operations for calculations rather than iterators so that we take\n",
      "            full advantage of underlying C and BLAS routines rather than slower Python code.\n",
      "\n",
      "        Some of these routines are listed at:\n",
      "        https://docs.scipy.org/doc/numpy/reference/routines.indexing.html#inserting-data-into-arrays\n",
      "        In this method, numpy.place is used.  It is documented at:\n",
      "        https://docs.scipy.org/doc/numpy/reference/generated/numpy.place.html#numpy.place\n",
      "\n",
      "        Method also calls self.FinishUpdate\n",
      "        \"\"\"\n",
      "\n",
      "        # Determine number of neighbors\n",
      "        numpy.place(self.count,self.TrueArray,0)\n",
      "        for n in self.Neighbors:\n",
      "            self.count = self.count + n['Value']\n",
      "\n",
      "        # Implement Game of Life Rules\n",
      "        # Note:  Self.Old is actually not needed for Game of Life.\n",
      "        #       It might not be needed for other Update methods either.\n",
      "        # numpy.copyto(self.Old,self)                       # Default is no change for count = 2\n",
      "        numpy.place(self['State'], self.count >3, False)   # If count > 3: new value = False\n",
      "        numpy.place(self['State'], self.count ==3, True)   # If count = 3: new value = True\n",
      "        numpy.place(self['State'], self.count <2, False)   # If count < 2: new value = False\n",
      "        self.FinishUpdate()\n",
      "        self.UpdateCount += 1\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(inspect.getsource(CAGrid.Update))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tests and Simulations\n",
    "In the cells below, we do some testing of the game of life rules and then run some large simulations demonstrating the game of life rules.  These tests give us confidence that our code operates as we expect.\n",
    "## Displaying Array Data\n",
    "Matplotlib has two function for displaying array data.  They are matshow and imshow.\n",
    "- [matshow](http://matplotlib.org/api/_as_gen/matplotlib.axes.Axes.matshow.html#matplotlib.axes.Axes.matshow) takes a single 2D numpy array.  It does automatic scaling so that the colormap range goes from the minimum to maximum value.\n",
    "\n",
    "- [imshow](http://matplotlib.org/api/_as_gen/matplotlib.axes.Axes.imshow.html#matplotlib.axes.Axes.imshow) is similar to matshow, but has a few more options.  Of primary importance is that we can pass an array of touples to specify the rgb or rgba color values.  This would allow us to specif the color at each grid location.\n",
    "\n",
    "For these game of life simulations, matshow will work well.  For more complicated cellular automaton in which each cell has a more complicated state, imshow might work better. \n",
    "## Test a 3 x 3 Checker Board\n",
    "The checker board pattern should be stable.  All cells have exactly three neighbors.\n",
    "\n",
    "First we create and show the grid."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[False  True False]\n",
      " [ True False  True]\n",
      " [False  True False]]\n",
      "[[ 0.  1.  0.]\n",
      " [ 1.  0.  1.]\n",
      " [ 0.  1.  0.]]\n"
     ]
    }
   ],
   "source": [
    "rows = 3; columns = 3; MyGrid=CAGrid((rows,columns),MyDtype)\n",
    "setstates(MyGrid, rows, columns, (0,1,0,1,0,1,0,1,0))\n",
    "print(MyGrid['State']); print(MyGrid['Value'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQoAAAEOCAYAAABxWlnfAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nv108UQDXSSiAkVAAI6EARkIBjP4LcfEwumoWAvoAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7c43f98>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "MyAxes.matshow(MyGrid['Value']); MyFigure"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we update and show the grid."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQoAAAEOCAYAAABxWlnfAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nv108UQDXSSiAkVAAI6EARkIBjP4LcfEwumoWAvoAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7c43f98>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "MyGrid.Update(); MyAxes.matshow(MyGrid['Value']); MyFigure"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will update and show the grid one more time.  The grid is in a steady state as it should as each 'alive' cell has exactly two neighbors that are also 'alive,' and each 'dead' neighbor is surrounded by four 'alive' neighbors so it always stays 'dead.'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[False  True False]\n",
      " [ True False  True]\n",
      " [False  True False]]\n",
      "[[ 0.  1.  0.]\n",
      " [ 1.  0.  1.]\n",
      " [ 0.  1.  0.]]\n"
     ]
    }
   ],
   "source": [
    "MyGrid.Update(); print(MyGrid['State']); print(MyGrid['Value'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>Continuous Line</h2>\n",
    "<p>With periodic boundary conditions, a continuous line grows and then dies because of overpopulation.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0.  0.  0.]\n",
      " [ 1.  1.  1.]\n",
      " [ 0.  0.  0.]]\n"
     ]
    }
   ],
   "source": [
    "rows = 3; columns = 3; MyGrid=CAGrid((rows,columns),MyDtype)\n",
    "setstates(MyGrid, rows, columns, (0,0,0,1,1,1,0,0,0))\n",
    "print(MyGrid['Value'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1.  1.  1.]\n",
      " [ 1.  1.  1.]\n",
      " [ 1.  1.  1.]]\n"
     ]
    }
   ],
   "source": [
    "MyGrid.Update(); print(MyGrid['Value'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0.  0.  0.]\n",
      " [ 0.  0.  0.]\n",
      " [ 0.  0.  0.]]\n"
     ]
    }
   ],
   "source": [
    "MyGrid.Update(); print(MyGrid['Value'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>Blinker</h2>\n",
    "<p>If we surround the line with empty cells, it is a <a href = http://web.stanford.edu/~cdebs/GameOfLife/ >blinker</a>.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0.  0.  0.  0.]\n",
      " [ 0.  1.  1.  1.]\n",
      " [ 0.  0.  0.  0.]\n",
      " [ 0.  0.  0.  0.]]\n"
     ]
    }
   ],
   "source": [
    "rows = 4; columns = 4; MyGrid=CAGrid((rows,columns),MyDtype);\n",
    "setstates(MyGrid, rows, columns, (0,0,0,0, 0,1,1,1, 0,0,0,0, 0,0,0,0));\n",
    "print(MyGrid['Value'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0.  0.  1.  0.]\n",
      " [ 0.  0.  1.  0.]\n",
      " [ 0.  0.  1.  0.]\n",
      " [ 0.  0.  0.  0.]]\n"
     ]
    }
   ],
   "source": [
    "MyGrid.Update(); print(MyGrid['Value'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0.  0.  0.  0.]\n",
      " [ 0.  1.  1.  1.]\n",
      " [ 0.  0.  0.  0.]\n",
      " [ 0.  0.  0.  0.]]\n"
     ]
    }
   ],
   "source": [
    "MyGrid.Update(); print(MyGrid['Value'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0.  0.  1.  0.]\n",
      " [ 0.  0.  1.  0.]\n",
      " [ 0.  0.  1.  0.]\n",
      " [ 0.  0.  0.  0.]]\n"
     ]
    }
   ],
   "source": [
    "MyGrid.Update(); print(MyGrid['Value'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Small Grid Animation Test\n",
    "We will now run a small simulation to demonstrate this game of life simulation.  The final result of this test is an animation of the simulation.  Matplotlib has a built in [animation module](http://matplotlib.org/api/animation_api.html).  [This notebook](https://github.com/WillClaudeHolmes/Jupyter_Examples/blob/master/AnimationIllustration.ipynb) describes the necessary background as well well as gives several examples.\n",
    "\n",
    "The matplotlib [function animation method](http://matplotlib.org/api/_as_gen/matplotlib.animation.FuncAnimation.html#matplotlib.animation.FuncAnimation) requires a callable function which updates the figure.  This function must take one argument, the sequence number of the image being produced.  The `af(n)` function defined below is this function for this simulation.\n",
    "\n",
    "In the cells below, we will save the animation to an external file, and then include it in the notebook with the [html video tag](https://www.w3schools.com/tags/tag_video.asp)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "def af(n):\n",
    "    MyGrid.Update()\n",
    "    MyAxes.matshow(MyGrid['Value'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAawAAADmCAYAAACJfLESAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7c43f98>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rows = 25; columns = 50;\n",
    "MyGrid=CAGrid((rows,columns),MyDtype)  #initilized with whatever random memory was at the location.\n",
    "setrandomstate(MyGrid,38)              #set 38% (3/8) cells as 'alive.'  \n",
    "MyGrid.FinishUpdate()\n",
    "MyAxes.matshow(MyGrid['State'])\n",
    "MyFigure"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The animation will be 13.2 seconds long.\n"
     ]
    }
   ],
   "source": [
    "AnimationFrames = 400  #total number of frames in animation.\n",
    "DelayBetweenFrames = 33 #in msec (20 gives 50 fps) (33.3 gives 30 fps)\n",
    "AnimationTime = AnimationFrames * DelayBetweenFrames/1000\n",
    "print (\"The animation will be {:.1f} seconds long.\".format(AnimationTime))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "MyAnimation = animation.FuncAnimation(MyFigure, af,\n",
    "                               frames=AnimationFrames, interval=DelayBetweenFrames, blit=False)\n",
    "MyAnimation.save('GOL_Small_Grid_test.mp4',extra_args=['-vcodec', 'h264'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<video controls autoplay loop src=\"GOL_Small_Grid_test.mp4\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>Glider Tests</h2>\n",
    "<p>A good test for the game of life simulation is if a <a href = http://web.stanford.edu/~cdebs/GameOfLife/ >glider</a> will act correctly.\n",
    "<h3>Small Grid Example</h3>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQkAAAEMCAYAAADXpUPXAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nnB/X29W+swgAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7c43f98>"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rows = 5; columns = 5\n",
    "MyGrid=CAGrid((rows,columns),MyDtype)\n",
    "#Set all values to zero or 'dead' or False\n",
    "numpy.copyto(MyGrid['State'],numpy.zeros((rows,columns),dtype=numpy.dtype(bool)))\n",
    "#Set specific cells to 'alive' or True\n",
    "MyGrid['State'][0][1] = True\n",
    "MyGrid['State'][1][1] = True\n",
    "MyGrid['State'][1][2] = True\n",
    "MyGrid['State'][2][0] = True\n",
    "MyGrid['State'][2][2] = True\n",
    "\n",
    "MyGrid.FinishUpdate()\n",
    "MyAxes.matshow(MyGrid['State'])\n",
    "MyFigure"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The animation will be 20.0 seconds long.\n"
     ]
    }
   ],
   "source": [
    "AnimationFrames = 20  #total number of frames in animation.\n",
    "DelayBetweenFrames = 1000 #in msec (20 gives 50 fps) (33.3 gives 30 fps)\n",
    "AnimationTime = AnimationFrames * DelayBetweenFrames/1000\n",
    "print (\"The animation will be {:.1f} seconds long.\".format(AnimationTime))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "MyAnimation = animation.FuncAnimation(MyFigure, af,\n",
    "                               frames=AnimationFrames, interval=DelayBetweenFrames, blit=False)\n",
    "MyAnimation.save('GOL_Glider_test.mp4',extra_args=['-vcodec', 'h264'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<video controls autoplay loop src=\"GOL_Glider_test.mp4\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It does indeed return to its initial state."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Large Grid Glider Test with Multiple Gliders\n",
    "Let us put several gliders onto the same grid and let them run.  When they collide they produce different patterns."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAawAAADmCAYAAACJfLESAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7c43f98>"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rows = 25; columns = 50\n",
    "MyGrid=CAGrid((rows,columns),MyDtype)\n",
    "numpy.copyto(MyGrid['State'],numpy.zeros((rows,columns),dtype=numpy.dtype(bool)))\n",
    "MyGrid['State'][5][10] = True\n",
    "MyGrid['State'][6][10] = True\n",
    "MyGrid['State'][6][11] = True\n",
    "MyGrid['State'][7][9]  = True\n",
    "MyGrid['State'][7][11] = True\n",
    "\n",
    "MyGrid['State'][12][20] = True\n",
    "MyGrid['State'][11][20] = True\n",
    "MyGrid['State'][11][21] = True\n",
    "MyGrid['State'][10][19] = True\n",
    "MyGrid['State'][10][21] = True\n",
    "\n",
    "MyGrid['State'][22][40] = True\n",
    "MyGrid['State'][21][40] = True\n",
    "MyGrid['State'][21][39] = True\n",
    "MyGrid['State'][20][41] = True\n",
    "MyGrid['State'][20][39] = True\n",
    "\n",
    "\n",
    "MyGrid.FinishUpdate()\n",
    "MyAxes.matshow(MyGrid['Value'])\n",
    "MyFigure"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The animation will be 30.0 seconds long.\n"
     ]
    }
   ],
   "source": [
    "AnimationFrames = 300  #total number of frames in animation.\n",
    "DelayBetweenFrames = 100 #in msec (20 gives 50 fps) (33.3 gives 30 fps)\n",
    "AnimationTime = AnimationFrames * DelayBetweenFrames/1000\n",
    "print (\"The animation will be {:.1f} seconds long.\".format(AnimationTime))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "MyAnimation = animation.FuncAnimation(MyFigure, af,\n",
    "                               frames=AnimationFrames, interval=DelayBetweenFrames, blit=False)\n",
    "MyAnimation.save('GOL_Glider_M_test.mp4',extra_args=['-vcodec', 'h264'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "The multiple glider example is below.\n",
    "<video controls autoplay loop src=\"GOL_Glider_M_test.mp4\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Full Game of Life Simulation\n",
    "Just for fun, let us run a simulation on a large grid."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x8e79b00>"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXMAAAD8CAYAAACFK0QrAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n/wE3Mozo21P5pwAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x8e79a20>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "rows = 75\n",
    "columns = 115\n",
    "MyGrid=CAGrid((rows,columns),MyDtype)  #initilized with whatever random memory was at the location.\n",
    "setrandomstate(MyGrid,38)\n",
    "MyGrid.FinishUpdate()\n",
    "MyFigure, MyAxes = plt.subplots()\n",
    "MyAxes.matshow(MyGrid['State'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The animation will be 33.0 seconds long.\n"
     ]
    }
   ],
   "source": [
    "AnimationFrames = 1000  #total number of frames in animation.\n",
    "DelayBetweenFrames = 33 #in msec (20 gives 50 fps) (33.3 gives 30 fps)\n",
    "AnimationTime = AnimationFrames * DelayBetweenFrames/1000\n",
    "print (\"The animation will be {:.1f} seconds long.\".format(AnimationTime))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "MyAnimation = animation.FuncAnimation(MyFigure, af,\n",
    "                               frames=AnimationFrames, interval=DelayBetweenFrames, blit=False)\n",
    "MyAnimation.save('GOL_Large_Sim.mp4',extra_args=['-vcodec', 'h264'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<video controls autoplay loop src=\"GOL_Large_Sim.mp4\" />"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [conda root]",
   "language": "python",
   "name": "conda-root-py"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}