01 NonPythonic Spaghetti.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this notebook we will be writing our first CA simulator code, which we will subsequently build off of to demonstrate various aspects of scientific programming in Python. The code here will use no abstraction through functions or classes, and will not use any numpy. We will try our best though to follow the PEP8 style guide and make this code as readable as we can. \n",
    "\n",
    "Below we use the jupyter notebook as a development workspace, where we can try various approaches and run small tests to make sure code we write is doing what we want it to do. At the end we will collect all the pieces and put them in a single cell which will act as our code base script. Executing that cell will produce and plot a spacetime field of a given shape using the given ECA rule number."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First thing is to import all packages we will be using, which here is just the random package for random initial conditions and matplotlib to plot spacetime fields.\n",
    "The last line is a [\"magic\"](https://ipython.readthedocs.io/en/stable/interactive/magics.html) command that renders plots in the output cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-08-01T17:13:05.990435",
     "start_time": "2017-08-01T17:13:05.430320"
    }
   },
   "outputs": [],
   "source": [
    "import random\n",
    "from matplotlib import pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A CA spacetime field is uniquely determined by the initial condition, the update rule (known as the \"lookup table\"), the number of time steps the update rule is applied, and the boundary conditions. \n",
    "\n",
    "We will only use periodic boundary conditions so the three pieces we need for the simulator are an initial condition, the number of time steps, and the lookup table. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's start by producing a random binary string of a given length for our initial condition."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-08-01T15:39:36.982386",
     "start_time": "2017-08-01T15:39:36.979648"
    }
   },
   "outputs": [],
   "source": [
    "length = 20"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are several ways to create our initial condition without using numpy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-08-01T15:39:37.903647",
     "start_time": "2017-08-01T15:39:37.897682"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1]\n"
     ]
    }
   ],
   "source": [
    "# first, let's create an empty list and then build it up with random samples of (0,1)\n",
    "initial_condition_1 = []\n",
    "for i in range(length):\n",
    "    initial_condition_1.append(random.randint(0,1))\n",
    "print(initial_condition_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above is intuitive, but since it has to dynamically allocate memory space to the initial condition list as it grows it is not as efficient as it could be (it doesn't really make much of a difference for such a small array, but it is good to start thinking about what is going on under-the-hood in this way). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-08-01T15:39:38.813525",
     "start_time": "2017-08-01T15:39:38.808292"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1]\n"
     ]
    }
   ],
   "source": [
    "# next then, we can create a list of the given length, then populate it with random samples as so. \n",
    "initial_condition_2 = [0] * length \n",
    "for i in range(length):\n",
    "    initial_condition_2[i] = random.randint(0,1)\n",
    "print(initial_condition_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The more Pythonic way to do this is by using what is called a list comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-08-01T15:39:39.278343",
     "start_time": "2017-08-01T15:39:39.273338"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0]\n"
     ]
    }
   ],
   "source": [
    "initial_condition_3 = [random.randint(0,1) for _ in range(length)]\n",
    "print(initial_condition_3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a variable for how many time steps to evolve our CA. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-08-01T15:39:40.084181",
     "start_time": "2017-08-01T15:39:40.081331"
    }
   },
   "outputs": [],
   "source": [
    "time = 20"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Those were easy. Now we have to make the lookup table, which is less trivial. It may not be immediately obvious what data structure we should use for this. The lookup table maps neighborhoods to updated site values, so we will use a dictionary which maps keys to values. \n",
    "\n",
    "Dictionaries are the built-in implementation of [hash tables](https://en.wikipedia.org/wiki/Hash_table#In_programming_languages) in Python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The lookup table is defined by the CA rule number, following the Wolfram numbering convention: the eight possible neighborhood values are given in lexicographical order and the corresponding lookup table outputs for the neighborhoods (in order) are treated as the binary representation of an integer, which is the CA rule number. \n",
    "\n",
    "So first we need to convert our integer rule number to binary. We also need a list of the 8 possible neighborhoods given in lexicographical order. Since these will be the keys for our lookup table dictionary, they need to be tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-08-01T15:39:41.221311",
     "start_time": "2017-08-01T15:39:41.218623"
    }
   },
   "outputs": [],
   "source": [
    "rule_number = 18"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-08-01T15:39:41.650383",
     "start_time": "2017-08-01T15:39:41.645064"
    }
   },
   "outputs": [],
   "source": [
    "# list of neighborhood values, given as tuples, in lexicographical order\n",
    "neighborhoods = [(0,0,0), (0,0,1), (0,1,0), (0,1,1), (1,0,0), (1,0,1), (1,1,0), (1,1,1)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-08-01T15:39:42.030338",
     "start_time": "2017-08-01T15:39:42.025177"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0b10010\n",
      "01001\n"
     ]
    }
   ],
   "source": [
    "# first we will try bin() to convert the rule number to binary\n",
    "print(bin(rule_number))\n",
    "# cut off the fisrt two characters (0b), and flip the remaining string around so it is the proper order\n",
    "print(bin(rule_number)[2:][::-1]) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that the result is not 8 characters long. We need to pad it with zeros on the right so that all the neighborhoods have an output they map to. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-08-01T15:39:42.921260",
     "start_time": "2017-08-01T15:39:42.915288"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "01001000\n"
     ]
    }
   ],
   "source": [
    "# A simple, but not Pythonic, first thing we could do is this\n",
    "in_binary_1 = bin(rule_number)[2:][::-1]\n",
    "binary_length = len(in_binary_1)\n",
    "if binary_length != 8:\n",
    "    padding = 8 - binary_length\n",
    "    in_binary_1 = in_binary_1 + '0'*padding\n",
    "print(in_binary_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now build the lookup table dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-08-01T15:39:43.732295",
     "start_time": "2017-08-01T15:39:43.725430"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0, 0, 0) --> 0\n",
      "(0, 0, 1) --> 1\n",
      "(0, 1, 0) --> 0\n",
      "(0, 1, 1) --> 0\n",
      "(1, 0, 0) --> 1\n",
      "(1, 0, 1) --> 0\n",
      "(1, 1, 0) --> 0\n",
      "(1, 1, 1) --> 0\n"
     ]
    }
   ],
   "source": [
    "lookup_table_1 = {}\n",
    "for i in range(8):\n",
    "    key = neighborhoods[i]\n",
    "    val = in_binary_1[i]\n",
    "    lookup_table_1.update({key:val})\n",
    "for key, val in lookup_table_1.items():\n",
    "    print(key, '-->', val)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can do both of the above steps in a more Pythonic way using a try, except statement. This way we don't need to pad the binary conversion, since we know if there is an index error it would needed to be padded with 0. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-08-01T15:39:44.876410",
     "start_time": "2017-08-01T15:39:44.723538"
    }
   },
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "string index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-12-597f80937233>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m8\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m     \u001b[0mkey\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mneighborhoods\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mi\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 6\u001b[1;33m     \u001b[0mval\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0min_binary_2\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mi\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      7\u001b[0m     \u001b[0mlookup_table_2\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mupdate\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m{\u001b[0m\u001b[0mkey\u001b[0m\u001b[1;33m:\u001b[0m\u001b[0mval\u001b[0m\u001b[1;33m}\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mIndexError\u001b[0m: string index out of range"
     ]
    }
   ],
   "source": [
    "# if we try to create the dictionary without padding we get an IndexError\n",
    "in_binary_2 = bin(rule_number)[2:][::-1]\n",
    "lookup_table_2 ={}\n",
    "for i in range(8):\n",
    "    key = neighborhoods[i]\n",
    "    val = in_binary_2[i]\n",
    "    lookup_table_2.update({key:val})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-08-01T15:39:45.173034",
     "start_time": "2017-08-01T15:39:45.163341"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0, 0, 0) --> 0\n",
      "(0, 0, 1) --> 1\n",
      "(0, 1, 0) --> 0\n",
      "(0, 1, 1) --> 0\n",
      "(1, 0, 0) --> 1\n",
      "(1, 0, 1) --> 0\n",
      "(1, 1, 0) --> 0\n",
      "(1, 1, 1) --> 0\n"
     ]
    }
   ],
   "source": [
    "# use try, except statement to make val a 0 if the index runs over, where we had to pad before\n",
    "in_binary_2 = bin(rule_number)[2:][::-1]\n",
    "lookup_table_2 ={}\n",
    "for i in range(8):\n",
    "    key = neighborhoods[i]\n",
    "    try:\n",
    "        val = in_binary_2[i]\n",
    "    except IndexError:\n",
    "        val = '0'\n",
    "    lookup_table_2.update({key: val})\n",
    "for key, val in lookup_table_2.items():\n",
    "    print(key, '-->', val)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Better still, let's use string formatting to convert the rule number to binary and automatically pad with 0s as needed, then use zip and dict to create the lookup table."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-08-01T15:39:47.339829",
     "start_time": "2017-08-01T15:39:47.336099"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "00010010\n"
     ]
    }
   ],
   "source": [
    "in_binary_3 = '{:{fill}{align}{width}b}'.format(rule_number, fill='0', align='>', width='8')\n",
    "print(in_binary_3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "since the string formatting also gives the binary result in the opposite order of what we want, use the reversed function in zip, so that it iterates through in the order we need\n",
    "\n",
    "### This is the Pythonic way of implementing a CA lookup table using a dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-08-01T15:39:47.770923",
     "start_time": "2017-08-01T15:39:47.765230"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0, 0, 0) --> 0\n",
      "(0, 0, 1) --> 1\n",
      "(0, 1, 0) --> 0\n",
      "(0, 1, 1) --> 0\n",
      "(1, 0, 0) --> 1\n",
      "(1, 0, 1) --> 0\n",
      "(1, 1, 0) --> 0\n",
      "(1, 1, 1) --> 0\n"
     ]
    }
   ],
   "source": [
    "lookup_table_3 = dict(zip(neighborhoods, reversed(in_binary_3)))\n",
    "\n",
    "for key, val in lookup_table_3.items():\n",
    "    print(key, '-->', val)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "note that because we use string formatting to create the binary representation of the rule number, the lookup table outputs are strings, and we will convert them to ints later"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "print(type(lookup_table_3[(0,0,0)]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now have all the pieces we need, so let's put them together to make a spacetime field"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "spacetime field will be a list of lists, so that spacetime_field[t] is the lattice configuration at time t initialize with the initial condition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-08-01T15:39:50.534158",
     "start_time": "2017-08-01T15:39:50.530958"
    }
   },
   "outputs": [],
   "source": [
    "spacetime_field = [initial_condition_3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-08-01T15:39:50.941117",
     "start_time": "2017-08-01T15:39:50.936368"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0]]\n",
      "[0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0]\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(spacetime_field)\n",
    "print(spacetime_field[0]) \n",
    "print(spacetime_field[0] == initial_condition_3) # spacetime field at time 0 should be the initial condition"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "for implementation of the update rule, we will need a variable to keep track of the current configuration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-08-01T15:39:51.628399",
     "start_time": "2017-08-01T15:39:51.625222"
    }
   },
   "outputs": [],
   "source": [
    "# We have to be careful though to COPY the list, and not just use the equals sign (which just sets a new pointer)\n",
    "current_configuration = initial_condition_3.copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-08-01T15:39:52.202651",
     "start_time": "2017-08-01T15:39:52.199454"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0]\n"
     ]
    }
   ],
   "source": [
    "print(current_configuration)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "we will also need a new_configuration placeholder "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_configuration = []"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "now iterate through the current configuration, get the neighborhood, and apply the lookup table"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-08-01T15:39:52.778797",
     "start_time": "2017-08-01T15:39:52.771242"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]\n"
     ]
    }
   ],
   "source": [
    "for i in range(len(current_configuration)):\n",
    "    \n",
    "    neighborhood = (current_configuration[(i-1)], \n",
    "                    current_configuration[i], \n",
    "                    current_configuration[(i+1)%length]) # use % for periodic boundary condition\n",
    "    \n",
    "    new_configuration.append(int(lookup_table_3[neighborhood]))\n",
    "print(new_configuration)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "now the do the same as above for the given number of time steps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-08-01T15:39:53.706605",
     "start_time": "2017-08-01T15:39:53.696303"
    }
   },
   "outputs": [],
   "source": [
    "for t in range(time):\n",
    "    new_configuration = []\n",
    "    for i in range(len(current_configuration)):\n",
    "        \n",
    "        neighborhood = (current_configuration[(i-1)], \n",
    "                        current_configuration[i], \n",
    "                        current_configuration[(i+1)%length])\n",
    "        \n",
    "        new_configuration.append(int(lookup_table_3[neighborhood]))\n",
    "    # update the current configuration    \n",
    "    current_configuration = new_configuration # here we don't want to keep making new copies, so use '='\n",
    "    # add the new configuration to the spacetime field\n",
    "    spacetime_field.append(new_configuration)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Take a look out our spacetime field"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-08-01T15:39:54.731419",
     "start_time": "2017-08-01T15:39:54.727013"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0]\n",
      "[1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]\n",
      "[0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0]\n",
      "[1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1]\n",
      "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0]\n",
      "[0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0]\n",
      "[0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0]\n",
      "[0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1]\n",
      "[1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0]\n",
      "[0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1]\n",
      "[0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0]\n",
      "[0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]\n",
      "[0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0]\n",
      "[0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1]\n",
      "[0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0]\n",
      "[0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0]\n",
      "[1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0]\n",
      "[0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0]\n",
      "[0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0]\n",
      "[0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1]\n",
      "[1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0]\n"
     ]
    }
   ],
   "source": [
    "for config in spacetime_field:\n",
    "    print(config)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, make a spacetime diagram"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-08-01T15:39:58.091678",
     "start_time": "2017-08-01T15:39:57.471049"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x864 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(12,12))\n",
    "plt.imshow(spacetime_field, cmap=plt.cm.Greys, interpolation='nearest')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Looks like rule 18!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now collect all the final results so that we can run everything in a single cell (like a .py script) to chose our parameters and create the corresponding spacetime diagram. \n",
    "\n",
    "To maximize spaghettiness and make it look gross, I'm going to use the non-pythonic implementations from above, so if you are skipping down to this part be sure to go back up and see some better code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-08-01T17:13:11.212858",
     "start_time": "2017-08-01T17:13:10.421599"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAq4AAAKsCAYAAAAtNz8NAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nO3dX6yv2VkX8GfZA/IvRCrTOrTF1qQqDQnCPiGohBALEZXQ3rQWQzLhT3qDAkaDBS+IFyaNGgMXhmRSIEMgQAPENgYRHDXiTWUfasKfijSltgNDZ7QoyAVQWV7sbTwdz/4Nv7XXXut5fr/PJ2nOnH3OXmu977ve9/fN2/08p/XeAwAAsvsjuxcAAAB/GIIrAAAlCK4AAJQguAIAUILgCgBACYIrAAAl3LurgVtrXxER3xURL4mId/Te337g707ryXVxcXH09zx48GDJeIfGOrSGWWPNnP/Fxps5z243HWfmY9l9bVbdh7Ovwci6b5L5fM4085ytMnuvZf2ceLHxjp1j5n04+zhH5jmH+Q+tIfMz98GDB/+t9/7Yo/6s3UUf19baSyLiv0TEl0fEMxHxsxHx1b33X7rh709bxMjxtNaWjHdorENrmDXWzPlfbLyZ8+x203FmPpbd12bVfTj7Gsx8HmY+nzNV7AU+e69l/Zx4sfGOnWPmfTj7OEfmOYf5D60h8zO3tfag937/UX92Vz8q8IUR8f7e+wd6778XET8cEW+4o7kAADgDdxVcXxERH37o989cfw0AAIbc1c+4Pupd8se9D26tvTUi3npH8wMAcGLuKrg+ExGveuj3r4yIX3/4L/Ten4yIJyPm/owrAACn6a6C689GxGtba6+JiF+LiLdExN84dpDZP7w984eKz33+2fPsLvA4tObMx7NqH8z8Qf2Kaz5k99oUVt5s93Ny9/yz59l9bjJkgqz37uzPsMxru5Pg2nv/WGvtb0bEv4qrdljf23v/xbuYCwCA83BnfVx77z8RET9xV+MDAHBe/MtZAACUILgCAFCC4AoAQAmCKwAAJdxZcdYMu9t1jI63u7XTTLPbWOy2u/3JiIr3QYYWTbtb98wcL/Ne263qXpv5OTFzbRk+v25a87k8C2ePl3WvRYx9vnrjCgBACYIrAAAlCK4AAJQguAIAUILgCgBACam7CmSobrxJxerbQzJU5s6UuaJ85jyZ75GbrKoMHqlWPaVroCPIunlWdR7JvLZjndK9lkHVvTYyjzeuAACUILgCAFCC4AoAQAmCKwAAJQiuAACUILgCAFBC6nZYGexuGTJT5nYyq+aZ2U5lVVunijKcm1NqHXTIubeyO3QsN42VYa+tGOsuxqs2/6k5tb028sz1xhUAgBIEVwAAShBcAQAoQXAFAKAEwRUAgBJ0FYjTq3pcVdmXtco4w/wq2m82s7PDiAx7+lindq/troxetQdn77XdXVFmjjXSDeJcZK72nz3/yNq8cQUAoATBFQCAEgRXAABKEFwBAChBcAUAoATBFQCAEs6qHdYptSiq2i7jpnl2t1PZffyja1gl89puUvF+18oub8un2fOs2mu7216tGKuqU7s/Vt0H3rgCAFCC4AoAQAmCKwAAJQiuAACUILgCAFDCyXUVyFAlt3v+3VWHqzoErFrbiMxVxjc5lzWvHG/FPLs7YlR8RmaYZ/cemDnWzM+c0TVkleFYdu+P2eN54woAQAmCKwAAJQiuAACUILgCAFCC4AoAQAmCKwAAJZRth7W7ZUeGlhC759/dYmN2C5abrGoDVLGtT+Y1777frXnuPPZa7rXtHCuD3e0EM3werdpr3rgCAFCC4AoAQAmCKwAAJQiuAACUILgCAFBC6q4CGaoOd1dR7q46XFW5f8iKfZD53FS81hmqYkdUXHfmNa9Y26F9u6ojyIjdnwc3yVCdntnuc13x2T57PG9cAQAoQXAFAKAEwRUAgBIEVwAAShBcAQAoQXAFAKCEFO2wLi4u4vLycspYGVrDVGyXsVvm9jyrVLzWu9u57J5/1LFryLzmVWvLOv/s71k13u6xRtqYrZLhfjvWuey1CG9cAQAoQnAFAKAEwRUAgBIEVwAAShBcAQAoIUVXgRFVq4mzOrWq/mPnWVXhmmEPrrh3ZldtZ6joXjF/xTXPvnd237sVP1tm3juZu1HMlmENx9r9ebRyvJt44woAQAmCKwAAJQiuAACUILgCAFCC4AoAQAmCKwAAJaRuh7WqxUjFlhgjsraiihhraaMtyNz5q+6PmU6tFdLM7zn3+TN8tsxc9+5rULUF4YrnZOZ9M9vI2rxxBQCgBMEVAIASBFcAAEoQXAEAKEFwBQCghLaqcuzgIlqbtojZ1YAZzs+xZlYk7q6uPCRz1eNNRs5n5j29ag9UXPMhxx5PxfNc1e77cPf+rPrMz7y2m2R+fid45j7ovd9/1B944woAQAmCKwAAJQiuAACUILgCAFCC4AoAQAmCKwAAJdzbvYCIiIuLi7i8vDzqe25qr7C7JcYqs9tozDyfs1vqrLimmc9nhj197BpWtYaZPd7uFjCr1pxhT+2U4T7Muj93r+vQGjKvbdbfvwur1rCqLZw3rgAAlCC4AgBQguAKAEAJgisAACUIrgAAlJCiq8BNVNjOXduqyvkRmaseZ441u8L1JhmqplfMk+HezXquM5yb3TLfozfZ3b0g8zM/89pWVdTPnH9EhueKN64AAJQguAIAUILgCgBACYIrAAAlCK4AAJTQdldQRkS01qYtYnbVYdYq8N3//vIhqyo/Z86z6nxmvm6HzKx+XWVkzTOPc8W/Kz9bhs+DY80+N1mf+RF578NVz/wRuzPB7uOPWLdvJj9zH/Te7z/qz7xxBQCgBMEVAIASBFcAAEoQXAEAKEFwBQCgBMEVAIAS7u1ewCEjbSwytJ64ye61zW79MfMaVLzWq+Zf1Yrp0Dy724vdZOaaR79npgzXOquK7aNmz5O1LdvudR1aQ+Zrvapl3qp7Z9Uz1xtXAABKEFwBAChBcAUAoATBFQCAEgRXAABKSN1VoGqF7e7q15nHk7lDwKprnbkqddU8FauzM3Q2mPk9Gee4C7ufX6vmWVVRvmKskWf+iAyfE7vvq8wdAlbtaW9cAQAoQXAFAKAEwRUAgBIEVwAAShBcAQAoQXAFAKCE1O2wZrfY2N2WY+Z4u1tVHFpDhnYqu8/n7nOze39mnWPUqufNqrY1u+1+fu3+/BiV9TOs4vNmdJ5j92GGvZa5BeLIeN64AgBQguAKAEAJgisAACUIrgAAlCC4AgBQwnBXgdbaqyLi+yPiT0TEH0TEk73372qtvTQifiQiXh0RH4yIN/fef3NwjiXfM3u82dX7x9pdLbqqCn7VtanYIWDVHtx93are77uvdeaq7d3z796fu/f0qXWfybzXdz/bV3UrmX0NbvPG9WMR8Xd6758TEV8UEd/YWntdRLwtIp7uvb82Ip6+/j0AANzKcHDtvT/be/+56//+7Yh4X0S8IiLeEBFPXf+1pyLijbddJAAATPkZ19baqyPi8yPiPRHx8t77sxFX4TYiXjZjDgAAztut/+Ws1tqnRcSPRcS39N5/6w/7swyttbdGxFtvOz8AAOfhVm9cW2ufEFeh9Qd77z9+/eWPtNYev/7zxyPiuUd9b+/9yd77/d77/dusAQCA8zAcXNvVq9XviYj39d7/6UN/9O6IeOL6v5+IiHeNLw8AAK600dYKrbUvjoifiYifj6t2WBER3x5XP+f6zoj47Ij4UES8qff+0UNj3b9/v19eXg6tY5dDPxKxohXRqlYiq6xqwTKzbc2q8zkyz6rzmdmqFlor9tTI8yZza62Zezrzcc62ohVS5j0wYve1nj3/7uuz8Pn54Kb/R374Z1x77/8hIm46gtePjgsAAI/iX84CAKAEwRUAgBIEVwAAShBcAQAo4db/AMGp211JOnP+VdW3s9cwc6zd849U0q7agxn2x7EOrXlVJe3uPZV5f8wcK/Nxrqj2zzDe7rFmdyLYXW2/+3zOHm9VJwJvXAEAKEFwBQCgBMEVAIASBFcAAEoQXAEAKEFwBQCgBO2wYn/Lq5E1nFqbqtnjZW3TVLUFzG6ZW1vt3msjVu3P3Xa3mDsk6zM3wx6Yed12fx7tnj9iXbu2VfeVN64AAJQguAIAUILgCgBACYIrAAAlCK4AAJRwVl0FVlUmz5x/pgzVjSvGWmVVh4BVe21294JjZdifM+/33SrugRGrqqwzPPMzV5SvGCtzB4vdMu+12WvzxhUAgBIEVwAAShBcAQAoQXAFAKAEwRUAgBIEVwAASji5dlgZWkLsbiNxLi1LVrXnObXzObPt1sz5D1nV0idry6dDdu/PVTLvz8x7eudYdzHeuXOtvXEFAKAIwRUAgBIEVwAAShBcAQAoQXAFAKCEsl0FdldxjphZzZzh+DNX+a6YI/P5nH08K/bnbLu7e8x0avtz5jwj+3bV+cxctb17rJnPm1OTYd9k7XoR4Y0rAABFCK4AAJQguAIAUILgCgBACYIrAAAlCK4AAJSQuh1W1ZYYp9R6ImsLnOzzrJp/97Xe3XIq8/k0/5p5MrRi2n08M8db1UZt917P4JSywl2MdxNvXAEAKEFwBQCgBMEVAIASBFcAAEoQXAEAKKHNriAcWkRrRy9ipDI5czXesWvLUEm7ap6ZVejHznFonlXnc8Tu+3r38Uesu99H5plZ6b17f66630dk2IczrTg3K/bzi80zc2277c4Ko2tY8bn7IvM86L3ff9SfeeMKAEAJgisAACUIrgAAlCC4AgBQguAKAEAJ93YvYFTmf1M767/FvqryM8O/f3zsNVh1bVb9O+Cr7D4HGfZa1rGq3u/H2r0HZ7OnazqlrDA63sjxjMzjjSsAACUIrgAAlCC4AgBQguAKAEAJgisAACUIrgAAlJCiHdbFxUVcXl5OGatqG4ljv2dVW6XMrWZmttjI3KYqQ9uY3WvIfD4z3yM32X2/Z3hO75Z1T2fYz5mv9e5zvfv6zG5tNdJCyxtXAABKEFwBAChBcAUAoATBFQCAEgRXAABKSNFVYETFarwRuysYDx3/qsrPVZWKx8pQnb57/pnnOcP5XFV9u0KG+313h5WK12D2eFn39O5rc8ju8zwi816bvTZvXAEAKEFwBQCgBMEVAIASBFcAAEoQXAEAKEFwBQCghNTtsFa1pMjQliNrm5HMLa9Wjbd7rAwtinbPn7Wlz12Mt3P+zNfzpnl2n//RNWTd06d2fxySeW03ca29cQUAoAjBFQCAEgRXAABKEFwBAChBcAUAoIQ2s7JxeBGtTVvE7ArsrJWfI2Zf65uO51yuwarzucruZ8Gh41/VLeSmeWZfm2OPZ/d9M2rFM2JkrAzdZ05tTx8r83VbtbZj51hp1fEc2J8Peu/3H/Vn3rgCAFCC4AoAQAmCKwAAJQiuAACUILgCAFCC4AoAQAn3di/gkJGWFBnaSOxuXTPzHIyMVfEazG7hNXOsU2u7tft8zh5vZruh3ddmxO7jtAfmjrfqebP7OFeNNXuerFlhdLyR7/HGFQCAEgRXAABKEFwBAChBcAUAoATBFQCAElJ3FVhVcZeh8nP3/BWrGzNXkZ7a/tg9f+b9uWLvrup6ccjuazAic0X77vO5+/m5qmvQ7q4su5/Fs9eQIZd54woAQAmCKwAAJQiuAACUILgCAFCC4AoAQAmCKwAAJaRuhzW7BczuliWn1vJp1Rp2t0BZ1Zpl9/4YkfXarBwv616bOX9mu6/ZbBn2dNaxVrWF2/05leGzIPMzxxtXAABKEFwBAChBcAUAoATBFQCAEgRXAABKSN1VYHdl3+g8K9a9qiq26jVYMdZIhWuG85mhYnXn/LuPZWQNGa7nzAroERmu20xZ93SGLg2rumusONbdWSFif16Yfd28cQUAoATBFQCAEgRXAABKEFwBAChBcAUAoATBFQCAElK0w7q4uIjLy8s7n6di64nMrWYyry3rWJnbxuxukZS51c3u49k9/12MN2ue2a3CZspwDbJ+HmVuQTjilK7N7Hlmt7v0xhUAgBIEVwAAShBcAQAoQXAFAKAEwRUAgBJSdBWYKUP17YgVa9hd9XhoDburb1cd56qxMl+33cdzaP6Kx7Pb7mdu1ed31ory3c/i2WPNrmjfvd8ydw9YxRtXAABKEFwBAChBcAUAoATBFQCAEgRXAABKEFwBACjh1u2wWmsviYjLiPi13vtXttZeGhE/EhGvjogPRsSbe++/edt5HjHv0d+zu/3IubSx2H1tDtndmmXleCvm331PzR4v8/HsVrFVWOb7ffcado+VoQXhinWfWlY4dPyr1j3jjes3R8T7Hvr92yLi6d77ayPi6evfAwDArdwquLbWXhkRfy0i3vHQl98QEU9d//dTEfHG28wBAAARt3/j+p0R8a0R8QcPfe3lvfdnIyKuf33Zo76xtfbW1tpla+3y+eefv+UyAAA4dcPBtbX2lRHxXO/9wcj3996f7L3f773ff+yxx0aXAQDAmbhNcdZfjIivaq391Yj4pIj49NbaD0TER1prj/fen22tPR4Rz81YKAAA5204uPbevy0ivi0iorX2pRHxd3vvX9Na+8cR8UREvP3613eNzlG1inNmpd5NY2WoBsxwfW6yu2J25lindt12n8/ZMqxhllXV4Zn3wIrn9+z5Z46Xodp/5liZK/RX7bXd12C2u+jj+vaI+PLW2q9ExJdf/x4AAG7l1n1cIyJ67/8uIv7d9X//94h4/YxxAQDg//IvZwEAUILgCgBACYIrAAAlCK4AAJTQZre+GFpEa0cvYqQlxMyWJbtbwMxukTTTyNp2n88RmdvGjJh53XYfS8T+Z8Qhu5+7mZ9FmffUbjP3ze5n8ap9M2LV/bFi/tE1jJi8px703u8/6s+8cQUAoATBFQCAEgRXAABKEFwBAChBcAUAoIQp/+TrDiNVd6uqUldU0u6uujy0htnnefexzjye3cdyaA2r7qlV12b38eyugl9V6b37ft/doWG23eez4lgr1zDzft89/4gM+9MbVwAAShBcAQAoQXAFAKAEwRUAgBIEVwAASkjRVeDi4iIuLy93L+ORKlbS7q78zFCZfKzd13O2zNX+q8bL3L1gpsz3+0y7z/Nsu6/bzLEy74Hdz6Ld82eYZ/aavXEFAKAEwRUAgBIEVwAAShBcAQAoQXAFAKAEwRUAgBJStMParWL7j8wtNladz92tUVa1Cpu9hpl2n8/ZZl7T3edm9jOqYhue3TI8pzO3uZs5z+5zs1vVczayBm9cAQAoQXAFAKAEwRUAgBIEVwAAShBcAQAo4ay6CmSuVj12bSPV6VUrCFd8z6rjzFD5ubt7we7K/QyV3ivGyjz/7uOcbfezteIezNx9JrMMz7zd83vjCgBACYIrAAAlCK4AAJQguAIAUILgCgBACYIrAAAlnFw7rAytg7KOlfk4K7ZG2d0C59AaMl+DkfnP/XgytzebPc/M1mcz7Z5/9hoy74HM86yw+9k1uoZV18AbVwAAShBcAQAoQXAFAKAEwRUAgBIEVwAASijbVSBzdeXuisCZleYj8xyyqhNA5v2xYv4MFaYzx1pV7b9qvGMr5zN0Vcj8XNk9/8xOCLvP56o9kGGv7bb7eDI/Vw7xxhUAgBIEVwAAShBcAQAoQXAFAKAEwRUAgBIEVwAASkjdDmt325xDa6jYxiJz+5HdbWMytPiouKdWjJVhDZlbFM2cP8Mz9yandD1Hvydr28QMLbSOnX+Vqp8tM8/17GvgjSsAACUIrgAAlCC4AgBQguAKAEAJgisAACW0VRWhBxfR2rRFrKo6nD3PTePtrojMUMW5e49mvgY3rW12VepMI3s96/0RsabSO8NzbebaDpnZcWF35f6IkftgdLxj55h5v2V4rq24d6ua+cwdvG4Peu/3H/UH3rgCAFCC4AoAQAmCKwAAJQiuAACUILgCAFCC4AoAQAn3di8gIuLi4iIuLy+P+p6Rlgyr2lWsWNvuFjSj35O1rdHuViqH1rD72ow4NP+pHc/u8bKOtWqe3c+OUVnPwap2R5k/w2euYXd7tUNmP6dXjBXhjSsAAEUIrgAAlCC4AgBQguAKAEAJgisAACWk6CpwkwzVxzMrIkeqC3dX9mWupj6X+TN0kJg5lmr/NWNl2DcZ1v0oFbsnjI634n7bva5DMnzu7XZq18cbVwAAShBcAQAoQXAFAKAEwRUAgBIEVwAAShBcAQAooa1qeXBwEa0dvYjdraVGWmiNfM/M+UfHW+HQmldc693X85BVe/1cjidDq5sVLYp2PyNH7W6Xtnt/jpj5/Fz17MjQrm3Esc+VzG2lDtl9H0bEg977/Uf9gTeuAACUILgCAFCC4AoAQAmCKwAAJQiuAACUcG/3AiIiLi4u4vLy8v/7+kgl2qqKyFVrWzHWSlnPQea9NnsNM8eaWbk/e09nrvTeOdboeOdybnbPs2oNWceaPc/sLhG798Hu5/Qhq9bmjSsAACUIrgAAlCC4AgBQguAKAEAJgisAACUIrgAAlNBmtjgZXkRr+xdxpAzn7ViH2ktkbXUzavf12X0OZh//KR3P7Psgc3uamSqem1XneWSerHtg1bNjdmvAm8ye59jrtuq+mS3BvfOg937/UX/mjSsAACUIrgAAlCC4AgBQguAKAEAJgisAACXc272AQ3ZXhkfkqO471qo1z6zIXDX/TLuPf3QNM8fKfD13n5uZ4616Fo4c5+5zM3uskWrqVect6/2W4fhvGu9c9ufs+TPfO964AgBQguAKAEAJgisAACUIrgAAlCC4AgBQguAKAEAJqdthrbK7rdKIzC2vTm0Npzb/KR1PhnOTtUXR7Hl2n5uZVrUBGpFhT88ca+TczGxttbuV3O7n7egaVrW2GpnHG1cAAEoQXAEAKEFwBQCgBMEVAIASBFcAAEo4q64CGar7jnVq1YAz559pdrXq7nOw+3gyVEafS6X3zDlmVoBnsPu5dsju+33FWLPnmf3MHXHsPKvuqQz7c1X28MYVAIASBFcAAEoQXAEAKEFwBQCgBMEVAIASTq6rwLlUKs4ea1U14O4q393neXd1/KE1VDyeDJW0K8Y6p3mOdU57YPf9dpPZnxMrxqo6z+49kKE7kTeuAACUILgCAFCC4AoAQAmCKwAAJQiuAACUILgCAFDCrdphtdb+WES8IyI+NyJ6RHxdRPxyRPxIRLw6Ij4YEW/uvf/mrVb56LlTjjV7noptLEbsbru1omXMi9m9p7WpWjfesS1gVrX5y9ryKiL3ns68tpl2H+chu1tLrbp3b1LxuTY6z23fuH5XRPxk7/3PRsTnRcT7IuJtEfF07/21EfH09e8BAOBWhoNra+3TI+JLIuJ7IiJ677/Xe/8fEfGGiHjq+q89FRFvvO0iAQDgNm9c/1REPB8R39dae29r7R2ttU+NiJf33p+NiLj+9WWP+ubW2ltba5ettctbrAEAgDNxm+B6LyK+ICK+u/f++RHxO3HEjwX03p/svd/vvd+/xRoAADgTtwmuz0TEM73391z//kfjKsh+pLX2eETE9a/P3W6JAABwi64CvfffaK19uLX2Z3rvvxwRr4+IX7r+3xMR8fbrX981OkeGCsZVlYozraoGHLH7mla8NivH2zl/hnOTtQp9VYeAqtXMu+fP/PzMOMeoDJ/HK+7dmfOvGmt0vJF751btsCLib0XED7bWPjEiPhARXxtXb3Hf2Vr7+oj4UES86ZZzAADA7YJr7/0/RcSjfkb19bcZFwAAXsi/nAUAQAmCKwAAJQiuAACUILgCAFDCbbsK3KnZbSRmjjW71cyx42VoY7FirKpr2H0+T60FS+aWaCtawNgDc1tOZdgDK8aaPU/mtl+zW2Eea+a9e2rnc2ZrwAhvXAEAKEJwBQCgBMEVAIASBFcAAEoQXAEAKCF1V4GqlXW7qwszVwNmrgxeMf/sytdz2Wu7x9u9tpEOARnuqd3XIPOeXvX83H0NVoy10sx7d7cM9/vInvbGFQCAEgRXAABKEFwBAChBcAUAoATBFQCAEgRXAABKSN0Oa1ULmBGZ26ysGm9VaxZtt/K23TqlsUbHW3Ff717Xqcm8b1a10JopQ9uvmXY/82c7tWeuN64AAJQguAIAUILgCgBACYIrAAAlCK4AAJSQuqvAqgrK2RWRM51aNeCqzgrHrm32sZxL94IVY42Od0pdPGbvtXNxLns6c7X9qu4JIypeg5tk3p+z5/fGFQCAEgRXAABKEFwBAChBcAUAoATBFQCAEgRXAABKSN0OK0O7odnttWZ+z8yxTql1UMSa48mwB+21/Xut2linJsMeyNrmb/b8q8ab2XIqw/Hsnv/UnrneuAIAUILgCgBACYIrAAAlCK4AAJQguAIAUELqrgIZKghnzqMacM1Yq+afeW0OrcFey73XTu1cZ3Vq57litX3m7gmZj2fnWBnWMPt4vHEFAKAEwRUAgBIEVwAAShBcAQAoQXAFAKAEwRUAgBJStMO6uLiIy8vLbfPPbssx0mIja+sJLWDm2t2yZXQN1cYaHU97nP12H2vm6+aZt2b+VeOd2ufhquPxxhUAgBIEVwAAShBcAQAoQXAFAKAEwRUAgBJSdBVY5ZQq+DJXA86ef8W5PnQsu6/1iAz7Y+ZYqoxPyyk9i0fHm90tZJYM53NE1vsww17bvT9nnwNvXAEAKEFwBQCgBMEVAIASBFcAAEoQXAEAKEFwBQCghJNrh1W19cTMsTK3sch6PBlajNhr+/fairFGxpu9b1bZfQ1ObU/PtPt87n7ejY6XtY3ZiAznc4Q3rgAAlCC4AgBQguAKAEAJgisAACUIrgAAlFC2q4BqwLzVgBkqaWdWbc+cf3cl76is+yPDfZC168Uqu8/ZiAz7ZpUVz8JDc1R85mW+niMyP3NHeOMKAEAJgisAACUIrgAAlCC4AgBQguAKAEAJqbsKZKhe2y1zNeCp/bvVK+ZX7b9uvMxVxjMrvVfdB7vvtxGZ9/RMmffAKd2HmWU4NzM/3w/xxhUAgBIEVwAAShBcAQAoQXAFAKAEwRUAgBIEVwAASmiz2/MMLaK1oxcx0nYhw7HeZHdbjswtS0Ycuz9WtRsaOc+zW9Dsvj6r9truc13xPK/aa+f+vDn0PdF8lsEAABCQSURBVIdU3J+ndpy7c8SptSQ7cN0e9N7vP+rPvHEFAKAEwRUAgBIEVwAAShBcAQAoQXAFAKCEe7sXMCpDJemxTq0aMPPxHLu2DJX7M69P5muze7wMa9t9rjOfz5nzZH3ejM6zYrxVXQB2H2fE/o4LN9k9/+gaRs7nyDzeuAIAUILgCgBACYIrAAAlCK4AAJQguAIAUILgCgBACSnaYV1cXMTl5eWUsaq2kcg6/+5jGV3DijY4q1rAzDyW0TVUG2t0vN1tqmaOtfv4R9ew+5mTuQ3Q7v1ZcR+uamM2YncLr8zP3ENjeeMKAEAJgisAACUIrgAAlCC4AgBQguAKAEAJKboKjDilasCR8apWA86cf6bdla+ja1gx1uzxdp9r52b/mk/tebP7eA5Z8dmyew+OjrfiGmQ4zlN75nrjCgBACYIrAAAlCK4AAJQguAIAUILgCgBACYIrAAAlpG6HtbtF0uw1nFobi93Hk6ENzu75d+/PzC1Tdp+bleOtmGN3m6Tdz5sRs5+fM8da1cJq93GuGm/3XhuR+Xwe4o0rAAAlCK4AAJQguAIAUILgCgBACYIrAAAltN1VbRERrbWjFzFSaT6zOn33eRs5ztHxZs4zc/6ZDh3LTWsb+Z5VZu/PkXNw7FiHzLx3Z1vxLMhwnCOyPnMzPz9XXevd889W8fNoVY7IvD8PzPOg937/UX/mjSsAACUIrgAAlCC4AgBQguAKAEAJgisAACUIrgAAlHBv9wJGjbRkqNjmY+aaMxx/1jY4q/bTqjZVpzTW6HgV2+PsPs4Rh9a8+5ljT8995mXea6vGO/YcZH52zB5vpIXWyDzeuAIAUILgCgBACYIrAAAlCK4AAJQguAIAUMKtugq01v52RHxDRPSI+PmI+NqI+JSI+JGIeHVEfDAi3tx7/81D41xcXMTl5eVtlnJnKlYErqoGnDn/bMeu4Vyq/WePt7syOfO5yTDPTLur4Gf9/bsYb/ee3v3Mn233M+rU5lm1P1ftw+E3rq21V0TEN0XE/d7750bESyLiLRHxtoh4uvf+2oh4+vr3AABwK7f9UYF7EfHJrbV7cfWm9dcj4g0R8dT1nz8VEW+85RwAADAeXHvvvxYR/yQiPhQRz0bE/+y9/1REvLz3/uz133k2Il72qO9vrb21tXbZWrt8/vnnR5cBAMCZuM2PCnxGXL1dfU1EfFZEfGpr7Wv+sN/fe3+y936/937/scceG10GAABn4jY/KvBlEfGrvffne++/HxE/HhF/ISI+0lp7PCLi+tfnbr9MAADO3W2C64ci4otaa5/Srsq/Xh8R74uId0fEE9d/54mIeNftlggAALdoh9V7f09r7Ucj4uci4mMR8d6IeDIiPi0i3tla+/q4CrdvmrHQu6SNRc0WLLvbtmRowzNzrN0tfVaNV/F+z7zmVfPY0zXvg1Xzr7rfVpy33ddmdA2rnl+36uPae/+OiPiOF3z5d+Pq7SsAAEzjX84CAKAEwRUAgBIEVwAAShBcAQAo4VbFWdVkrpjdPb/uBXPnnznWzGszuoZqY42Ot7vKOPMzatW5OXa/Z9g3M8eafb8fK8P5zPx5NHN/ntJn212MdxNvXAEAKEFwBQCgBMEVAIASBFcAAEoQXAEAKEFwBQCghJNrhzW7vcVN462aZ9bfvwun1OZk97GMrmHFWLPH232ud7fHGVG11U3W1j0Zzs1umc/nqjXs3p+rWsztfq7N3h/euAIAUILgCgBACYIrAAAlCK4AAJQguAIAUELZrgK7KyJXdSKoWCk52ylVRGauZj6l8zw63sx7Z8TuZ8SIDBXQM8da0SUiIveemjlW5s+j3WvYvT8znM8R3rgCAFCC4AoAQAmCKwAAJQiuAACUILgCAFCC4AoAQAmp22HtbhVxaA2715ahBU3mNie75z+llimja6g21l2MN2uekeuZ4dysai11rKzXeeU85/J5VFGGe3fFWKO8cQUAoATBFQCAEgRXAABKEFwBAChBcAUAoISWoRKvtTZtEauqbw/Nc9N4Gda2Yv7ZRroXzOx4MNOqav/de233eY5Ydx+sOAcjz5uR8WZft92fL6uen5mv9cg8M+fffR9mlvneHTH5s/pB7/3+o/7MG1cAAEoQXAEAKEFwBQCgBMEVAIASBFcAAEq4t3sBh8yursz87/XurgjMXC264lqvqvbfPdbs8TLvm1XjragMznCcWauZV82/qvvMqnlm/f27kGENs2S+d2fPv+r56Y0rAAAlCK4AAJQguAIAUILgCgBACYIrAAAlCK4AAJSQuh3W7tY0o1a0OdndDmzU7uuzuxXUqvFO6TzPHm/VuZnZNmb2M+oms1vdzLTq+Zl5r838bPF5NJdn7rrj8cYVAIASBFcAAEoQXAEAKEFwBQCgBMEVAIASUncVWFXtv2os1aLr7L7WM8c6tftgxVh3Md7MeWbebyMyr3n3ntrdwWH3mmd3XMi810bsXsPu+2O2kTV44woAQAmCKwAAJQiuAACUILgCAFCC4AoAQAmCKwAAJaRuhzVCa5ax+Su2OTmlazO6hhVjzR4vw7m+ycwWRSPzZJ7jlPZAxbZjo+PNHCvz59FMp/TZNjpe5uPxxhUAgBIEVwAAShBcAQAoQXAFAKAEwRUAgBLKdhU4perK0TXMHCtztWjm49k51uzxTuk8z55nd1eD2d+T+X6fKfOeWjHWXYy3Yv6ZFe2H7L5up3bvrrrW3rgCAFCC4AoAQAmCKwAAJQiuAACUILgCAFCC4AoAQAmp22HtbhUxuoZqY61cQ9b2SafWZuVc7oMM84w4dm0ZjmXVPsx6bjLfh7tbTnl+zpXhfGZuu+WNKwAAJQiuAACUILgCAFCC4AoAQAmCKwAAJaToKnBxcRGXl5dHfc/uqsNV451ateiI3edz5ljnUu1ftdJ79znY3XUj83Vb9Szc/cxbtad3X4MRma/biN3Pm9lW3aPeuAIAUILgCgBACYIrAAAlCK4AAJQguAIAUILgCgBACSnaYd3kXNpUzZ5/d5uTDG14jh3vXNpUzR6vYouizOdz1fyZr9ux9+Lu+Ufn2b2nd7demz3equu2e45T+6we4Y0rAAAlCK4AAJQguAIAUILgCgBACYIrAAAltNnV1EOLaG3rIlZVlK+qesxcLTpixfFkuDa7z3XmfbPqOTVz3SPXemb1b4Yq65HjWXEOVs0/4lw+jzLstWPHOsRn9fT77UHv/f6j/swbVwAAShBcAQAoQXAFAKAEwRUAgBIEVwAAShBcAQAo4d7uBRyyqi3I7rHuYrwV82du5ZH1Wu8+z6NrmDnW7nZDq9qYjcxT8RwcGmv3OVg1/+7WY1nHGh1v1V4b4bN6//3ujSsAACUIrgAAlCC4AgBQguAKAEAJgisAACWk7iowIkNF5MyxZlZg766GnL2G3WOdWrX/qvEqVv9m2B83mdnVYGSeQ1adgxUyPHNPaU/Prk6f2dnBZ3Xu/eGNKwAAJQiuAACUILgCAFCC4AoAQAmCKwAAJQiuAACUULYd1im1BTm0hlWtNDK38th9fXbvtVXjVTzPu9c8uoYVc+xux1XV7mfe7mud4Rm1+/Po0Pn0WT3XyBq8cQUAoATBFQCAEgRXAABKEFwBAChBcAUAoITUXQV2V1eOrmHmWKuqRXdXRI7YfW1Wjbf7PI+uYeZYu6tfV82/+zgPyby2Y2W4p0bsvg9XjDU63u7jOZfP6t3XJsIbVwAAihBcAQAoQXAFAKAEwRUAgBIEVwAASnjR4Npa+97W2nOttV946Gsvba39dGvtV65//YyH/uzbWmvvb639cmvtL9/VwgEAOC/txVo4tNa+JCL+V0R8f+/9c6+/9o8i4qO997e31t4WEZ/Re/97rbXXRcQPRcQXRsRnRcS/jog/3Xv/34fmuH//fr+8vDxu4Te0VxhpSTG79cXM1g8Zjmfm/LuPZ3dLn1Vtqiqe5wznZtW9e+w8I2Ot2gOH7G4htftZPCLz59GI3Xtgtt33W9aWkqMOfIY86L3ff9Sfvegb1977v4+Ij77gy2+IiKeu//upiHjjQ1//4d777/befzUi3h9XIRYAAG5l9GdcX957fzYi4vrXl11//RUR8eGH/t4z118DAIBbmV2c9aj3zo98D9xae2tr7bK1dvn8889PXgYAAKdmNLh+pLX2eETE9a/PXX/9mYh41UN/75UR8euPGqD3/mTv/X7v/f5jjz02uAwAAM7FaHB9d0Q8cf3fT0TEux76+ltaa3+0tfaaiHhtRPzH2y0RAAD+cF0FfigivjQiPjMiPhIR3xER/zwi3hkRnx0RH4qIN/XeP3r99/9+RHxdRHwsIr6l9/4vX3QRrT0fEf/1oS99ZkT8tyOPhdNiD2APYA9gD5ynP9l7f+T/Hf+iwXWH1trlTW0QOA/2APYA9gD2AC/kX84CAKAEwRUAgBKyBtcndy+A7ewB7AHsAewBPk7Kn3EFAIAXyvrGFQAAPk6q4Npa+4rW2i+31t7fWnvb7vVw91prr2qt/dvW2vtaa7/YWvvm66+/tLX20621X7n+9TN2r5W71Vp7SWvtva21f3H9e3vgjLTW/lhr7Udba//5+nnw5+2B89Ja+9vXnwO/0Fr7odbaJ9kDvFCa4Npae0lE/LOI+CsR8bqI+OrW2uv2rooFPhYRf6f3/jkR8UUR8Y3X1/1tEfF07/21EfH09e85bd8cEe976Pf2wHn5roj4yd77n42Iz4urvWAPnInW2isi4psi4n7v/XMj4iUR8ZawB3iBNME1Ir4wIt7fe/9A7/33IuKHI+INm9fEHeu9P9t7/7nr//7tuPqwekVcXfunrv/aUxHxxj0rZIXW2isj4q9FxDse+rI9cCZaa58eEV8SEd8TEdF7/73e+/8Ie+Dc3IuIT26t3YuIT4mrfzLeHuDjZAqur4iIDz/0+2euv8aZaK29OiI+PyLeExEv770/G3EVbiPiZftWxgLfGRHfGhF/8NDX7IHz8aci4vmI+L7rHxd5R2vtU8MeOBu991+LiH8SV/8a57MR8T977z8V9gAvkCm4tkd8TcuDM9Fa+7SI+LG4+meCf2v3elintfaVEfFc7/3B7rWwzb2I+IKI+O7e++dHxO+E/0v4rFz/7OobIuI1EfFZEfGprbWv2bsqMsoUXJ+JiFc99PtXxtX/TcCJa619QlyF1h/svf/49Zc/0lp7/PrPH4+I53atjzv3FyPiq1prH4yrHxH6S621Hwh74Jw8ExHP9N7fc/37H42rIGsPnI8vi4hf7b0/33v//Yj48Yj4C2EP8AKZguvPRsRrW2uvaa19Ylz9UPa7N6+JO9Zaa3H1c23v673/04f+6N0R8cT1fz8REe9avTbW6L1/W+/9lb33V8fVff9veu9fE/bA2ei9/0ZEfLi19meuv/T6iPilsAfOyYci4otaa59y/bnw+riqebAH+Dip/gGC1tpfjaufdXtJRHxv7/0fbl4Sd6y19sUR8TMR8fPx/36+8dvj6udc3xkRnx1XD7Q39d4/umWRLNNa+9KI+Lu9969srf3xsAfORmvtz8VVcd4nRsQHIuJr4+rlij1wJlpr/yAi/npcdZt5b0R8Q0R8WtgDPCRVcAUAgJtk+lEBAAC4keAKAEAJgisAACUIrgAAlCC4AgBQguAKAEAJgisAACUIrgAAlPB/ADUAmoCXLaJ/AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 864x864 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "rule_number = 110\n",
    "length = 100\n",
    "time = 100 \n",
    "\n",
    "# make the initial condition\n",
    "initial_condition = []\n",
    "for i in range(length):\n",
    "    initial_condition.append(random.randint(0,1))\n",
    "\n",
    "# create list of neighborhood tuples in lex. order\n",
    "neighborhoods = [(0,0,0), (0,0,1), (0,1,0), (0,1,1), (1,0,0), (1,0,1), (1,1,0), (1,1,1)]\n",
    "\n",
    "# convert the rule number to binary and padd with 0s as needed\n",
    "in_binary = bin(rule_number)[2:][::-1]\n",
    "binary_length = len(in_binary)\n",
    "if binary_length != 8:\n",
    "    padding = 8 - binary_length\n",
    "    in_binary = in_binary + '0'*padding\n",
    "\n",
    "# create the lookup table dictionary\n",
    "lookup_table = {}\n",
    "for i in range(8):\n",
    "    key = neighborhoods[i]\n",
    "    val = in_binary[i]\n",
    "    lookup_table.update({key:val})\n",
    "    \n",
    "# initialize spacetime field and current configuration\n",
    "spacetime_field = [initial_condition]\n",
    "current_configuration = initial_condition.copy()\n",
    "\n",
    "# apply the lookup table to evolve the CA for the given number of time steps\n",
    "for t in range(time):\n",
    "    new_configuration = []\n",
    "    for i in range(len(current_configuration)):\n",
    "        \n",
    "        neighborhood = (current_configuration[(i-1)%length], \n",
    "                        current_configuration[i], \n",
    "                        current_configuration[(i+1)%length])\n",
    "        \n",
    "        new_configuration.append(int(lookup_table[neighborhood]))\n",
    "        \n",
    "    current_configuration = new_configuration\n",
    "    spacetime_field.append(new_configuration)\n",
    "    \n",
    "# plot the spacetime field diagram\n",
    "plt.figure(figsize=(12,12))\n",
    "plt.imshow(spacetime_field, cmap=plt.cm.Greys, interpolation='nearest')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Final thoughts for the first tutorial"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When getting started it is best to first and foremost write code that does what you want it to. There can be many different ways of writing code that produces the same output; we implemented a CA lookup table using a dictionary a few different ways in this notebook. There are \"better\" ways of writing code to produce the desired functionality. For scientific programming with Python, there are two things to keep in mind for what makes code \"good\". \n",
    "\n",
    "First, Python is a high-level language that allows for elegant, simple, and readible code. This is encapsulated in the Zen of Python, shown below. A few examples of good Python practices were shown in this notebook. Notice that we have used descriptive variable names like \"rule_number\" and \"initial_condition\", rather than using generic variable names like \"x\", \"y\", and \"z\". This makes code more readible and self-documenting. Code written this way is much easier to understand by others, and by yourself if you haven't looked at it for weeks, months, or years. Hardcoding of values should be avoided, though we have not always done so here, e.g. 'for i in range(8):'. Explicit indexing into lists, strings, tuples, etc. should similarly be avoided where possible. This is something we have done in the above, but will remove later with the use numpy arrays.\n",
    "\n",
    "Second, your mathematical intuition can help to get code that works, but it may not always correspond to efficient implementations. Scientific computing is often very compute intensive, and efficient low-level languages like C and Fortran are popular for the speed they can achieve. High-level langauges, like Python, are generally much slower in contrast. We will discuss speed and performance further in the tutorials on Numpy and Numba. Even when writing native Python though, it is useful to think about performance and efficiency. For example, CA evolution happens iteratively, one step at a time. Thus the code written above intuitively applies the lookup table and then adds the new configuration into the spacetime field list at each time step. Python allows this, and it makes it easy to write this first version of the code that will produce spacetime fields as we desire. However, it is not very efficient. Memory must be dynamically allocated to the spacetime field list, as needed, when new configurations are appended. As we will do later, it is more efficient to first allocate the appropriate memory space, and then populate it. We can do this because we specify at the outset how many time steps we wish to evolve for. \n",
    "\n",
    "\n",
    "Finally, don't expect (or even necessarily try) to write the \"correct\" or \"best\" version of your program on the first try. Good code often takes several iterations. Making your code modular by using functions and classes, as described more in the next tutorial, as well as using unit tests will make it easier to modify and improve your code. Using version control, like [git](https://git-scm.com/book/en/v2) is also highly encouraged. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# avoid explicit indexing where possible in Python\n",
    "\n",
    "List = [1,2,3]\n",
    "# instead of this:\n",
    "for i in range(len(List)):\n",
    "    print(List[i])\n",
    "    \n",
    "# do this\n",
    "for thing in List:\n",
    "    print(thing)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Zen of Python, by Tim Peters\n",
      "\n",
      "Beautiful is better than ugly.\n",
      "Explicit is better than implicit.\n",
      "Simple is better than complex.\n",
      "Complex is better than complicated.\n",
      "Flat is better than nested.\n",
      "Sparse is better than dense.\n",
      "Readability counts.\n",
      "Special cases aren't special enough to break the rules.\n",
      "Although practicality beats purity.\n",
      "Errors should never pass silently.\n",
      "Unless explicitly silenced.\n",
      "In the face of ambiguity, refuse the temptation to guess.\n",
      "There should be one-- and preferably only one --obvious way to do it.\n",
      "Although that way may not be obvious at first unless you're Dutch.\n",
      "Now is better than never.\n",
      "Although never is often better than *right* now.\n",
      "If the implementation is hard to explain, it's a bad idea.\n",
      "If the implementation is easy to explain, it may be a good idea.\n",
      "Namespaces are one honking great idea -- let's do more of those!\n"
     ]
    }
   ],
   "source": [
    "import this"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}