Practical_4.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Practical 4: Modules and Functions - Building Conway's Game of Life\n",
    "\n",
    "<div class=\"alert alert-block alert-success\">\n",
    "<b>Objectives:</b> In this practical we continue to use functions, modules and conditional statements. We also continue practicing how we access entries from 2D arrays. At the end of this notebook you will have a complete version of Conway's Game of Life which will produce an animation. This will be done through 3 different sections, each of which has an exercise for you to complete:\n",
    "    \n",
    " - 1) [Creating different shapes through 2D Numpy array modifications](#Part1)\n",
    "      * [Exercise 1: Draw still 'life' from Conway's Universe](#Exercise1)\n",
    "      * [Exercise 2: Draw oscillators and space-ship 'life' from Conway's Universe](#Exercise2)\n",
    " - 2) [Creating a function that searches a local neighbourhood for values of '1' and '0'](#Part2)\n",
    "      * [Exercise 3: Implement the 4 rules of life](#Exercise3)\n",
    "      * [Exercise 4: Loop through 20 oscillations of the 'Beacon' lifeform](#Exercise4)\n",
    " - 3) [Populating Conway's Universe with multiple species](#Part3)\n",
    " \n",
    "As with our other notebooks, we will provide you with a template for plotting the results. Also please note that you should not feel pressured to complete every exercise in class. These practicals are designed for you to take outside of class and continue working on them. Proposed solutions to all exercises can be found in the 'Solutions' folder.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "<b>Please note:</b> After reading the instructions and aims of any exercise, search the code snippets for a note that reads -------'INSERT CODE HERE'------- to identify where you need to write your code \n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction: The game\n",
    "\n",
    "Before we get our teeth into the exercises included in this notebook, let's remind ourselves about the basis for Conway's game of life. In Conway's game of life, the Universe is represented as a 2D space [a 2D Numpy array in our case!] on which each cell can either be alive or dead. If we refer to each cell as having one of two states, we can represent this numerically as each cell having either a value of 1 or 0. If we then assume we can draw 2D shapes that represent a 'specie', as a collection of live cells, we might find patterns changing over time.\n",
    "\n",
    "Every cell interacts with its neighbours, whether they are horizontally, vertically of diagonally adjacent. There are 4 laws that define these interactions:\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "    \n",
    " - Any live cell with fewer than two live neighbours dies, as if by underpopulation.\n",
    "    \n",
    " - Any live cell with two or three live neighbours lives on to the next generation.\n",
    " \n",
    " - Any live cell with more than three live neighbours dies, as if by overpopulation.\n",
    " \n",
    " - Any dead cell with exactly three live neighbours becomes a live cell, as if by reproduction.\n",
    "</div>\n",
    "\n",
    "So, imagine we are at the beginning of time in our 2D Universe. We need to check the status of every cell and make changes according to these laws. After one sweep through our 2D space, or time step, the status of individual cells will change. Numerically, the distribution of '1's and '0's change across our 2D space. In fact, by defining species as dinstinct groups of cells of a certain shape, as we move through multiple time steps we find 3 types of patterns emerging:\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "    \n",
    " - Still life: These patterns remain fixed on the board\n",
    " \n",
    " - Oscillators: These patterns change shape on every iteration, but return to their initial state after a number of generations.\n",
    " \n",
    " - Space-ships: These patterns end up moving across the board according to the rules that define life and death.\n",
    "</div>\n",
    "\n",
    "From a programming perspective, implementing these rules through any number of time steps requires a number of procedures to be implemented via code:\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "\n",
    " - 1) Defining 2D arrays that represent species in Conway's Universe. \n",
    " - 2) Creating a function that searches the immediate neighbouring space of each cell for 1's and 0's.\n",
    " - 3) Counting the number of 1's and 0's according to the previous point.\n",
    " - 4) Changing the values of each cell according to the 4 laws stated above.\n",
    " - 5) Looping through points 2-4 for any number of time steps.\n",
    "\n",
    "</div>\n",
    "\n",
    "\n",
    "By sequentially following the proceeding exercises, we will eventually build a variant of Conway's game of life."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating different shapes through 2D Numpy array modifications <a name=\"Part1\"></a>\n",
    "\n",
    "Before we can run a simulation, let's create distinct species as groups of cells, and thus patterns. This will help us practice creating 2D arrays and populating each cell with either a '0' or '1' depending on what pattern we want to draw. To generate and thus draw each specie you will be asked to initialise a 2D Numpy array that repeats the pattern seen in the picture. The code to plot, thus visualise, each pattern is given for you.\n",
    "\n",
    "### Still life \n",
    "\n",
    "The pictures in Figure 1 and 2 illustrate common types of still life in Conway's Universe. Ive given you some code that reproduces the pattern for 'Block', in the code box below. Read through the code and comments and see if this makes sense. \n",
    "\n",
    "![](https://github.com/loftytopping/DEES_programming_course/blob/master/images/Practical_3_figure1.png?raw=true)\n",
    "<h3><center>Figure 1</center></h3>\n",
    "\n",
    "![](https://github.com/loftytopping/DEES_programming_course/blob/master/images/Practical_3_figure2.png?raw=true)\n",
    "<h3><center>Figure 2</center></h3>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "An empty array [[0 0 0 0]\n",
      " [0 0 0 0]\n",
      " [0 0 0 0]\n",
      " [0 0 0 0]]\n",
      "A finished array [[0 0 0 0]\n",
      " [0 1 1 0]\n",
      " [0 1 1 0]\n",
      " [0 0 0 0]]\n",
      "None\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#%matplotlib inline #this is to help us retrieve those love animations!\n",
    "\n",
    "import numpy as np #import the numerical python library, numpy. Changing the referenced library to 'np' is solely for convenience\n",
    "import matplotlib.pyplot as plt #as per the above, much easier to write over and over again \n",
    "from matplotlib import animation, rc\n",
    "\n",
    "# Lets first create our 'Block'. Dont forget, we can call our arrays and matrices anything we want. In this case Im going to use the name of the pattern we are interested in\n",
    "Block = np.zeros((4,4),dtype=int) #Im telling the Python interpreter I want a numpy array that is 4 rows by 4 columns, contains '0' for now and is expecting my data to be of integer type\n",
    "# What does this look like?\n",
    "print(\"An empty array\",Block)\n",
    "# Can you see a matrix of 0s?\n",
    "\n",
    "# Ok cool. Now lets add some black cells by position some values of 1. For the Block pattern, this is done as follows:\n",
    "Block[1,1]=1\n",
    "Block[1,2]=1\n",
    "Block[2,1]=1\n",
    "Block[2,2]=1\n",
    "# Remeber how we refer to elements in an array in Python? Everything starts at 0, so here im filling in the central 2x2 matrix with 1s. Lets check this out numerically:\n",
    "print(print(\"A finished array\",Block))\n",
    "\n",
    "#Now lets plot this to recreate the patterns given in figure x. \n",
    "plt.imshow(Block, cmap='binary') #The cmap, or colour map, gives us a black and white board.\n",
    "plt.title('Block')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-success\">\n",
    "<b> Exercise 1: Draw still 'life' from Conway's Universe. </b> <a name=\"Exercise1\"></a>\n",
    "\n",
    "In this exercise you will need to create a 2D Numpy array that essentially 'draws' both the *Tub* and *Boat* specie from figure 2. \n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWoAAADHCAYAAAAwLRlnAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAALmElEQVR4nO3df6zd9V3H8edrpexHwLHINWJb6DRkWV0UzA2SEKNpMOnGNvxPyGDGLOk/oixOyUj2x/hjkmgky5b90wyCCoLEEbOx6dIFcCHZ2C6sW6gdSSVFKst664ZQo0zg7R/noHe19J6O+/2e92mfj+Qk59z7vefz/ravvO73fu/33JOqQpLU1xvmPYAk6eQsaklqzqKWpOYsaklqzqKWpOYsaklqzqJuKMnhJL8x7zkk9WBRDyDJsTW3V5L855rHH5j3fNJPIsmhNVn+YZIvJtm2Qc975UbMeLqyqAdQVee8egP+BXjfmo/dPe/5pNfhfdNcXwB8H/j0nOc5I1jUc5DkriQfX/P4yiSHjtvsV5McmB653J7kjaMOKZ1EVf0X8LfADoAkb03yl0lWkzyd5GNJ3jD93C8keTDJvyU5muTuJOdNP/dXwIXAF6ZH6jfNa586s6j7+gDwm8DFwC8CN893HOn/JHkL8NvA16cf+jTwVuDngV8HPgj87qubA7cCPwe8E9gGfBygqq7nx3/q/NORdmGhWNR9faqqDlfVUeBPgGvnPZAE/F2S54DnmRxI/FmSTUxK++aqeqGqDgF/DlwPUFUHq2pvVb1YVavAbUzKXDM6a94D6DU9s+b+00yORqR5+62q+sq0nK8G/hG4FDibSU5f9TSwBSDJzwCfAn4NOJfJAeIPxxx60XlEPR//AbxlzeOfPcE2a3+bfiHw7KATSaegql6uqvuBl4HLgf8GLlqzyYXAv07v3woU8EtV9VPAdUxOh/zv0w0/8WKzqOdjH3BVkrcluQD4gxNsc0OSLUl+msn56b8ZdULpJDJxNfA24AngPuATSc5NchHwh8Bd083PBY4BzyXZAvzxcU/3fSbntvUaLOr5uBM4wOTHw38A7j3BNvcAXwH+GXiSyXlqad6+kOQYk3PUnwB+p6r2A7/P5CfFp4BHgL8G7ph+zS3ArwD/DnwRuP+457wV+FiS55L80fC7sHjiGwdIUm8eUUtScxa1JDVnUUtScxa1JDVnUUtSc4O8MvH888+v7du3D/HUEocOHeLo0aNZf8uNZa41pJPlepCi3r59OysrK0M8tcTy8vJc1jXXGtLJcu2pD0lqzqKWpOYsaklqzqKWpOYsaklqzqKWpOYsaklqzqKWpOYsaklqbqaiTrIryZNJDib56NBDSWMx21oE6xb19N2GPwO8G9gBXJtkx9CDSUMz21oUsxxRXwYcrKqnqupHTN7f7+phx5JGYba1EGYp6i3AM2seH55+TFp0ZlsLYZaiPtGf3ft/74ibZHeSlSQrq6urr38yaXjrZttcq4NZivowsG3N463As8dvVFV7qmq5qpaXlpY2aj5pSOtm21yrg1mK+pvAxUnenuRs4Brg88OOJY3CbGshrPvGAVX1UpIbgC8Dm4A7qmr/4JNJAzPbWhQzvcNLVX0J+NLAs0ijM9taBL4yUZKas6glqTmLWpKas6glqTmLWpKas6glqTmLWpKas6glqTmLWpKas6glqTmLWpKas6glqTmLWpKas6glqTmLWpKas6glqTmLWpKas6glqTmLWpKas6glqTmLWpKas6glqbl1izrJHUmOJHlijIGksZhtLYpZjqjvBHYNPIc0D3ditrUA1i3qqvoq8IMRZpFGZba1KDbsHHWS3UlWkqysrq5u1NNKc2Wu1cGGFXVV7amq5apaXlpa2qinlebKXKsDr/qQpOYsaklqbpbL8+4Bvga8I8nhJB8afixpeGZbi+Ks9TaoqmvHGEQam9nWovDUhyQ1Z1FLUnMWtSQ1Z1FLUnMWtSQ1Z1FLUnMWtSQ1Z1FLUnMWtSQ1Z1FLUnMWtSQ1Z1FLUnMWtSQ1Z1FLUnMWtSQ1Z1FLUnMWtSQ1Z1FLUnMWtSQ1Z1FLUnMWtSQ1t25RJ9mW5KEkB5LsT3LjGINJQzPbWhRnzbDNS8BHqurxJOcCjyXZW1X/NPBs0tDMthbCukfUVfW9qnp8ev8F4ACwZejBpKGZbS2KUzpHnWQ7cCnw6BDDSPNittXZzEWd5Bzgc8CHq+r5E3x+d5KVJCurq6sbOaM0qJNl21yrg5mKOslmJkG+u6ruP9E2VbWnqparanlpaWkjZ5QGs162zbU6mOWqjwC3Aweq6rbhR5LGYba1KGY5or4CuB7YmWTf9PaegeeSxmC2tRDWvTyvqh4BMsIs0qjMthaFr0yUpOYsaklqzqKWpOYsaklqzqKWpOYsaklqzqKWpOYsaklqzqKWpOYsaklqzqKWpOYsaklqzqKWpOYsaklqzqKWpOYsaklqzqKWpOYsaklqzqKWpOYsaklqzqKWpOYsaklqbt2iTvKmJN9I8u0k+5PcMsZg0tDMthbFWTNs8yKws6qOJdkMPJLk76vq6wPPJg3NbGshrFvUVVXAsenDzdNbDTmUNAazrUUx0znqJJuS7AOOAHur6tETbLM7yUqSldXV1Y2eUxrEetk21+pgpqKuqper6hJgK3BZknedYJs9VbVcVctLS0sbPac0iPWyba7VwSld9VFVzwEPA7sGmUaaE7Otzma56mMpyXnT+28GrgS+O/Rg0tDMthbFLFd9XAD8RZJNTIr9vqp6YNixpFGYbS2EWa76+A5w6QizSKMy21oUvjJRkpqzqCWpOYtakpqzqCWpOYtakpqzqCWpOYtakpqzqCWpOYtakpqzqCWpOYtakpqzqCWpOYtakpqzqCWpOYtakpqzqCWpOYtakpqzqCWpOYtakpqzqCWpOYtakpqbuaiTbEryrSQPDDmQNCZzrUVwKkfUNwIHhhpEmhNzrfZmKuokW4GrgM8OO440HnOtRTHrEfUngZuAVwacRRqbudZCWLeok7wXOFJVj62z3e4kK0lWVldXN2xAaQjmWotkliPqK4D3JzkE3AvsTHLX8RtV1Z6qWq6q5aWlpQ0eU9pw5loLY92irqqbq2prVW0HrgEerKrrBp9MGpC51iLxOmpJau6sU9m4qh4GHh5kEmlOzLW684hakpqzqCWpOYtakpqzqCWpOYtakpqzqCWpOYtakpqzqCWpOYtakpqzqCWpuVTVxj9psgo8/RN++fnA0Q0cp/u681x7Uff5oqoa/U/ZLWiu57m2+3xqXjPXgxT165FkpaqWz5R157n2mbjP83Im/lu7zxvHUx+S1JxFLUnNdSzqPWfYuvNc+0zc53k5E/+t3ecN0u4ctSTpx3U8opYkrdGmqJPsSvJkkoNJPjriunckOZLkibHWnK67LclDSQ4k2Z/kxhHXflOSbyT59nTtW8Zae7r+piTfSvLAmOvOi9keJ9unc65bFHWSTcBngHcDO4Brk+wYafk7gV0jrbXWS8BHquqdwOXA7424zy8CO6vql4FLgF1JLh9pbYAbgQMjrjc3ZnvUbJ+2uW5R1MBlwMGqeqqqfgTcC1w9xsJV9VXgB2Osddy636uqx6f3X2DyH7xlpLWrqo5NH26e3kb5ZUWSrcBVwGfHWK8Bsz1Stk/nXHcp6i3AM2seH2ak0uogyXbgUuDREdfclGQfcATYW1Vjrf1J4CbglZHWmzezPWK2T9dcdynqnOBjZ8TlKEnOAT4HfLiqnh9r3ap6uaouAbYClyV519BrJnkvcKSqHht6rUbM9ojZPl1z3aWoDwPb1jzeCjw7p1lGk2QzkyDfXVX3z2OGqnoOeJhxzmVeAbw/ySEmpwB2JrlrhHXnyWzPIdunW667FPU3gYuTvD3J2cA1wOfnPNOgkgS4HThQVbeNvPZSkvOm998MXAl8d+h1q+rmqtpaVduZ/B8/WFXXDb3unJnt8dY9bXPdoqir6iXgBuDLTH7xcF9V7R9j7ST3AF8D3pHkcJIPjbEuk+/C1zP57rtvenvPSGtfADyU5DtMimRvVZ0Rl8qNzWyPmu3TNte+MlGSmmtxRC1Jem0WtSQ1Z1FLUnMWtSQ1Z1FLUnMWtSQ1Z1FLUnMWtSQ19z+CKU/ep2GokQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# We have already imported both Numpy and Matplotlib so no need to import those again.\n",
    "# Initialise our matrices\n",
    "Tub = np.zeros((5,5),dtype=int)\n",
    "Boat = np.zeros((5,5),dtype=int)\n",
    "\n",
    "#-------'INSERT CODE HERE'-------\n",
    "# Now add '1's to the currently empty 2D array Tub\n",
    "\n",
    "\n",
    "\n",
    "#--------------------------------\n",
    "\n",
    "plt.subplot(1, 2, 1).imshow(Tub, cmap='binary') #The cmap, or colour map, gives us a black and white board.\n",
    "plt.title('Tub')\n",
    "#plt.show()\n",
    "\n",
    "#-------'INSERT CODE HERE'-------\n",
    "# Now add '1's to the currently empty 2D array Boat\n",
    "\n",
    "\n",
    "\n",
    "#--------------------------------\n",
    "\n",
    "plt.subplot(1, 2, 2).imshow(Boat, cmap='binary') #The cmap, or colour map, gives us a black and white board.\n",
    "plt.title('Boat')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-success\">\n",
    "<b> Exercise 2: Draw oscillators and space-ship 'life' from Conway's Universe. </b> <a name=\"Exercise2\"></a>\n",
    "\n",
    "Following exercise #1,now do the same for 2 types of both *oscillators* and *space ships*: Toad, Beacon, Glider and Light-weight spaceship (LWSS). Can you replicate the patterns shown in figures 1 and 3? Check the size of each array you need, accounting for white space around the outside. Use the space below and copy-paste the code we have already used.\n",
    "\n",
    "![](images/Practical_3_figure3.png \"Title\") \n",
    "<h3><center>Figure 3</center></h3>\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Enter the Python code here to create and then visualise a Toad, Beacon and Glider\n",
    "\n",
    "#Initialise each matrix\n",
    "Beacon = np.zeros((6,6),dtype=int)\n",
    "Toad = np.zeros((6,6),dtype=int)\n",
    "Glider = np.zeros((5,5),dtype=int)\n",
    "LWSS = np.zeros((6,7),dtype=int)\n",
    "\n",
    "#Enter values for '1' where you would like a black square\n",
    "#-------'INSERT CODE HERE'-------\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "#--------------------------------\n",
    "\n",
    "\n",
    "#Now visualise your results. \n",
    "\n",
    "plt.subplot(1, 2, 1).imshow(Beacon, cmap='binary') #The cmap, or colour map, gives us a black and white board.\n",
    "plt.title('Beacon')\n",
    "plt.subplot(1, 2, 2).imshow(Toad, cmap='binary') #The cmap, or colour map, gives us a black and white board.\n",
    "plt.title('Toad')\n",
    "plt.show()\n",
    "\n",
    "plt.subplot(1, 2, 1).imshow(Glider, cmap='binary') #The cmap, or colour map, gives us a black and white board.\n",
    "plt.title('Glider')\n",
    "plt.subplot(1, 2, 2).imshow(LWSS, cmap='binary') #The cmap, or colour map, gives us a black and white board.\n",
    "plt.title('LWSS')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating a function that searches a local neighbourhood for values of '1' and '0' <a name=\"Part2\"></a>\n",
    "\n",
    "Now we know how to define a specie by modifying values in a 2D array, we also need to now create a function that can search the neighbouring space of any cell for the occurance of '1's or '0's. We are going to perform this operation many times so creating a function to do this seems a sensible approach.\n",
    "\n",
    "As an example, let's re-create the 2D array that represents the specie 'Beacon' and then pass this array into a new function that will search the neighbouring space of every cell to detect a '1' or '0. In this example I have given you all of the code to perform this operation. Try to understand the syntax used. Does this make sense? First look at the code and then let's formulate the steps in the function as a narrative."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Finished function call, nothing to report!\n"
     ]
    }
   ],
   "source": [
    "#Initialise the Beacon matrix\n",
    "Beacon = np.zeros((6,6),dtype=int)\n",
    "\n",
    "#Enter values for '1' where you would like a black square\n",
    "Beacon [1,1]=1\n",
    "Beacon [1,2]=1\n",
    "Beacon [2,1]=1\n",
    "Beacon [3,4]=1\n",
    "Beacon [4,3]=1\n",
    "Beacon [4,4]=1\n",
    "\n",
    "# Now define a function that moves through through each cell in our 2D array and searches the neighbouring space \n",
    "# We pass three variables:\n",
    "# rows - Number of rows in our space to be searched\n",
    "# cols - Number of columns in our space to be searched\n",
    "# space - The 2D array space to be searched\n",
    "def search_each_cell(total_rows,total_cols,space):\n",
    "    \n",
    "    # 1) First, we need to start moving through each cell of our 'space'.\n",
    "    #    To do this, we will use two nested 'for' loops\n",
    "    for row in range(total_rows):\n",
    "        for col in range(total_cols):\n",
    "            # So 'row' and 'col' define our current cell.\n",
    "            # We now need to search a neighbourhood defined as 1 cell distance around this position\n",
    "            # We thus need two more nested for loops. When searching this neighbouring space, we want\n",
    "            # to count the number of 1's. Thus we also need a variable that we can increment by 1 \n",
    "            # everytime we find a value of 1. Lets call this integer variable count\n",
    "            count = 0\n",
    "            for row2 in range(row-1,row+2): # See here that we can define a start and end to our 'range'\n",
    "                for col2 in range(col-1,col+2): \n",
    "                     # We need to check if our new position, defined by [row2,col2] is off the board\n",
    "                    if (row2<0) or (row2>=total_rows) or (col<0) or (col2>=total_cols):\n",
    "                        # Do nothing\n",
    "                        pass\n",
    "                    elif row2 == row and col2 == col:\n",
    "                        # Do nothing, its the cell we already have!\n",
    "                        pass\n",
    "                    # If we are not off the board or in the same cell as our starting point...\n",
    "                    # We can check if this new space has a value of 1. It it does, lets count it\n",
    "                    else:\n",
    "                        if space[row2,col2]>0:\n",
    "                            count=count+1\n",
    "    \n",
    "    return # At the moment we are not returning anything. Seem odd? We will get back to this.\n",
    "\n",
    "# call the above function\n",
    "search_each_cell(6,6,Beacon)\n",
    "\n",
    "print(\"Finished function call, nothing to report!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's try to understand what this function is actually doing. As an algorithm, we have the following steps\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "    \n",
    " - 1) Pass the 2D Numpy array to the new function along with variables that define the total number of rows and columns\n",
    " \n",
    " - 2) We need to move through every cell and search its local neighbourhood. Moving through each cell is defined by the first two loops that cycle through both the row and column index of our 2D space. The limits are defined by the variables total_rows and total_cols\n",
    " \n",
    " - 3) For each cell, we will want to have an integer variable that counts how many 1's there are in the local neighborhood. We need to initialise this to 0 for each cell we move through. We call this variable <code> count </code>\n",
    " \n",
    " - 4) Now we need to look at the local space surrounding our cell. For this we need two more nested loops that look 1 row above, 1 row below, 1 column to the left and one to the right.\n",
    " \n",
    " - 5) As we move through this neighborhood we need to check if we are either off the board OR in the same location as the cell we are interested in!\n",
    " \n",
    " - 6) If none of the above is true, then check if a cell has a value greater then 0. If it does, increment variable <code> count </code> by 1.\n",
    " \n",
    " - 7) For each cell on the board, repeat steps 3-6.\n",
    " \n",
    " - 8) When the entire space has been searched, stop the function and return nothing.\n",
    " \n",
    "</div>\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-success\">\n",
    "<b> Exercise 3 - Implement the 4 rules of life  <a name=\"Exercise3\"></a>  </b> \n",
    "\n",
    "Now we have the function that can search the local neighbourhood of any cell and count how many 1s and 0's there are, we can now add on more code that can implement the 4 rules of life and thus keep the value of our current cell or change it. Let's remind ourselves what those rules are:\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "    \n",
    " - Any live cell with fewer than two live neighbours dies, as if by underpopulation.\n",
    "    \n",
    " - Any live cell with two or three live neighbours lives on to the next generation.\n",
    " \n",
    " - Any live cell with more than three live neighbours dies, as if by overpopulation.\n",
    " \n",
    " - Any dead cell with exactly three live neighbours becomes a live cell, as if by reproduction.\n",
    "</div>\n",
    "\n",
    "So in this exercise we have a shape that has been passed into our function, and then create a new shape according to the rules of life. In the exercise you will need to add a series of conditional statements that populate the value of cells in our new shape according to these rules. In other words, we can re-write the above rules as:\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "    \n",
    " - If our current cell is alive [=1]:\n",
    " \n",
    "   a) If count < 2, current cell = 0 [it dies].\n",
    "    \n",
    "   b) If 2<=count<=3, current cell = 1 [it stays alive].\n",
    "   \n",
    "   c) If count>3, current cell = 0 [it dies]\n",
    "   \n",
    " \n",
    " - If our current cell is dead [=0]\n",
    " \n",
    "   a) If count == 3, current cell = 1 [born]\n",
    "   \n",
    "</div>\n",
    "\n",
    "Notice the syntax I have used for the last conditional: <code> If count == 3 </code>? When checking a value we use two equals signs <code> == </code> as we are not *assigning* a value as we would in, e.g. <code> x = 4 </code>. In the code snippet below, I have identified where you need to implement these rules. Notice that we plot the 'Beacon' pattern before we call the function and then the new 2D space which should change the pattern. With this in mind, also note that our function new returns a new version of our 2D space which I have called 'new_space'. If correct, when you run your completed code you should see figure 4.\n",
    "\n",
    "![](images/Practical_3_figure4.png \"Title\") \n",
    "<h3><center>Figure 4</center></h3>\n",
    "\n",
    "Please note that where I have added 'INSERT CODE HERE' we are using the correct indentation.\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndentationError",
     "evalue": "expected an indented block (<ipython-input-5-b4e96637cbd8>, line 52)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-5-b4e96637cbd8>\"\u001b[0;36m, line \u001b[0;32m52\u001b[0m\n\u001b[0;31m    elif space[row,col] == 0:\u001b[0m\n\u001b[0m       ^\u001b[0m\n\u001b[0;31mIndentationError\u001b[0m\u001b[0;31m:\u001b[0m expected an indented block\n"
     ]
    }
   ],
   "source": [
    "#Initialise the Beacon matrix\n",
    "Beacon = np.zeros((6,6),dtype=int)\n",
    "\n",
    "#Enter values for '1' where you would like a black square\n",
    "Beacon [1,1]=1\n",
    "Beacon [1,2]=1\n",
    "Beacon [2,1]=1\n",
    "Beacon [3,4]=1\n",
    "Beacon [4,3]=1\n",
    "Beacon [4,4]=1\n",
    "\n",
    "# Now define a function that moves through through each cell in our 2D array and searches the neighbouring space \n",
    "# We pass three variables:\n",
    "# rows - Number of rows in our space to be searched\n",
    "# cols - Number of columns in our space to be searched\n",
    "# space - The 2D array space to be searched\n",
    "def search_each_cell(total_rows,total_cols,space):\n",
    "    new_space = np.zeros((total_rows,total_cols),dtype=int)\n",
    "    # 1) First, we need to start moving through each cell of our 'space'.\n",
    "    #    To do this, we will use two nested 'for' loops\n",
    "    for row in range(total_rows):\n",
    "        for col in range(total_cols):\n",
    "            # So 'row' and 'col' define our current cell index.\n",
    "            # We now need to search a neighbourhood defined as 1 cell distance around this position\n",
    "            # We thus need two more nested for loops. When searching this neighbouring space, we want\n",
    "            # to count the number of 1's. Thus we also need a variable that we can increment by 1 \n",
    "            # everytime we find a value of 1. Lets call this integer variable count. \n",
    "            count = 0\n",
    "            for row2 in range(row-1,row+2): # See here that we can define a start and end to our 'range'\n",
    "                for col2 in range(col-1,col+2): \n",
    "                     # We need to check if our new position, defined by [row2,col2] is off the board\n",
    "                    if (row2<0) or (row2>=total_rows) or (col<0) or (col2>=total_cols):\n",
    "                        # Do nothing\n",
    "                        pass\n",
    "                    elif row2 == row and col2 == col:\n",
    "                        # Do nothing, its the cell we already have!\n",
    "                        pass\n",
    "                    # If we are not off the board or in the same cell as our starting point...\n",
    "                    # We can check if this new space has a value of 1. It it does, lets count it\n",
    "                    else:\n",
    "                        if space[row2,col2]>0:\n",
    "                            count=count+1\n",
    "            #-------'INSERT CODE HERE'-------\n",
    "            # Here you need to introduce conditional statements that act on the value of 'count'\n",
    "            # Read through the narrative provided above and remember to obey the spacing rules \n",
    "            # You will need to check the value of space[row,col] and then, depending on whether\n",
    "            # this is greater than 0 OR equals to 0, implement the rules of life. I have provided\n",
    "            # the first example. Please do try to complete this.\n",
    "            if space[row,col] > 0:\n",
    "                \n",
    "                \n",
    "            elif space[row,col] == 0:\n",
    "                \n",
    "                \n",
    "                \n",
    "            #--------------------------------\n",
    "                    \n",
    "    \n",
    "    return new_space\n",
    "\n",
    "# call the above function\n",
    "Beacon_new = search_each_cell(6,6,Beacon)\n",
    "\n",
    "print(\"Finished function call, now lets compare our pattern before and after...\")\n",
    "#Now visualise your results. \n",
    "\n",
    "plt.subplot(1, 2, 1).imshow(Beacon, cmap='binary') #The cmap, or colour map, gives us a black and white board.\n",
    "plt.title('Beacon - before')\n",
    "plt.subplot(1, 2, 2).imshow(Beacon_new, cmap='binary') #The cmap, or colour map, gives us a black and white board.\n",
    "plt.title('Beacon - after')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-success\">\n",
    "<b> Exercise 4 - Loop through 20 oscillations of the 'Beacon' lifeform <a name=\"Exercise4\"></a>  </b>  \n",
    "\n",
    "Now that we have build the function that can implement the 4 rules of life, all that is left for us to do is to call this function a set number of times to simulate evolution across our Universe. In the code box below, drop your conditional statements from above in the relevant place and click 'Run'. Do you see the Beacon shape oscillating? As before, I have provided the code for plotting but see if the syntax makes sense.\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np #import the numerical python library, numpy. Changing the referenced library to 'np' is solely for convenience\n",
    "import matplotlib.pyplot as plt #as per the above, much easier to write over and over again \n",
    "from matplotlib import animation, rc\n",
    "from IPython.display import HTML\n",
    "from IPython.display import clear_output\n",
    "import time\n",
    "\n",
    "#Initialise the Beacon matrix\n",
    "Beacon = np.zeros((6,6),dtype=int)\n",
    "\n",
    "#Enter values for '1' where you would like a black square\n",
    "Beacon [1,1]=1\n",
    "Beacon [1,2]=1\n",
    "Beacon [2,1]=1\n",
    "Beacon [3,4]=1\n",
    "Beacon [4,3]=1\n",
    "Beacon [4,4]=1\n",
    "\n",
    "# Now define a function that moves through through each cell in our 2D array and searches the neighbouring space \n",
    "# We pass three variables:\n",
    "# rows - Number of rows in our space to be searched\n",
    "# cols - Number of columns in our space to be searched\n",
    "# space - The 2D array space to be searched\n",
    "def search_each_cell(total_rows,total_cols,space):\n",
    "    new_space = np.zeros((total_rows,total_cols),dtype=int)\n",
    "    # 1) First, we need to start moving through each cell of our 'space'.\n",
    "    #    To do this, we will use two nested 'for' loops\n",
    "    for row in range(total_rows):\n",
    "        for col in range(total_cols):\n",
    "            # So 'row' and 'col' define our current cell index.\n",
    "            # We now need to search a neighbourhood defined as 1 cell distance around this position\n",
    "            # We thus need two more nested for loops. When searching this neighbouring space, we want\n",
    "            # to count the number of 1's. Thus we also need a variable that we can increment by 1 \n",
    "            # everytime we find a value of 1. Lets call this integer variable count\n",
    "            count = 0\n",
    "            for row2 in range(row-1,row+2): # See here that we can define a start and end to our 'range'\n",
    "                for col2 in range(col-1,col+2): \n",
    "                     # We need to check if our new position, defined by [row2,col2] is off the board\n",
    "                    if (row2<0) or (row2>=total_rows) or (col<0) or (col2>=total_cols):\n",
    "                        # Do nothing\n",
    "                        pass\n",
    "                    elif row2 == row and col2 == col:\n",
    "                        # Do nothing, its the cell we already have!\n",
    "                        pass\n",
    "                    # If we are not off the board or in the same cell as our starting point...\n",
    "                    # We can check if this new space has a value of 1. It it does, lets count it\n",
    "                    else:\n",
    "                        if space[row2,col2]>0:\n",
    "                            count=count+1\n",
    "            #-------'INSERT CODE HERE'-------\n",
    "            # Here you need to introduce conditional statements that act on the value of 'count'\n",
    "            # Read through the narrative provided above and remember to obey the spacing rules \n",
    "            if space[row,col] > 0:\n",
    "            \n",
    "            \n",
    "            elif space[row,col] == 0:\n",
    "            \n",
    "            \n",
    "            \n",
    "            #--------------------------------\n",
    "                    \n",
    "    \n",
    "    return new_space\n",
    "\n",
    "fig, ax2 = plt.subplots()\n",
    "plt.imshow(Beacon, cmap='binary') #The cmap, or colour map, gives us a black and white board.\n",
    "plt.title('Beacon oscillating')\n",
    "plt.show()\n",
    "\n",
    "# Let us call the function 20 times\n",
    "# Each time we are given a new shape to plot on our figure. \n",
    "# Wait 0.2 seconds before moving on to thje next iteration\n",
    "# We shpuld see oscillating behaviour.\n",
    "for x in range(20):\n",
    "    clear_output(wait=True)\n",
    "    Beacon_new = search_each_cell(6,6,Beacon)\n",
    "    Beacon = Beacon_new\n",
    "    plt.imshow(Beacon_new, cmap='binary') #The cmap, or colour map, gives us a black and white board.\n",
    "    plt.title('Beacon oscillating')\n",
    "    plt.show()\n",
    "    time.sleep(0.2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Populating Conway's Universe with multiple species <a name=#Part3></a>\n",
    "\n",
    "Now we are going to use the defintion of our shapes to populate a miniature Universe in 2D space! Once we have this, following the same procedure as above, we should see some interesting movement! So let's create a space that is big enough for all of our cell types. To do this, we need to create another matrix:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Universe=np.zeros((50,50),dtype=int)\n",
    "print(Universe)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You should now see a snapshot of the Universe matrix that is empty. How do we populate our Universe with individual species? We could enter a value for each cell but this is laborious. Rather, we are going to use our existing matrices that define our species and place them on the Universe grid. We do that by definining the exact space in the Universe we want our cells to go. This is practice in recognising the correct shape of an array/matrix and matching one to another. For example, look at the code below which places the top left corner of an LWSS on the cell in the 12th row and 13th column of my Universe and then visualises the results. Dont forget, indexing in Python starts at 0 so for the 12th row and 13th column, I need to refer to element [11,12]. Im also using the operator <code> : </code> which allows us to straddle cells bound by a start and a finish. Why have I chosen the range given below? Feel free to change the values, but if you get the size of space needed to fit in an LWSS, Python will complain it cannot broadcast a given shape:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Define the space in the Universe you would like your LWSS to appear\n",
    "Universe[11:17,12:19] = LWSS\n",
    "#Now visualise our Universe\n",
    "plt.imshow(Universe, cmap='binary') #The cmap, or colour map, gives us a black and white board.\n",
    "plt.title('Universe [with 1 LWSS]')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To finish this notebook, in the following code box we fill the Universe with a range of species and then run a simulation. Can you see how we have mapped species shapes into our Universe? It is left for you to copy the working function 'search_each_cell' from above to complete the simulation.\n",
    "\n",
    "Have a play with this! What happens if you increase the number of iterations to 300? Please note, we might want to clear our Universe from the above exercise, in which case we could write: Universe[:,:]=0, but let's keep it in for now. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Define the space in the Universe you would like your different species to appear\n",
    "Universe[30:36,32:39] = LWSS\n",
    "Universe[11:17,12:19] = LWSS\n",
    "Universe[22:28,12:18] = Beacon\n",
    "Universe[33:39,2:8] = Beacon\n",
    "Universe[19:25,32:38] = Toad\n",
    "Universe[1:6,1:6] = Glider\n",
    "Universe[6:11,25:30] = Boat\n",
    "plt.imshow(Universe, cmap='binary') #The cmap, or colour map, gives us a black and white board.\n",
    "plt.title('Universe [with multiple cell types]')\n",
    "plt.show()\n",
    "\n",
    "#-------'INSERT CODE HERE'-------\n",
    "def search_each_cell(total_rows,total_cols,space):\n",
    "\n",
    "    \n",
    "    \n",
    "#--------------------------------\n",
    "\n",
    "\n",
    "fig, ax2 = plt.subplots(figsize=(12, 12))\n",
    "plt.imshow(Universe, cmap='binary') #The cmap, or colour map, gives us a black and white board.\n",
    "plt.title('Universe simulation')\n",
    "plt.show()\n",
    "\n",
    "for x in range(100):\n",
    "    clear_output(wait=True)\n",
    "    Universe_new = search_each_cell(50,50,Universe)\n",
    "    Universe = Universe_new\n",
    "    plt.imshow(Universe_new, cmap='binary') #The cmap, or colour map, gives us a black and white board.\n",
    "    plt.title('Universe simulation')\n",
    "    plt.show()\n",
    "    time.sleep(0.2)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.12.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}