{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "## CSCS530 Winter 2015\n", "#### Complex Systems 530 - Computer Modeling of Complex Systems (Winter 2015)\n", "\n", " * Course ID: CMPLXSYS 530\n", " * Course Title: Computer Modeling of Complex Systems\n", " * Term: Winter 2015\n", " * Schedule: Wednesdays and Friday, 1:00-2:30PM ET\n", " * Location: 120 West Hall (http://www.lsa.umich.edu/cscs/research/computerlab)\n", " * Teachers: [Mike Bommarito](https://www.linkedin.com/in/bommarito) and [Sarah Cherng](https://www.linkedin.com/pub/sarah-cherng/35/1b7/316)\n", "\n", "#### [View this repository on NBViewer](http://nbviewer.ipython.org/github/mjbommar/cscs-530-w2015/tree/master/)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Basic Grid\n", "\n", " In this notebook, we'll explore one of the most common types of environment - a grid. In this case, we'll be creating __a two-dimension (2D) square grid__. It's important to remember that grids can take other forms, including:\n", " * _one-dimensional_\n", " * _three-dimensional_\n", " * _hexagonal_\n", " * _triangular_\n", " \n", " 2D grids are the simple to implement and understand, and they are a very common choice for real-world spatial models. Let's begin by importing some libraries and exploring how a grid works.\n", " \n", " ### Imports\n", "\n", " The imports below provide us with:\n", " * numpy: numerical python utilities, including multi-dimensional arrays/matrices\n", " * matplotlib.pyplot: plotting library\n", " \n", " In addition, the ``%matplotlib inline`` statement ensures that our plots are visible in ipython." ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "collapsed": false }, "outputs": [], "source": [ "%matplotlib inline\n", "# Imports\n", "import numpy\n", "import matplotlib.pyplot as plt\n", "\n", "import seaborn; seaborn.set()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Grids terminology and notation\n", "\n", " Before we begin, it's important to agree our terminology and notation down. Below are some grid terms that we'll be using:\n", " \n", " * cell: a region of the grid bounded by sides that can be identified by a position\n", " * lattice: synonym for grid (specially, integer lattice)\n", " * neighbors: cells that are adjacent to a given reference cell\n", " * [Moore neighborhood](http://en.wikipedia.org/wiki/Moore_neighborhood): a definition of cell adjacency that includes all touching cells\n", " ![Moore neighbordhood](http://upload.wikimedia.org/wikipedia/en/thumb/4/41/Moore_d.gif/220px-Moore_d.gif)\n", "\n", "\n", " * [von Neumann neighborhood](http://en.wikipedia.org/wiki/Von_Neumann_neighborhood): a definition of cell adjacency that includes only unit-distance cells, i.e., along cardinal directions\n", " ![von Neumann neighborhood](http://upload.wikimedia.org/wikipedia/commons/thumb/b/ba/Vierer-Nachbarschaft.png/220px-Vierer-Nachbarschaft.png)\n", " \n", " \n", " * [Manhattan distance](http://en.wikipedia.org/wiki/Taxicab_geometry): also known as taxicab or $\\ell_1$ distance, Manhattan distance is the metric used in calculating von Neumann neighborhoods" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Grids with Numerical Values\n", "\n", " Now that we know how to refer to elements of our grid, let's see the most common way to store and display grids with numerical values. These are grids whose cells store a numerical value, e.g., :\n", " \n", " * integer ID of an agent; e.g., cell (3,4) contains agent #17\n", " * integer population size; e.g., number of people living in a certain neighborhood\n", " * decimal quantity; e.g., mass of vegetation per square meter\n", " \n", " To store this information, we can use ``numpy.array`` objects. To brush up on arrays, you might review the following links:\n", "\n", " * [Numpy basics](http://docs.scipy.org/doc/numpy/user/basics.html)\n", " * [Numpy tutorial](http://wiki.scipy.org/Tentative_NumPy_Tutorial)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Creating an empty array\n", "\n", " To start, let's see how to create an empty array. We can do this in a number of ways, including:\n", " \n", " * __NaN__: create an array whose cells are filled with NaN (\"not-a-number\")\n", " * __zero__: create an array whose cells are filled with zeros\n", " \n", " Depending on the interpretation of cell values, your appropriate choice may vary." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Creating an empty array: NaN" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[[ nan nan nan nan nan]\n", " [ nan nan nan nan nan]\n", " [ nan nan nan nan nan]\n", " [ nan nan nan nan nan]\n", " [ nan nan nan nan nan]]\n" ] } ], "source": [ "# Set the grid size\n", "grid_size = 5\n", "\n", "# Create the grid\n", "space = numpy.full((grid_size, grid_size), numpy.nan)\n", "print(space)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Creating an empty array: zero" ] }, { "cell_type": "code", "execution_count": 16, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[[ 0. 0. 0. 0. 0.]\n", " [ 0. 0. 0. 0. 0.]\n", " [ 0. 0. 0. 0. 0.]\n", " [ 0. 0. 0. 0. 0.]\n", " [ 0. 0. 0. 0. 0.]]\n" ] } ], "source": [ "# Set the grid size\n", "grid_size = 5\n", "\n", "# Create the grid\n", "space = numpy.zeros((grid_size, grid_size))\n", "print(space)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Visualizing our grid\n", "\n", " Our next step should be to visualize the grid in a more scalable fashion than reviewing the full array of cell values. Instead, we can visualize the grid in a form that allows our visual cortex to provide context and characterization.\n", " \n", " Let's start by visualizing our \"zero-d\" space using the ``matplotlib.pyplot`` method [``pcolor``](http://matplotlib.org/api/pyplot_api.html#matplotlib.pyplot.pcolor)." ] }, { "cell_type": "code", "execution_count": 17, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 17, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": [ "iVBORw0KGgoAAAANSUhEUgAAAcQAAAFXCAYAAAA8rT7yAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", "AAALEgAACxIB0t1+/AAAGcRJREFUeJzt3X+wHWWd5/H3CdnV4Vcx+IOEKKiD9WG0aqxhXKDCD5UA\n", "6oiiu6IWrAJFdl0u1oKsU6IjI1roUAzDqFWTcZdJZK0ZUbQEplbYTSj5bRaFnUWskm/JqqgJaqDA\n", "hVCsk+TuH6cvHC7k3tNNTnKn835Vnco5/Tx9nm6K3E++Tz/ddzA9PY0kSbu7Rbv6ACRJWggMREmS\n", "MBAlSQIMREmSAANRkiTAQJQkCYDF83VI8gbg68APgAHw/ao6d9IHJknaPSW5HDgS2AacV1V3jbS9\n", "APgvwO9X1eHj7DOueQOxcXNVvaftl0uS1EaSY4FDqmp5kkOBNcDykS5/AXwX+P0W+4xl3CnTQdsv\n", "liSpgxXAtQBVdR+wX5K9R9ovAP5by33GMm4gvibJtUluTXJ820EkSRrTEmDTyOeHmm0AVNUTbfcZ\n", "1ziB+CPgoqp6J3AGsDrJuFOtkiQ9H11mKDvNas4bbFW1keGiGqrqx0l+CSwDHpjdd9WqVT4YVZIW\n", "iKmpqYld7hoMBp1/3k9PT891XBt5ZnV3IPDgPF/ZZZ9nmbdCTHJqkk82718KvATY0HYgSZLGsBZ4\n", "N0CSw4ANVbV5Vp8Bz6wCx9lnXuNMff4D8JUktzMM0LOrakvbgSRJ/TEYTKb4rKr1Se5OcgewFTgn\n", "yenAo1V1XZJ1wMuAg5J8H/irqvpSkv81uk+XsQc78tc/OWUqSQvHJKdM99hjj84/77du3bog71xw\n", "cYwkqbVJVYi7koEoSWpt0aL+PfnTQJQktdbHCrF/ES9JUgdWiJKk1vpYIRqIkqTWDERJkjAQJUkC\n", "DERJkoB+3nbRvzOSJKkDK0RJUmtOmUqShIEoSRJgIEqSBBiIkiQB/QxEV5lKkoQVoiSpgz7eh2gg\n", "SpJa6+OUqYEoSWrNQJQkCQNRkiSgn4HYv6uikiR1YIUoSWptkhViksuBI4FtwHlVdddI2/HAZ4At\n", "wA1VdXGSvYAvA78L/Evg01W1tu24VoiSpNYWLVrU+TWXJMcCh1TVcmAl8IVZXT4PvAs4GjghyaHA\n", "GcB9VXUccErTp/05ddlJkrR7GwwGnV/zWAFcC1BV9wH7JdkbIMkrgYeramNVTQM3NP1/Bbyo2X9/\n", "YFOXczIQJUmtTTAQl/DMQHuo2fZcbb8GllbVN4CXJ/kRcBNwfpdzMhAlSa1NMBCfNdR8bUlOA35e\n", "Va8Gjgf+uss5GYiSpIVkI09XhAAHAg+OtC0daVvWbDsK+B8AVfV94GVJWievgShJam2CFeJa4N0A\n", "SQ4DNlTVZoCqegDYJ8lBSRYDJzX972e4KpUkBwOPN9cYWzEQJUmtTSoQq2o9cHeSO4DPAeckOT3J\n", "yU2Xs4GvArcAV1XV/cB/Bl6R5Gbg74B/3+WcvA9RktTaJH/bRVV9fName0fabgeWz+q/GXjv8x3X\n", "QJQktdbHR7cZiJKk1voYiF5DlCQJK0RJUgd9rBANRElSawaiJElMdpXprmIgSpJas0KUJIl+BmL/\n", "al5JkjqwQpQkteY1REmS6OeUqYEoSWrNClGSJKwQJUkC+hmI/at5JUnqwApRktSa1xAlSaKfU6YG\n", "oiSpNStESZKwQpQkCehnhdi/M5IkqQMrRElSa7vtlGmSFwI/AD5dVV+e7CFJkha6SQZiksuBI4Ft\n", "wHlVdddI2/HAZ4AtwA1VdXGz/TTgT4B/Av6sqm5oO+64FeKFwMNtv1yS1E+TuoaY5FjgkKpanuRQ\n", "YA2wfKTL54ETgAeBW5J8A/g18GfAHwL7AJ8CdnwgJgkQ4Fttv1yS1E8TrBBXANcCVNV9SfZLsndV\n", "PZ7klcDDVbURIMn1Tf9NwLqqegJ4AvgPXQYeJ+IvA84H+jdhLEnqZNGiRZ1f81jCMOBmPNRse662\n", "XwMHAq8A9kpyXZJbkhzX6ZzmakzyfuCWqvpZs8lQlCTtTHPlzgCYbv7cH3gncCbwpS4DzRfVbwNO\n", "SbIeWAl8omvySpL6YzAYdH7NYyNPV4QwrAAfHGlbOtK2rNn2S+A7VTVdVT8GHkvy4rbnNOc1xKp6\n", "38z7JJ8EflJV3247iCSpXyZ4DXEtcBFwRZLDgA1VtRmgqh5Isk+SgxgG4UnAqQyvG34pyaUMK8W9\n", "quqhtgN7H6IkqbVJrTKtqvVJ7k5yB7AVOCfJ6cCjVXUdcDbwVYZTpVdV1f0AzWrT/9ls/1CXsQfT\n", "09M74hwAWLVq1Y77MknS8zI1NTWxMu6EE07o/PN+3bp1C3I9ihWiJKk1n2UqSVJPWSFKklrbbZ9l\n", "KknSKANRkiT6eQ3RQJQktWaFKEkS/awQ+3dGkiR1YIUoSWrNKVNJkujnlKmBKElqzQpRkiQMREmS\n", "gH4GYv8mgSVJ6sAKUZLUWh8rRANRktSagShJEgaiJEmAgShJEtDPQHSVqSRJWCFKkjrw0W2SJDHZ\n", "KdMklwNHAtuA86rqrpG244HPAFuAG6rq4pG2FwI/AD5dVV9uO27/Il6SNHGDwaDzay5JjgUOqarl\n", "wErgC7O6fB54F3A0cGKSQ0faLgQe7npOBqIkqbVJBSKwArgWoKruA/ZLsjdAklcCD1fVxqqaBq5v\n", "+tMEY4BvdT0nA1GS1NoEA3EJsGnk80PNtudq+zWwtHn/F8D5QOe5XANRkrSQzRVwA4Ak7wduqaqf\n", "jbHPdrmoRpLU2gQX1Wzk6YoQ4EDgwZG2pSNty5ptfwy8Ksm/AV4GPJnk51X17TYDG4iSpNYmGIhr\n", "gYuAK5IcBmyoqs0AVfVAkn2SHMQwCE8CTq2qVTM7J/kk8JO2YQgGoiSpg0kFYlWtT3J3kjuArcA5\n", "SU4HHq2q64Czga8C08BVVXX/jhrbQJQktTbJ+xCr6uOzNt070nY7sHyOfT/VdVwDUZLUms8ylSSp\n", "p6wQJUmt9bFCNBAlSa0ZiJIkYSBKkgQYiJIkAQaiJElAPwPR2y4kScIKUZLUQR8rRANRktSagShJ\n", "EgaiJEmAgShJEtDPQHSVqSRJWCFKkjroY4VoIEqSWjMQJUnCQJQkCTAQJUkC+hmIrjKVJAkrRElS\n", "B4sW9a+emjcQk/wOcCVwAPAC4OKq+taEj0uStIBNcso0yeXAkcA24Lyqumuk7XjgM8AW4IaqurjZ\n", "filwNLAHcElVXdN23HEi/u3A96rqjcB7gcvbDiJJ6pfBYND5NZckxwKHVNVyYCXwhVldPg+8i2H4\n", "nZjk0CRvBF7b7PNW4HNdzmneQKyqq6vqsubjQcDPuwwkSeqPSQUisAK4FqCq7gP2S7I3QJJXAg9X\n", "1caqmgaub/rfCpzS7P8osGeS1iXs2NcQk9wBLANOajuIJKlfJjhlugS4a+TzQ822+5s/N420/Rp4\n", "VVVtA55otq0Erm8Cs5Wxr4pW1VHAycDftx1EkqSO5kreZ7QlORk4E/hQl4HmDcQkf5Tk5QBVdQ+w\n", "OMmLuwwmSeqHCU6ZbmRYCc44EHhwpG3pSNuyZhtJ3gx8DHhLVT3W5ZzGqRCPAc5vBjwA2KuqHuoy\n", "mCSpHyYYiGuBdwMkOQzYUFWbAarqAWCfJAclWczwEt7aJPsClwInVdVvup7TONcQvwisTnIr8EJg\n", "qutgkqR+mNQ1xKpan+TuZt3KVuCcJKcDj1bVdcDZwFeBaeCqqro/yb8DXgRc3SymmQY+UFW/aDP2\n", "vIFYVU8Cp7U7JUlSn03yPsSq+visTfeOtN0OLJ/V/wrgiuc7rk+qkSS15rNMJUnqKStESVJrfawQ\n", "DURJUmu75cO9JUmazQpRkiQMREmSgH4GYv8mgSVJ6sAKUZLUWh8rRANRktSagShJEgaiJEmAgShJ\n", "EtDPQHSVqSRJWCFKkjroY4VoIEqSWvNZppIkYYUoSRJgIEqSBPQzEPs3CSxJUgdWiJKk1vpYIRqI\n", "kqTWDERJkphsICa5HDgS2AacV1V3jbQdD3wG2ALcUFUXz7fPuAxESVJrkwrEJMcCh1TV8iSHAmuA\n", "5SNdPg+cADwI3JLkG8BL59lnLC6qkSS1NhgMOr/msQK4FqCq7gP2S7I3QJJXAg9X1caqmga+BRw/\n", "1z5tGIiSpIVkCbBp5PNDzbbnatsELAUOmGOfsTllKklqbScuqplroO21dTo4A1GS1NoEn2W6kWdW\n", "dwcyvF4407Z0pG0ZsAH4f3PsMzanTCVJrU3wGuJa4N0ASQ4DNlTVZoCqegDYJ8lBSRYDJzX9121v\n", "nzasECVJrU1qyrSq1ie5O8kdwFbgnCSnA49W1XXA2cBXgWngqqq6H7h/9j5dxjYQJUmtTfIaYlV9\n", "fName0fabuc5bql4jn1ac8pUkiSsECVJHfgLgiVJwmeZSpIEGIiSJAEGoiRJQD8DsX9XRSVJ6sAK\n", "UZLUmqtMJUmin1OmBqIkqTUDUZIkDERJkoB+XkPs3xlJktSBFaIkqTWnTCVJwkCUJAkwECVJAgxE\n", "SZIAV5lKktRbVoiSpNacMpUkid04EJNcChwN7AFcUlXXTPSoJEkL2s4MxCSLgSuBg4EtwJlV9dNZ\n", "fU4DzgW2AldU1ZokewCrgd9jmF8fqarvbG+cea8hJnkj8NqqWg68Ffhch/ORJPXIokWLOr86OBV4\n", "pKqOAT4LXDLamGRP4ELgOOBNwIeT7Ae8H3ii2W8l8FdzntMYB3IrcErz/lFgzyT9q5UlSWMbDAad\n", "Xx2sAGZmJm8EjprVfgTw3ap6vKqeBG5v+vwdcH7TZxOw/1yDzBuIVbWtqp5oPq4Erq+q6bFOQZKk\n", "528Jw0CjyZ9tzTTqs9obm4ClVbWlCUiA84CvzDXI2ItqkpwMnAmcOO4+kqR+mtQ1xCRnMSy+Zgqv\n", "AXD4rG7zFXPPOLgk5wB/CLx9rp3GXVTzZuBjwJur6rFx9pEk9dekArGqVjNcCPOUJGsYVoH3zlSG\n", "VbVlpMtGYOnI52XA+mbfs4C3ASdX1da5xp43EJPsC1wKrKiq38x7NpKk3tvJt12sY7iWZR3wDuCm\n", "We13Alc0ebUNWA6cm+RVwAeBY6vqn+YbZJwK8b3Ai4Crm8U008AHquoX456JJKlfdvKj274GnJDk\n", "NuBJ4AyAJB8Fbq6qO5NcAKxlGIgXVdVjzbb9getH8uvEWdXlUwbT0ztufcyqVatcbCNJC8TU1NTE\n", "yri1a9d2/nl/4oknLsg7FXyWqSRJ+Og2SVIHu+2j2yRJGmUgSpJEP38fooEoSWqtjxVi/yJekqQO\n", "DERJknDKVJLUQR+nTA1ESVJrBqIkSRiIkiQBBqIkSUA/A9FVppIkYYUoSeqgjxWigShJaq2PgeiU\n", "qSRJWCFKkjroY4VoIEqSWutjIDplKkkSVoiSpA76WCEaiJKk1gxESZIwECVJAnZuICZZDFwJHAxs\n", "Ac6sqp/O6nMacC6wFbiiqtaMtB0A/BB4Z1Xdur1xXFQjSWptMBh0fnVwKvBIVR0DfBa4ZLQxyZ7A\n", "hcBxwJuADyfZb6TLpcD/mW8QA1GStNCtAK5p3t8IHDWr/Qjgu1X1eFU9Cdw+0yfJm4DfAPfON4iB\n", "KEla6JYAmwCqahrY1kyjPqu9sQlYmuRfAJ8A/hSYtzT1GqIkqbVJXUNMchawEpieGQo4fFa3+Yq5\n", "mYO7APibqnosyej252QgSpJam1QgVtVqYPXotiRrGFaB985UhlW1ZaTLRmDpyOdlwHrgdOCtSf4T\n", "8HvAv0pySlX98LnGNhAlSa3t5Nsu1gGnNH++A7hpVvudwBVJ9gW2AcuBc6vq+pkOSb4EfGl7YQgG\n", "oiSpg50ciF8DTkhyG/AkcAZAko8CN1fVnUkuANYyDMSLquqxWd8xzTwG09Pz9hnbqlWrdtyXSZKe\n", "l6mpqYml1j333NP55/3rXve6BXlXvxWiJKk1n1QjSRIGoiRJgIEoSRLQz0D0STWSJGEgSpIEOGUq\n", "Seqgj1OmBqIkqTUDUZIkDERJkgADUZIkoJ+B6CpTSZKwQpQkdWCFKElST1khSpJa62OFaCBKklrr\n", "YyA6ZSpJEgaiJEmAU6aSpA76OGVqIEqSWjMQJUmin4HoNURJkhizQkzyB8A3gcuratVkD0mStNDt\n", "zAoxyWLgSuBgYAtwZlX9dFaf04Bzga3AFVW1ptn+EeA04LfAVFXdvb1x5g3EJHsCfwms7XIikiQ9\n", "T6cCj1TVv01yAnAJ8L6ZxianLgRezzAwv5fkm8CBwHuAw4DXAScD3QMReBJ4G/CxbuchSeqbnXwN\n", "cQXwX5v3NwJrZrUfAXy3qh4HSHI7cDTwGuDqqpoG/nfz2q55ryFW1baq+m27Y5ckaYdZAmwCaMJt\n", "WzON+qz2xiZgKfAK4OAkNyRZ11z+2y5XmUqSWptUhZjkLGAlMD0zFHD4rG7zFXODZv8BsKiq3prk\n", "KOBvn+O7nmIgSpJam1QgVtVqYPXotiRrGFaB985UhlW1ZaTLRoYV4YxlwPrmz/ua/nckOXiusdve\n", "dtG/G08kSa0NBoPOrw7WAac0798B3DSr/U7g9Un2TbI3sBy4DfjvwFsAkhwK/HyuQcZZZXoEwzLz\n", "JcCWJB8E3lBVj4x/LpIkdfY14IQktzFc6HkGQJKPAjdX1Z1JLmB4N8Q24KKqegy4M8lbk3yH4RTq\n", "OXMNMpienp6rvZVVq1btuC+TJD0vU1NTE5vV27BhQ+ef98uWLVuQs41eQ5QktdbHR7cZiJKk1gxE\n", "SZLoZyD6cG9JkjAQJUkCnDKVJHXQxylTA1GS1FofA9EpU0mSsEKUJHXQxwrRQJQktdbHQHTKVJIk\n", "rBAlSR1YIUqS1FNWiJKk1vpYIRqIkqTW+hiITplKkoSBKEkS4JSpJKmDPk6ZGoiSpNb6GIhOmUqS\n", "hBWiJKmDPlaIBqIkaUFLshi4EjgY2AKcWVU/ndXnNOBcYCtwRVWtSbIUWAO8gOGM6Ier6h+3N45T\n", "ppKkhe5U4JGqOgb4LHDJaGOSPYELgeOANwEfTrIfcD7wzao6DvhYs+92GYiSpNYGg0HnVwcrgGua\n", "9zcCR81qPwL4blU9XlVPArcDRwO/Al7U9Nkf2DTXIAaiJGmhW0ITZlU1DWxrplGf1d7Y1Gz7AvCe\n", "JD8EvsiwitwuryFKklqb1KKaJGcBK4HpmaGAw2d1m6+Ymzm4PwG+XlV/nuSPgcuAU7a3k4EoSVow\n", "qmo1sHp0W5I1DCu+e2cqw6raMtJlI7B05PMyYD3wr4E/bbbdCPzNXGM7ZSpJam0nX0Ncx9OV3TuA\n", "m2a13wm8Psm+SfYGlgO3AT8Cjmz6HN583i4rREnSQvc14IQktwFPAmcAJPkocHNV3ZnkAmAtsA24\n", "qKoeS/LnwOok72E4Bfsf5xpkMD09PVd7K6tWrdpxXyZJel6mpqYmdvf85s2bO/+832uvvRbkXf1W\n", "iJKk1vr4pBqvIUqShBWiJKkDK0RJknrKQJQkCadMJUkdOGUqSVJPGYiSJOGUqSSpA6dMJUnqKQNR\n", "kiScMpUkdeCUqSRJPWWFKElqzQpRkqSeskKUJLVmhShJUk8ZiJIk4ZSpJKkDp0wlSeopK0RJUmtW\n", "iJIk9dS8FWKSy4EjgW3AeVV118SPSpKkRpLFwJXAwcAW4Myq+umsPr8LXAX836p6z7j7jZqzQkxy\n", "LHBIVS0HVgJf6HQ2kqReGQwGnV8dnAo8UlXHAJ8FLnmOPquAb3fY7ynzTZmuAK4FqKr7gP2S7D3/\n", "sUuStMOsAK5p3t8IHPUcfc4C7uyw31PmC8QlwKaRzw812yRJu7GdXCE+lUVVNQ1sa6ZDn1JVT3TZ\n", "b1TbVab9W1YkSVowkpzF8BLddLNpABw+q1vXBaFz7jdfIG7kmRXhgcCD2+s8NTVlYErS7mEiP++r\n", "ajWwenRbkjUMs+jemQqvqraM8XUzGTbWfvOl7Frg3c0BHQZsqKrNYxyEJEk7yjrglOb9O4CbttNv\n", "wDODeu2Y+w13np6enqudJJ8F3gBsBc6pqnvn3EGSpB0oySLgb4FXA08CZ1TVhiQfBW4GvgfcA+wJ\n", "7A/8HPgIw4U0z9pve+PMG4iSJO0OfFKNJEkYiJIkAQaiJEnADvxtFz7zdG5J/gD4JnB5Va3a1cez\n", "kCS5FDga2AO4pKqumWeX3UKS32H4HMYDgBcAF1fVt3bpQS0wSV4I/AD4dFV9eVcfz0KR5A3A1xn+\n", "txkA36+qc3ftUS18OyQQR595muRQYA2wfEd8dx8k2RP4S4ZLgDUiyRuB1zb/7+wP/CNPP2ppd/d2\n", "4HtVdVmSgxguPTcQn+lC4OFdfRAL1M0zD7nWeHbUlKnPPJ3bk8DbgF/t6gNZgG7l6fuEHgX2TOID\n", "HoCqurqqLms+HsRwKbkaSQIE/5GwPf49amlHTZkuAUanSGeeeXr/Dvr+f9aqahvw2+HfX41q/tvM\n", "PINwJXB988xBNZLcASwDTtrVx7LAXAacA5y5qw9kgXpNkmsZ3pf36aq6cVcf0EI3qUU1/stErSQ5\n", "meEPtg/t6mNZaKrqKOBk4O939bEsFEneD9xSVT9rNvkz55l+BFxUVe8EzgBWz/VQaw3tqEBs9cxT\n", "aVSSNwMfA95SVY/t6uNZKJL8UZKXA1TVPcDiJC/exYe1ULwNOCXJeoYzC59IctwuPqYFo6o2VtXX\n", "m/c/Bn7JcJZBc9hR/2JYC1wEXOEzT+flv2RHJNkXuBRYUVW/2dXHs8Acw/A3fX84yQHAXlX10C4+\n", "pgWhqt438z7JJ4GfVNXsXw6720pyKvDqqvpUkpcCLwG2+8gyDe2QQKyq9Unubq51bGU4r69GkiMY\n", "Pk/vJcCWJB8E3lBVj+zaI1sQ3gu8CLi6WUwzDXygqn6xaw9rQfgiw6muW4EXAlO7+Hj0z8c/AF9J\n", "cjvDmcCzx/ztELs1n2UqSRI+qUaSJMBAlCQJMBAlSQIMREmSAANRkiTAQJQkCTAQJUkCDERJkgD4\n", "/3X1jDQ0YLJiAAAAAElFTkSuQmCC\n" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Now show the space\n", "plt.figure()\n", "plt.pcolor(space, snap=True)\n", "plt.colorbar()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ " Of course, since this is an \"empty\" grid with no values, we don't see much. Let's manually set one of the cells from 0 to 1 and plot again." ] }, { "cell_type": "code", "execution_count": 18, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": [ "iVBORw0KGgoAAAANSUhEUgAAAbkAAAFXCAYAAAA/GjDaAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", "AAALEgAACxIB0t1+/AAAFsJJREFUeJzt3X+wnGdd9/H3ntahtGkn8qshxTrUOF8qCmNAiGmbgKEF\n", "pmXqj/JjZKD4PGEcCY4RnVFUhspg1dIGrSODlF86gs9TfpjwPJQxBaVIn8w8pmqFGfMdSilgToCE\n", "EoVgweasf+ymsz3k3LvX5tzZva++XzM7s7v3vddeJ5PsJ9/vfe11ev1+H0mSarQw6wlIktQWQ06S\n", "VC1DTpJULUNOklQtQ06SVC1DTpJUrTPHnRARW4EPAJ8FesC/ZOavtD0xSdIjU0Q8DfgwsCsz37bs\n", "2POA3wMeBD6WmW9uGmtsyA19MjNfMs1kJUmaVEScDdwE7F3hlD8GLgcOAXdExAcz88BK403aruwV\n", "zVKSpOk8AFwJfHX5gYh4MvD1zFzMzD5wG7CtabBJK7kfiYjdwGOAN2Xmx8vmLEnSeJm5BHw3Ik52\n", "eB1weOTx14CLmsabpJL7HHBdZv408CrgXRExaThKktSWsV3GsWGVmYsMFp6QmfdGxFeAC4AvnuR0\n", "N8KUpPnR2qWmXq839ed9v9+fdl6LwBNHHl8wfG5FYyu5iPj5iHjj8P4TgMcDB6ecoCRJk3pYGGbm\n", "F4FzI+LCYUfxKlZeoDIYYNxvIYiINcD7GVyPWwB+NzP/ZoXTreQkaX60VsktLCxM/Xm/tLS04rwi\n", "4tnAOxkUVA8C9wPvAe7NzD0RcSlwA4O8+WBmvrXpvcaGXCFDTpLmR2shd8YZZ0z9eX/8+PHTtmLf\n", "BSSSpGK9Xje+WWbISZKKLSx0Y1dIQ06SVKwrlVw3oliSpClYyUmSinWlkjPkJEnFDDlJUrUMOUlS\n", "tQw5SVK1uvIVgm7MUpKkKVjJSZKK2a6UJFXLkJMkVcuQkyRVy5CTJFWrKyHn6kpJUrWs5CRJxbry\n", "PTlDTpJUrCvtSkNOklTMkJMkVcuQkyRVqysh140rh5IkTcFKTpJUrM1KLiJ2AZuAJWBnZu4fOXY1\n", "8NvAA8D/zsw/bRrLSk6SVGxhYWHqW5OI2AJsyMzNwHbg5pFjPeBPgBcAW4EXRcT6xnme6g8qSXrk\n", "6fV6U9/G2AbsBsjMA8DaiFgzPPY44BuZeX9m9oE7gOc1DWbISZKKtRhy64DDI4+PDJ8jMw8D50bE\n", "D0XE9wGXAec3DeY1OUlSsdO4unL5G/1P4M+BrwKHTnL8YQw5SdI8WWRYuQ2tZxBmAGTm3wGXAkTE\n", "O4D7mgYz5CRJxVqs5PYC1wG3RMRG4GBmHjtxMCJuA17BYOXlNuA3mwYz5CRJxdoKuczcFxF3RcSd\n", "wHFgR0RcCxzNzD3AOxgE4RnAb2fm/Y3z7Pf7qzm/VR1MknRKWiu3Lrrooqk/7++9997TdkHPSk6S\n", "VKwr23oZcpKkYl0JOb8nJ0mqlpWcJKlYVyo5Q06SVMyQkyRVa9xGy/PCkJMkFbOSkyRVqysh1416\n", "U5KkKVjJSZKKeU1OklStrrQrDTlJUjErOUlStazkJEnV6krIdaPelCRpClZykqRiXpOTJFWrK+1K\n", "Q06SVMxKTpJULSs5SVK1ulLJdWOWkiRNwUpOklSsqnZlRJwFfBZ4U2b+RbtTkiTNuzZDLiJ2AZuA\n", "JWBnZu4fObYDeDnwILA/M1/XNNak7co3AF+fbrqSpNosLCxMfWsSEVuADZm5GdgO3Dxy7Dzg14FL\n", "MnML8NSIeFbjPMf9IBERQAAfHftTS5IeEXq93tS3MbYBuwEy8wCwNiLWDI99B3gAOC8izgQeDdzf\n", "NNgkldyNwOuAbjRgJUmta6uSA9YBh0ceHxk+R2Z+B7gO+DzwBeDOzLyncZ5NByPiFcAdmfml4VMG\n", "nSTpdHoodyLiXAaXz34YeDJwSUT8aNOLxy08uRJ4ckT8HPAk4IGI+HJm/u2pzVmS1GUtLjxZZFi5\n", "Da0HDg3vXwx8PjO/ARARnwaeyWBh5Ek1hlxmvuzE/Yh4I/AFA06S1GLI7WXQkrwlIjYCBzPz2PDY\n", "fcDFEfGoYevymcBtTYP5PTlJUrG2djzJzH0RcVdE3AkcB3ZExLXA0czcExFvAT4ZEf8F/L/M/HTT\n", "eL1+v7+a81vVwSRJp6S1cuvyyy+f+vP+9ttvP23rO6zkJEnF3LtSkqQZs5KTJBWrau9KSZJGGXKS\n", "pGp15ZqcISdJKmYlJ0mqVlcquW7MUpKkKVjJSZKK2a6UJFWrK+1KQ06SVMxKTpJULUNOklStroRc\n", "N5qqkiRNwUpOklSsK5WcISdJKmbISZKqZchJkqplyEmSqtWVkHN1pSSpWlZykqRibuslSapWm+3K\n", "iNgFbAKWgJ2ZuX/4/HrgfUAf6AEXAb+Rmf9rpbEMOUlSsbZCLiK2ABsyc3NEPAV4N7AZIDMXgecO\n", "zzsD+DvgI03jdaPelCTNlV6vN/VtjG3AboDMPACsjYg1JznvVcCHMvPbTYNZyUmSirXYrlwH7B95\n", "fGT43D3LztsOXD5uMCs5SdI8+540jYhNwL9m5rfGvdhKTpJUrMVKbpFB5XbCeuDQsnOuAj4+yWBW\n", "cpKkYi1ek9sLXAMQERuBg5l5bNk5PwHcPck8reQkScXaquQyc19E3BURdwLHgR0RcS1wNDP3DE9b\n", "B3xtkvEMOUlSsTa/J5eZv7Xsqc8sO/70Sccy5CRJxdy7UpKkGbOSkyQV60olZ8hJkooZcpKkahly\n", "kqRqGXKSpGoZcpKkanUl5PwKgSSpWlZykqRiXankDDlJUjFDTpJULUNOklQtQ06SVK2uhJyrKyVJ\n", "1bKSkyQV60olZ8hJkooZcpKkahlykqRqGXKSpGp1JeRcXSlJqpaVnCSp2MJCN2qksSEXEY8G3guc\n", "DzwKeHNmfrTleUmS5lib7cqI2AVsApaAnZm5f+TYk4C/Ar4P+MfMfE3TWJNE8YuAf8jM5wAvBXZN\n", "OW9JUiV6vd7UtyYRsQXYkJmbge3AzctOuQl4S2ZuAo4PQ29FYyu5zLx15OGFwJfHvUaSVLcWK7lt\n", "wG6AzDwQEWsjYk1mfisiesClwMuGx3953GATX5OLiDuBC4Crppq2JKkaLYbcOmD/yOMjw+fuAR4P\n", "fAv4o4jYCPx9Zv5W02ATXznMzEuAq4H3lc5YkqQp9ZbdvwB4K7AV+PGIeGHTi8eGXEQ8IyJ+ACAz\n", "7wbOjIjHTT9fSVLXtXVNDlhkULmdsB44NLx/BLgvM+/LzCXgE8BTmwabpJK7DHgdQEScD5yTmUcm\n", "eJ0kqVIthtxe4BqAYUvyYGYeA8jM48C9EfFDw3OfAWTTYJNck3s78K6I+BRwFtC4XFOSVL+2rsll\n", "5r6IuGu4DuQ4sCMirgWOZuYe4FeB9w4XoXwmM/9P03iTrK58AHj5KsxdklSJNr8nd5LFJJ8ZOfZ5\n", "Bh3GibjjiSSpmHtXSpI0Y1ZykqRiXankDDlJUrFqNmiWJGk5KzlJUrUMOUlStboSct1oqkqSNAUr\n", "OUlSsa5UcoacJKmYISdJqpYhJ0mqliEnSapWV0LO1ZWSpGpZyUmSinWlkjPkJEnF3LtSklQtKzlJ\n", "UrUMOUlStboSct1oqkqSNAUrOUlSsa5UcoacJKmYISdJqlabIRcRu4BNwBKwMzP3jxz7AvCl4bE+\n", "8PLMPLTSWIacJKlYWyEXEVuADZm5OSKeArwb2DxySh94QWb+5yTjufBEklSs1+tNfRtjG7AbIDMP\n", "AGsjYs3oWw9vEzHkJEnzZB1weOTxkeFzo94eEX8fEdePG8yQkyQVa7GS+563Wvb4DcDrgK3Aj0XE\n", "zza92GtykqRiLe5ducjDK7f1wEMLSzLzL0/cj4jbgB8DPrzSYFZykqRiLVZye4FrACJiI3AwM48N\n", "H58XEXdExFnDc7cAn20azEpOklSsrdWVmbkvIu6KiDuB48COiLgWOJqZeyLig8C+iPgm8M+Z+aHG\n", "efb7/dWc36oOJkk6Ja19me2WW26Z+vP+1a9+9Wn7JrntSklStWxXSpKK+UtTJUnVcu9KSVK1DDlJ\n", "UrUMOUlStboSct24cihJ0hSs5CRJxVxdKUmqVlfalYacJKmYISdJqpYhJ0mqVleuyXVjlpIkTcFK\n", "TpJUzHalJKlahpwkqVqGnCSpWoacJKlarq6UJGnGrOQkScVsV0qSqlVVyEXEDcClwBnAH2TmX7c6\n", "K0nSXGsz5CJiF7AJWAJ2Zub+k5zz+8CmzHxu01hjr8lFxHOAp2bmZuCFwB9NM2lJUj0WFhamvjWJ\n", "iC3AhmHmbAduPsk5FwOXAf2x85zgZ/kU8OLh/aPA2RHRjTpVktSKXq839W2MbcBugMw8AKyNiDXL\n", "zrkReP0k8xzbrszMJeDbw4fbgdsyc2x6SpI0hXXAaHvyyPC5ewAi4lrgE8CXJhls4oUnEXE18AvA\n", "FZO+RpJUp9O48OShN4qI7wdewSCHLhw9tpJJF548n0Fp+PzM/OZ081RXViPNQr9vc0DqkhY/zxYZ\n", "VG4nrAcODe//FHA+8GngLOCiiLgpM39tpcHGhlxEnAfcAGzLzH+fdtaSpHq0GHJ7geuAWyJiI3Aw\n", "M48BZOaHgA8BRMQPAu9pCjiYrJJ7KfBY4NbhgpM+8MrM/LepfwRJUqe1ta1XZu6LiLsi4k7gOLBj\n", "eB3uaGbuKR2vt8ptIntODWxXrsx2pdSK9sqtvXun/kd7xRVXnLYPQ/eulCRVy229JEnFutKZMuQk\n", "ScUMOUlStbry++QMOUlSsa5Uct2IYkmSpmDISZKqZbtSklSsK+1KQ06SVMyQkyRVy5CTJFXLkJMk\n", "VasrIefqSklStazkJEnFulLJGXKSpGJdCTnblZKkalnJSZKKdaWSM+QkScW6EnK2KyVJ1bKSkyQV\n", "60olZ8hJkooZcpKkahlykqRqtRlyEbEL2AQsATszc//IsVcD/wN4ELg7M1/bNJYLTyRJxXq93tS3\n", "JhGxBdiQmZuB7cDNI8ceDbwEuCQzLwMujohNTeMZcpKkebIN2A2QmQeAtRGxZvj4PzPz8sxcioiz\n", "gfOArzQNZshJkubJOuDwyOMjw+ceEhG/AXwOuDUz72sazJCTJBVrq115srda/kRm/iFwEfDCiPjJ\n", "phcbcpKkYi2G3CIPr9zWA4cAIuIxEbEVIDO/A3wMuKRpMENOklSsxZDbC1wDEBEbgYOZeWx47Ezg\n", "3cPrcQDPArJxnv1+f/qf8nut6mC16cr3SmZhlf8eShpo7UPn7rvvnvof7dOf/vTGeUXE9cBW4Diw\n", "A9gIHM3MPRHxSuC1wH8x+ArBa5rGMuROI0NuZYac1IpOhtxq8svgkqRiXflPuyEnSSpmyEmSqmXI\n", "SZKq1ZWQ8ysEkqRqGXKSpGrZrpQkFetKu9KQkyQVM+QkSdUy5CRJ1TLkJEnV6krIubpSklQtKzlJ\n", "UjErOUmSZsxKTpJUrCuVnCEnSSrWlZCzXSlJqpYhJ0mqlu1KSVKxrrQrDTlJUjFDTpJUra6EnNfk\n", "JEnVmqiSi4inAR8GdmXm29qdkiRp3rVZyUXELmATsATszMz9I8eeC1wPPAhkZm5vGmtsJRcRZwM3\n", "AXtPZdKSJI0TEVuADZm5GdgO3LzslD8Dfi4zLwPOi4gXNI03SbvyAeBK4KtTzFeSVKFerzf1bYxt\n", "wG6AzDwArI2INSPHn5mZi8P7h4HHNg02NuQycykzvzvuPEmSVsE6BuF1wpHhcwBk5n8ARMQTgcuB\n", "25oGc3XladTv92c9BUlaFadxdeX3vFFEPAH4CPBLmfmNphcbcpKkYi2G3CIjlRuwHjh04kFEnMug\n", "ent9Zn5i3GClXyHoxhcjJEmtavGa3F7gGoCI2AgczMxjI8d3MVjpf/tE8xzXQouIZwPvBB7PYMnm\n", "/cDWFUpE+3GSND9aK0wOHjw49ef9BRdc0DiviLge2AocB3YAG4GjDALwfmAfg5+tD7w/M9+50lhj\n", "Q66QISdJ86OTIbeavCYnSSrWlW29DDlJUjFDTpJUra6EnBs0S5KqZchJkqplu1KSVKwr7UpDTpJU\n", "rCshZ7tSklQtKzlJUrGuVHKGnCSpWFdCznalJKlaVnKSpGJWcpIkzZiVnCSpWFcqOUNOklSsKyFn\n", "u1KSVC1DTpJULduVkqRiXWlXGnKSpGJdCTnblZKkalnJSZKKdaWSM+QkSXMlInYBm4AlYGdm7h85\n", "9ijgHcDFmfmscWPZrpQkzY2I2AJsyMzNwHbg5mWnvAX4/5OOZ8hJkor1er2pb2NsA3YDZOYBYG1E\n", "rBk5/pvA/510noacJGmerAMOjzw+MnwOgMz8dslgXpOTJBU7jQtPTumNrOQkSfNkkZHKDVgPHJp2\n", "MENOklSsxWtye4FrACJiI3AwM48tf3smrPB6/X6/9GdrsqqDSZJOSWs9xWPHjk39eX/OOec0zisi\n", "rge2AseBHcBG4Ghm7omI24EnARcCnwfempnvWWksQ06S6tXJkFtNLjyRJBXryo4nXpOTJFXLSk6S\n", "VMxKTpKkGTPkJEnVsl0pSSpmu1KSpBkz5CRJ1bJdKUkqZrtSkqQZM+QkSdWyXSlJKma7UpKkGbOS\n", "kyQVs5KTJGnGrOQkScWs5CRJmjFDTpJULduVkqRitislSZoxKzlJUjErOUmSZmxsJRcRu4BNwBKw\n", "MzP3tz4rSdIjVlPuRMTzgN8DHgQ+lplvbhqrsZKLiC3AhszcDGwHbj7FuUuSKtDr9aa+NZkgd/4Y\n", "+BngUuCKiHhK03jj2pXbgN0AmXkAWBsRa8a8RpKkaa2YOxHxZODrmbmYmX3gtuH5KxoXcuuAwyOP\n", "jwyfkyQ9grVVydGcO8uPfQ14YtNgpQtPurGcRpJUi6bcGZtJ4xaeLPLwym09cOhU3lCSVIW2Pu+b\n", "cmeRh1duFwyfW9G4Sm4vcA1ARGwEDmbmsZLZSpJUYMXcycwvAudGxIURcSZw1fD8FfX6/X7ju0XE\n", "9cBW4DiwIzM/c8o/giRJK1ieO8BG4Ghm7omIS4EbgD7wwcx8a9NYY0NOkqSucscTSVK1DDlJUrUM\n", "OUlStVbttxC4x2WziHga8GFgV2a+bdbzmScRcQODLXrOAP4gM/96xlOaCxHxaOC9wPnAo4A3Z+ZH\n", "ZzqpORMRZwGfBd6UmX8x6/nMi4jYCnyAwZ9ND/iXzPyV2c5qNlYl5Eb3GhvuI/ZuYPNqjF2DiDgb\n", "uIkxS10fiSLiOcBTh393HgP8E2DIDbwI+IfMvDEiLgRuBwy5h3sD8PVZT2JOfTIzXzLrSczaarUr\n", "3eOy2QPAlcBXZz2ROfQp4MXD+0eBsyPCTQWAzLw1M28cPrwQ+PIs5zNvIiKAwOBfif+OWL125Tpg\n", "tD15Yq+xe1Zp/E7LzCXgu4N/kxo1/LP59vDhduC24carGoqIOxns7HDVrOcyZ25k8B2qX5j1RObU\n", "j0TEbuAxDNq5H5/1hGahrYUn/g9CRSLiagYfVq+d9VzmTWZeAlwNvG/Wc5kXEfEK4I7M/NLwKT9z\n", "Hu5zwHWZ+dPAq4B3DXcIecRZrZAr3eNSekhEPB94PfCCzPzmrOczLyLiGRHxAwCZeTdwZkQ8bsbT\n", "mhdXAi+OiH0MOgC/ExE/NeM5zY3hr6L5wPD+vcBXGHQDHnFWK9n3AtcBt7jH5Vj+j3NERJzHYIue\n", "bZn577Oez5y5DPhB4Fcj4nzgnMw8MuM5zYXMfNmJ+xHxRuALmfm3M5zSXImInwd+ODN/NyKeADwe\n", "ODjjac3EqoRcZu6LiLuG1w5O7DWmoYh4NvBOBn/RHoyIXwS2ZuY3ZjuzufBS4LHArcMFJ33glZn5\n", "b7Od1lx4O4M206eAs4DXzHg+6o6PAO+PiE8z6Nj9UmY+OOM5zYR7V0qSquWOJ5KkahlykqRqGXKS\n", "pGoZcpKkahlykqRqGXKSpGoZcpKkahlykqRq/TccGSxY+z0zKwAAAABJRU5ErkJggg==\n" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Change cell (1,1)'s value to 1\n", "space[1, 1] = 1\n", "\n", "# Now show the space\n", "plt.figure()\n", "plt.pcolor(space, snap=True)\n", "plt.colorbar()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "There are two things to note:\n", "\n", " * cell ``(1,1)`` corresponds to the __second__ row and __second__ column in the grid because we are using [__zero-indexing__](http://en.wikipedia.org/wiki/Zero-based_numbering)\n", " * ``(0, 0)`` is in the lower left corner for this visualization; __not all visualizations may choose this orientation!__ For example, many follow a convention like words on a page, with (0, 0) in the upper left corner" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Initializing a grid with random values\n", "\n", "Grids are commonly setup with initial conditions, including:\n", " \n", " * endowments of timber or other resources\n", " * populations per square mile or other densities\n", " * agent positions\n", " \n", " Let's walk through creating a grid that represents the binary presence of a resource. Our parameters are as follows:\n", " \n", " * __``grid_size``__: \"dimension\" of the grid, i.e., number of cells in each row or column\n", " * __``num_cells``__: number of cells to sample for resource endowment\n", " \n", "In order to determine which cells to endow, we'll need to sample from a random distribution. If you haven't already, now would be a great time to review the __Basic Distributions__ notebook in the ``basic-random`` folder. We'll make the following assertions for our spatial distribution of resource:\n", " \n", " \n", " * the __row__ coordinate will be uniformly distributed across the entire discrete grid\n", " * the __column__ coordinate will be uniformly distributed across the entire discrete grid\n", " * the __row__ and __column__ coordinates will be drawn __independently__ from each other" ] }, { "cell_type": "code", "execution_count": 20, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Endowing cell (4, 20).\n", "Endowing cell (5, 16).\n", "Endowing cell (2, 16).\n", "Endowing cell (5, 11).\n", "Endowing cell (1, 14).\n", "Endowing cell (5, 10).\n", "Endowing cell (12, 0).\n", "Endowing cell (6, 5).\n", "Endowing cell (19, 15).\n", "Endowing cell (15, 12).\n" ] }, { "data": { "text/plain": [ "" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": [ "iVBORw0KGgoAAAANSUhEUgAAAb4AAAFXCAYAAADdxiujAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", "AAALEgAACxIB0t1+/AAAGGVJREFUeJzt3X+sXOV95/H32FS02CCXLqmxo0ghrr6hlER1sonXITaJ\n", "zY8obLMtTldqxVKIUX/Yq3jTlQIbNQTUsFmyOC3pom1CwqZ00x8QZMMGUgOiScsibU27JEjrb5NQ\n", "qNbXAbvEWceUBF/f/WMOdHzxPXM9PufeOfd5v6SR5vy4zzx3OMznfp/zzOPe1NQUkiSVYtF8d0CS\n", "pLlk8EmSimLwSZKKYvBJkopi8EmSimLwSZKKcsqwEyLiZuACYDHwCeDngLcAB6pTPpmZD7TWQ0lS\n", "8SLiTcA9wPbMvG3asY3Ax4EjwAOZ+dt1bdUGX0RcCJyXmWsj4kzgb4CHgWsz8/7RfwVJkmYnIk4D\n", "bgF2zXDK7wIXAfuAr0bE3Zm5Z6b2hg11fg14f/X8ILCEfuXXO5FOS5J0El4E3gs8O/1ARLwe+IfM\n", "nMjMKeB+YENdY7UVX2YeBV6oNjcDXwYmga0R8aGqE1sz8/kT/S0kSZqNKot+GBHHO7wc2D+w/Rxw\n", "Tl17s5rcEhHvA64CtgJ3Ah/OzA3AE8ANs2lDkqQ5MHREcjaTWy4BrgMuycxDwCMDh+8FbjvuD/4T\n", "FwOVpPHSyu2qXq838uf91NTUqH2aAM4e2F5Z7ZtRbcUXEWcANwOXZeb3qn13R8T51SnrgCdH7Kwk\n", "SSfqmIDMzGeA0yPidRFxCnAZM0+CAYZXfP8a+AngTyOiR796uwO4IyIOAd+nPwQqSSpcr9fOvMeI\n", "eDtwO3AWcCQifpV+Fj2VmTuBXwf+mH5G/VFmfqu2n3PwzxI51ClJ46WVhFq8ePHIn/eTk5Nz9m2B\n", "off4JEmajbYqvqYZfJKkRixa1I1VMA0+SVIjulLxdSOeJUlqiBWfJKkRXan4DD5JUiMMPklSUQw+\n", "SVJRDD5JUlG68nWGbvRSkqSGWPFJkhrhUKckqSgGnySpKAafJKkoBp8kqShdCT5ndUqSimLFJ0lq\n", "RFe+x2fwSZIa0ZWhToNPktQIg0+SVBSDT5JUlK4EXzfuREqS1BArPklSI9qs+CJiO7AGOApsy8zd\n", "A8feB3wEeBH4k8z8L3VtWfFJkhqxaNGikR91ImIdsCoz1wKbgVsHjvWATwOXAuuBfxkRK2r7ebK/\n", "qCRJ0K/4Rn0MsQHYAZCZe4BlEbG0OvbPgO9m5vOZOQV8FdhY15jBJ0lqRIvBtxzYP7B9oNpHZu4H\n", "To+IN0TEjwDvBH6yrjHv8UmSGjGHszqnv9AHgC8AzwL7jnP8GAafJGncTVBVeJUV9AMOgMx8BLgA\n", "ICI+Azxd15jBJ0lqRIsV3y7gY8BnI2I1sDczD798MCLuB66gP+NzA3BtXWMGnySpEW0FX2Y+FhGP\n", "R8SjwCSwJSKuBA5m5k7gM/TDcTHwkcx8vrafU1NTrXR0QOsvIEk6Ia0k1DnnnDPy5/1TTz01ZzcI\n", "rfgkSY3oypJlBp8kqRFdCT6/xydJKooVnySpEV2p+Aw+SVIjDD5JUlGGLTY9Lgw+SVIjrPgkSUXp\n", "SvB1oy6VJKkhVnySpEZ4j0+SVJSuDHUafJKkRljxSZKKYsUnSSpKV4KvG3WpJEkNseKTJDXCe3yS\n", "pKJ0ZajT4JMkNcKKT5JUFCs+SVJRulLxdaOXkiQ1xIpPktSIBTPUGRE3AxcAi4FPAH8F3Em/WtwH\n", "XJGZL7XZSUnS+Gsz+CJiO7AGOApsy8zdA8e2AL8MHAF2Z+aH6tqqHeqMiAuB8zJzLfAe4HeAG4Hf\n", "y8z1wLeBq0f/VSRJC8WiRYtGftSJiHXAqiqLNgO3Dhw7A/j3wDsycx1wXkS8rbafQ36PrwHvr54f\n", "BJYA64F7q333ARuHtCFJKkCv1xv5McQGYAdAZu4BlkXE0urYD4AXgTMi4hTgx4Dn6xqrDb7MPJqZ\n", "L1SbHwC+DCwZGNp8Djh7WI8lSQtfWxUfsBzYP7B9oNpHZv4A+Bj9Eci/Ax7NzG/V9nM2v0xEvI/+\n", "kOZWYDCau3EnU1qAWvrLWuqCVy7kiDgd+C3gp4DXA++IiJ+p++GhwRcRlwDXAZdm5iHgUEScWh1e\n", "CUyM2HFJ0gLS4lDnBFWFV1lBf3IlwLnAtzPzu5l5BPhL4K11jQ2b3HIGcDNwWWZ+r9r9EHB59fxy\n", "4CvDeixJWvhaDL5dwCaAiFgN7M3Mw9Wxp4FzBwqytwK1Q529qampGQ9GxDXA9cDf0i8tp4Argc8B\n", "pwLPAFdl5mTNa8z8ApJGNuqwZd3/8ypGK2PeGzduHPnieuihh2r7FBE30Z9cOQlsAVYDBzNzZ5VV\n", "VwMvAf8zM6+ta6s2+Bri/2VSCww+nYRWgu+iiy4a+eJ68MEH5+wGtCu3SJIa4VqdkiSNISs+SVIj\n", "uvJ1GYNPktQIg0+SVJSu3OMz+CRJjbDikyQVpSsVXzd6KUlSQ6z4pI7yi+gaNw51SpKK0pWhToNP\n", "ktQIKz5JUlEMPklSUboSfN0YkJUkqSFWfJKkRnSl4jP4JEmNMPgkSUUx+CRJRTH4JElF6UrwOatT\n", "klQUKz5JUiNcskySVJQ2hzojYjuwBjgKbMvM3dX+FcB/B6aAHnAO8OHM/OOZ2jL4JEmNaCv4ImId\n", "sCoz10bEG4HPA2sBMnMCeFd13mLgEeDeuva6UZdKksZer9cb+THEBmAHQGbuAZZFxNLjnPcrwJcy\n", "84W6xqz4JEmNaHGoczmwe2D7QLXvW9PO2wxcNKwxKz5JUte8KmEjYg3wfzLz+8N+2IpPktSIFiu+\n", "CfoV3stWAPumnXMZ8NBsGrPikyQ1osV7fLuATQARsRrYm5mHp53zz4EnZtNPKz5JUiPaqvgy87GI\n", "eDwiHgUmgS0RcSVwMDN3VqctB56bTXsGnySpEW1+jy8z/8O0Xd+YdvzNs23L4JMkNcK1OiVJGkNW\n", "fJKkRnSl4jP4JEmNMPgkSUUx+CRJRTH4JElFMfgkSUXpSvD5dQZJUlGs+CRJjehKxWfwSZIaYfBJ\n", "kopi8EmSimLwSZKKYvBJHTTq/7hTU1MN90RSWww+SVIjrPgkSUUx+CRJRTH4JElFMfgkSUXpSvC5\n", "VqckqShWfJKkRixa1I1aamjwRcSbgHuA7Zl5W0TcAbwFOFCd8snMfKDFPkqSOqDNoc6I2A6sAY4C\n", "2zJz98Cx1wJ/BPwI8NeZ+Rt1bdXGc0ScBtwC7Jp26NrMfHf1MPQkSfR6vZEfdSJiHbAqM9cCm4Fb\n", "p51yC/0ibA0wWQXhjIbVpS8C7wWeHXKeJKlwbQUfsAHYAZCZe4BlEbEUICJ6wAXAfdXxf5uZ/7eu\n", "sdrgy8yjmfnD4xzaGhEPR8QXI+LMYT2WJC18LQbfcmD/wPaBah/AWcD3gd+JiL+IiJuGNTbKncg/\n", "oD/UuQF4ArhhhDYkSRpVb9rzlcCngPXAz0bEe+p++IRndWbmIwOb9wK3nWgb0rhysWlpdC1Obpng\n", "nyo8gBXAvur5AeDpzHwaICIeBs4DZpx/csIVX0TcHRHnV5vrgCdPtA1J0sLT4lDnLmATQESsBvZm\n", "5mGAzJwEnoqIN1TnvgXIusZqK76IeDtwO/0x1CMR8WvA9cAdEXGI/rjqVcN6LEla+Nqq+DLzsYh4\n", "PCIeBSaBLRFxJXAwM3cC/w74b9VEl29k5n21/ZyDoR3HjiRpvLSSUB/96EdH/ry/8cYb52y9M1du\n", "kSQ1wrU6JUkaQ1Z8kqRGdKXiM/gkSY1YMItUS5I0G1Z8kqSiGHySpKJ0Jfi6MSArSVJDrPgkSY3o\n", "SsVn8EmSGmHwSZKKYvBJkopi8EmSitKV4HNWpySpKFZ8kqRGdKXiM/gkSY1wrU5JUlGs+CRJRTH4\n", "JElF6UrwdWNAVpKkhrRe8Z3MXwBTU1MN9kSS1KauVHwOdUqSGmHwSZKK0mbwRcR2YA1wFNiWmbsH\n", "jv0d8PfVsSnglzNz30xtGXySpEa0FXwRsQ5YlZlrI+KNwOeBtQOnTAGXZuY/zqY9J7dIkhrR6/VG\n", "fgyxAdgBkJl7gGURsXTwpavHrBh8kqRxtxzYP7B9oNo36L9GxF9ExE3DGjP4JEmNaLHie9VLTdv+\n", "LeBDwHrg/Ij4hbof9h6fJKkRLa7VOcGxFd4K4JXJK5n5hy8/j4j7gfOBe2ZqzIpPktSIFiu+XcAm\n", "gIhYDezNzMPV9hkR8dWI+NHq3HXAk3WNWfFJkhrR1qzOzHwsIh6PiEeBSWBLRFwJHMzMnRFxN/BY\n", "RBwC/ndmfqm2n22vjtLr9UZ+AVdukaRWtJJQn/3sZ0f+0L7mmmvm7NvvDnVKkorS+lCnVZsklcF/\n", "iFaSVBTX6pQkFcXgkyQVxeCTJBWlK8HXjTuRkiQ1xIpPktQIZ3VKkorSlaFOg0+S1AiDT5JUFINP\n", "klSUrtzj60YvJUlqiBWfJKkRDnVKkopi8EmSimLwSZKKYvBJkorirE5JksaQFZ8kqREOdUqSirJg\n", "gi8i3gTcA2zPzNsi4rXAnfSHSfcBV2TmS+12U5I07toMvojYDqwBjgLbMnP3cc75j8CazHxXXVu1\n", "9/gi4jTgFmDXwO4bgU9n5nrg28DVJ9Z9SdJCtGjRopEfdSJiHbAqM9cCm4Fbj3POucA7gamh/Rxy\n", "/EXgvcCzA/suBO6rnt8HbBz2IpKkha/X6438GGIDsAMgM/cAyyJi6bRz/jNw3Wz6WRt8mXk0M384\n", "bfeSgaHN54CzZ/NCkiSNaDmwf2D7QLUPgIi4EngY+PvZNHayk1u6cSdTktS6OZzc8soLRcSPA1cA\n", "FwOvYxa5NMr3+A5FxKnV85XAxAhtSJIWmBaHOicYqPCAFfQnVwK8G/hJ4C/pT8T82Yi4pa6xUYLv\n", "IeDy6vnlwFdGaEOStMC0GHy7gE0AEbEa2JuZhwEy80uZeX418eXngb/OzN+sa6x2qDMi3g7cDpwF\n", "HImIXwMuAb4QEb8KPAN8Yei7IUla8NpasiwzH4uIxyPiUWAS2FLd1zuYmTtPtL3e1NTQmZ8nq/UX\n", "kCSdkFZuxu3atWvkz/uLL754zm4QulanJKkoLlkmSWrEglmyTJKk2TD4JElF6cq/x2fwSZIa0ZWK\n", "rxvxLElSQww+SVJRHOqUJDWiK0OdBp8kqREGnySpKAafJKkoBp8kqShdCT5ndUqSimLFJ0lqRFcq\n", "PoNPktSIrgSfQ52SpKJY8UmSGtGVis/gkyQ1oivB51CnJKkoVnySpEZ0peIz+CRJjTD4JElFMfgk\n", "SUVpM/giYjuwBjgKbMvM3QPHrgGuBo4AT2Tm1rq2nNwiSWpEr9cb+VEnItYBqzJzLbAZuHXg2I8B\n", "vwi8IzPfCZwbEWvq2jP4JEnjbgOwAyAz9wDLImJptf2PmXlRZh6NiNOAM4Dv1DVm8EmSxt1yYP/A\n", "9oFq3ysi4sPAN4E/zcyn6xoz+CRJjWhrqPN4LzV9R2b+J+Ac4D0R8S/qftjgkyQ1osXgm+DYCm8F\n", "sA8gIs6MiPUAmfkD4AHgHXWNGXySpEa0GHy7gE0AEbEa2JuZh6tjpwCfr+7vAbwNyNp+Tk1Njf5b\n", "zk7rLyBJOiGtfO/giSeeGPnz/s1vfnNtnyLiJmA9MAlsAVYDBzNzZ0T8G2Ar8BL9rzP8Rl1bBp8k\n", "ladzwdckv8AuSWqEK7dIkopi8GlWRr1Q5mCIWpJOiMEnSSpKV4LPrzNIkopi8EmSiuJQpySpEV0Z\n", "6jT4JEmNMPgkSUUx+CRJRTH4JElF6UrwOatTklQUKz5JUiOs+CRJGkNWfPPMNTdnNh9/PZbw38P1\n", "YdWWrlR8Bp8kqRFdCT6HOiVJRTH4JElFcahTktSIrgx1GnySpEYYfJKkonQl+LzHJ0kqykgVX0Ss\n", "B+4CngR6wNcz84NNdkyS1C1tVnwRsR1YAxwFtmXm7oFj7wJuAo4AmZmb69o6mYrvzzPz3Zn5LkNP\n", "ktSWiFgHrMrMtcBm4NZpp/w+cHlmvhM4IyIurWvvZIKvG4O5kqQ50ev1Rn4MsQHYAZCZe4BlEbF0\n", "4PhbM3Oier4f+Im6xk4m+H46InZExNciYuNJtCNJUp3l9APtZQeqfQBk5v8DiIizgYuA++saG3VW\n", "5zeBj2XmXRFxDvBIRLwhM4+M2J70Kq4N2Y4S3lfXI50fczir81UvFBGvAe4Ffj0zv1v3wyMFX1VS\n", "3lU9fyoivgOsBJ4ZpT1JUve1GHwTDFR4wApg38sbEXE6/Srvusx8eFhjIw11RsQvRcT11fPXAGcB\n", "e0dpS5K0MLR4j28XsAkgIlYDezPz8MDx7cD2zHxwVv0cpbSvbip+ETiTfnjekJl/NsPpjh1ImlMO\n", "dQ7VSmm2d+/ekd/AlStX1vYpIm4C1gOTwBZgNXCQfig+DzxG//eaAr6YmbfP1NZIwXeCirmSJI0H\n", "g2+ozgVfk1yyTJLUiK4sWWbwSZIaYfBJkorSleBzkWpJUlEMPklSURzqlCQ1oitDnQafJKkRXQk+\n", "hzolSUWx4pO04BT0RfSx0pWKz+CTJDWiK8HnUKckqShWfJKkRljxSZI0hqz4JEmN6ErFZ/BJkhrR\n", "leBzqFOSVBSDT5JUFIc6JUmN6MpQp8EnSWpEV4LPoU5JUlGs+KTCjPpXuetfapiuVHwGnyRp7EXE\n", "dmANcBTYlpm7B46dCnwGODcz3zasLYc6JUljLSLWAasycy2wGbh12imfBP7XbNsz+CRJjej1eiM/\n", "htgA7ADIzD3AsohYOnD8WuB/zLafBp8kadwtB/YPbB+o9gGQmS+cSGPe45MkNWIOJ7ec1AtZ8UmS\n", "xt0EAxUesALYN2pjBp8kqREt3uPbBWwCiIjVwN7MPDz95ZllJdibg+/m+OUfaYz4PT5xkkOFMzl8\n", "+PDIF8mSJUtq+xQRNwHrgUlgC7AaOJiZOyPiQeC1wOuAbwOfysw7ZmrL4JMKY/CJDgZfk5zcIklq\n", "RFdWbvEenySpKFZ80jw6mb+QRx16dMhSbbHikyRpDBl8kqSiONQpSWqEQ52SJI0hg0+SVBSHOiVJ\n", "jXCoU5KkMWTwSZKK4lCnJKkRDnVKkjSGrPgkSY2w4pMkaQxZ8UnzyAWjtZBY8UmSNIYMPklSURzq\n", "lCQ1wqFOSZLGkBWfJKkRVnySJI2hkSu+iNgOrAGOAtsyc3djvZIkaUBd5kTERuDjwBHggcz87bq2\n", "Rqr4ImIdsCoz1wKbgVtHaUeStHD0er2RH3VmkTm/C/w8cAFwcUS8sa69UYc6NwA7ADJzD7AsIpaO\n", "2JYkSXVmzJyIeD3wD5k5kZlTwP3V+TMaNfiWA/sHtg9U+yRJhWqr4qM+c6Yfew44u66xpia3dGMq\n", "jyRpIajLnKF5NOrklgmOrfBWAPtG7YQkaUFo6/O+LnMmOLbCW1ntm9GoFd8uYBNARKwG9mbm4RHb\n", "kiSpzoyZk5nPAKdHxOsi4hTgsur8GfVGXR0+Im4C1gOTwJbM/MZIDUmSNMT0zAFWAwczc2dEXADc\n", "DEwBd2fmp+raGjn4JEnqIldukSQVxeCTJBXF4JMkFaXVf53B9TyPLyLWA3cBT9Kf/vv1zPzg/PZq\n", "/kXEm4B7gO2ZeVtEvBa4k/4faPuAKzLzpfns43w6zvtzB/AW+l/mBfhkZj4wbx2cRxFxM/3lqhYD\n", "nwD+Cq8d4Ljvzc9R+HXTWvANrq1WrZv2eWBtW6/XQX+emb84350YFxFxGnALx05DvhH4dGbeExEf\n", "B64Gfn8++jffZnh/AK7NzPvnoUtjIyIuBM6rPmvOBP4GeBj4vcz8UsnXTs17U/R10+ZQp+t51vOL\n", "/cd6EXgv8OzAvguB+6rn9wEb57hP4+R474/6vga8v3p+EFhCf9r7vdW+kq+d4703iyn886fNoc7l\n", "wODQ5strq32rxdfskp+OiB3AmcCNmfnQfHdoPmXmUeCHETG4e8nA8NTQ9fcWshneH4CtEfGb9ANx\n", "a2Y+P+edm2fVe/NCtfkB4MvAJV47r3pvNtN/bybpXzcfotDrZi4ntxT9F8Y03wQ+lpn/CvgV4HPV\n", "igOamdfPq/0B/SGrDcATwA3z3J95FRHvoz+kuZVjr5fir53qvbmK/ntzJ/Dhkq+bNoPvRNbzLEr1\n", "z2fcVT1/CvgO/fXldKxDEXFq9Xzo+nulycxHMvPr1ea9wM/MZ3/mU0RcAlwHXJqZh/DaecX098br\n", "pt3gcz3PGUTEL0XE9dXz1wBnAXvnt1dj6SHg8ur55cBX5rEvYyci7o6I86vNdfRnCRcnIs6gv1zV\n", "ZZn5vWq31w7Hf2+8blpessz1PI+vmuTzRfr39xYBN2Tmn81vr+ZXRLwduJ3+HwFHgOeBS4AvAKcC\n", "zwBXZebkvHVyHs3w/lwPfAQ4BHyf/vtzYMZGFqiIuIb+e/G39Ic1p4Argc9R+LUzw3tzB/BBCr5u\n", "XKtTklQUV26RJBXF4JMkFcXgkyQVxeCTJBXF4JMkFcXgkyQVxeCTJBXF4JMkFeX/Ax0EI2TKsBZm\n", "AAAAAElFTkSuQmCC\n" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Set the grid and cell parameters\n", "grid_size = 25\n", "num_cells = 10\n", "\n", "# Create the space and activate random cells\n", "space = numpy.zeros((grid_size, grid_size))\n", "\n", "# Now sample the agents.\n", "for cell_id in range(num_cells):\n", " # Sample random position\n", " row = numpy.random.randint(0, grid_size)\n", " col = numpy.random.randint(0, grid_size)\n", " \n", " # \"Endow\" the cell with the resource by setting its value to 1.\n", " space[row, col] = 1\n", " \n", " # Output some info about the agent.\n", " print(\"Endowing cell ({0}, {1}).\".format(row, col))\n", "\n", "# Now show the space\n", "plt.figure()\n", "plt.pcolor(space, snap=True)\n", "plt.colorbar()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## What have we done?\n", "\n", " You should now see a small grid with blank background and a number of endowed cells.\n", " \n", "### Questions\n", "\n", " 1. Are we guaranteed to always have ``num_cells`` cells with endowment? Why or why not?\n", " 2. How can the spatial distribution be characterized?" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Slightly more complicated example\n", "\n", " Let's try a slightly more complicated example by making the following complications:\n", " \n", " * Choose a more interesting spatial distribution.\n", " * Represent the __quantity__, not just presence, of a resource" ] }, { "cell_type": "code", "execution_count": 21, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Endowing cell (13, 11).\n", "Endowing cell (13, 12).\n", "Endowing cell (13, 13).\n", "Endowing cell (12, 12).\n", "Endowing cell (10, 14).\n", "Endowing cell (12, 12).\n", "Endowing cell (11, 13).\n", "Endowing cell (11, 13).\n", "Endowing cell (13, 12).\n", "Endowing cell (12, 12).\n" ] }, { "data": { "text/plain": [ "" ] }, "execution_count": 21, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": [ "iVBORw0KGgoAAAANSUhEUgAAAb4AAAFXCAYAAADdxiujAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", "AAALEgAACxIB0t1+/AAAF7xJREFUeJzt3XHQXXV95/H3TehQiWRcFAXisiN151tK0Sm4CjEQbIDg\n", "SEt30TrTDmo0jkvJjg7dGWGcijDKsqGglRa3Ck2FLe0iIIE1SACxVDezyq6LOLN8q6bQbhKBFMMG\n", "KArJ3T/uwb15fO65z3NzTp7nPL/3a+ZO7j3n3N/53Tt37iff3/nd39Pr9/tIklSKRXPdAUmSDiSD\n", "T5JUFINPklQUg0+SVBSDT5JUFINPklSUg8YdEBHrgRXAYuAK4DeBE4Gd1SFXZuZdrfVQklS0iHgZ\n", "8OfAa4CDgU9m5leG9p8OfAp4EbgrMz9Z115t8EXEacBxmbk8Ig4DvgPcB1yUmZv243VIkjRTvwF8\n", "OzP/MCKOBu4BvjK0/4+AM4AdwF9HxC2Z+cioxsZVfA8A36ru7wKWMKj8ehN2XpKkWcnMm4ceHg38\n", "w0sPIuJ1wD9m5vbq8SZgFTBZ8GXmXuC56uFaBgm7B1gXERcCjwPrMvOp2b8USZJmLiK+CSwDzh7a\n", "fATw5NDjJ4Bj6tqZ0eSWiDgHWAOsA24EPpqZq4CHgEtn3m1JkiaTmW8FzgH+ouawsSOSM5ncshq4\n", "GFidmbuB+4d23wFcO6YJFwOVpPmllctVvV5v4u/7fr8/sk8RcSLwRGb+Q2Y+FBEHRcSrMnMnsB04\n", "cujwZdW2kWorvohYCqwHzs7Mp6ttt0TE8dUhpwLfG/uKJEma3CnAhQAR8RpgSRV6ZOZjwKERcXRE\n", "HMRgGHRzXWO9ur/OEBEfBC4B/pbB/xD6wAbgw8Bu4BlgzUsdGMGKT5Lml1YqvkWLFk38fb937966\n", "iu8XgeuBfw78IoNLbK8CdmXmxohYwaBI6wO3ZOan685VG3wNMfgkaX5pJfgWL1488ff9nj17Dtiv\n", "BcZe45MkaSZ6vW780s3gkyQ1YtGibqyCafBJkhrRlYqvG/EsSVJDrPgkSY3oSsVn8EmSGmHwSZKK\n", "YvBJkopi8EmSitKVnzN0o5eSJDXEik+S1AiHOiVJRTH4JElFMfgkSUUx+CRJRelK8DmrU5JUFCs+\n", "SVIjuvI7PoNPktSIrgx1GnySpEYYfJKkohh8kqSidCX4unElUpKkhljxSZIa0WbFFxHrgRXAYuCK\n", "zPxytf0o4C+APtADjgE+mpl/Naotg0+S1Ii2fs4QEacBx2Xm8og4DPgO8GWAzNwOvK06bjFwP3BH\n", "bT9b6aUkqTi9Xm/i2xgPAO+q7u8CDomI6Z70PuDWzHyurjErPklSI9oa6szMvcBLYbYW2JSZ/WkO\n", "XQucMa49g0+S1Ii2Z3VGxDnAGuDMafadBPzvzHxmXDsGnyRp3ouI1cDFwOrM3D3NIWcD986kLYNP\n", "ktSItiq+iFgKrAdWZebTIw77V8BfzqQ9g0+S1IgWhzrfDbwSuLma1NIHvgY8nJkbq2OOAJ6YSWO9\n", "fn+664ONav0EkqRZaSWhjjnmmIm/77du3XrAln2x4pMkNaIrS5YZfJKkRnQl+PwBuySpKFZ8kqRG\n", "dKXiM/gkSY0w+CRJRWlrkeqmGXySpEZY8UmSitKV4OtGXSpJUkOs+CRJjfAanySpKF0Z6jT4JEmN\n", "sOKTJBXFik+SVJSuBF836lJJkhpixSdJaoTX+CRJRenKUKfBJ0lqhBWfJKkoVnySpKJ0peLrRi8l\n", "SWqIFZ8kqRELZqgzItYDK4DFwBXAt4EbGVSLO4DzMvOFNjspSZr/2gy+qVmUmV+e5pj/AJyUmW+r\n", "a6t2qDMiTgOOy8zlwNuBzwCXAX+cmSuBHwLvn+RFSJIWlkWLFk18qzMii6YecyxwCtAf288x+x8A\n", "3lXd3wUsAVYCd1Tb7gROH3cSSdLC1+v1Jr6NMTWLDomIqU/6Q+DimfSzdqgzM/cCz1UPPwB8BVg9\n", "NLT5BHDkTE4kSVrY2prVOSWL1gKbMvNnlV1EvBe4D/j7mbQ3o8ktEXEOgyHNM4EfDO3qxpVMSVLn\n", "VVm0hkEWvbTtnwHnVduOZga5NDaeI2I1g/LxrMzcDeyOiIOr3cuA7bPuvSRpwWlxqHO6LHrJrwOv\n", "Ab4B3Ab8WkRcVddWbcUXEUuB9cCqzHy62nwvcC5wU/XvV8f2WJK04LU1q3NEFgGQmbcCt1bH/Qtg\n", "Q2b+fl1744Y63w28Eri5upDYB94LXB8RHwIeA744yQuRJC0sLa7cMl0WfQ14ODM3zraxXr8/dubn\n", "/mr9BJKkWWmlNDvjjDMm/r6/5557DticEVdukSQ1wrU6JUmah6z4JEmNWDBrdUqSNBMGnySpKF25\n", "xmfwSZIaYcUnSSpKVyq+bvRSkqSGWPFJkhrhUKckqShdGeo0+CRJjbDikyQVxeCTJBWlK8HXjQFZ\n", "SZIaYsUnSWpEVyo+g0+S1AiDT5JUFINPklQUg0+SVJSuBJ+zOiVJRbHikyQ1wiXLJElFaXOoMyLW\n", "AyuAxcAVmfnloX0HA58Hjs3MN49rqxvxLEma93q93sS3OhFxGnBcZi4H3g58ZsohVwLfmmk/DT5J\n", "UiPaCj7gAeBd1f1dwCERMfyki4D/OtN+OtQpSWpEW0OdmbkXeK56uBbYlJn9of3PRcSM2zP4JEmd\n", "EBHnAGuAM/enHYNPktSIlie3rAYuBlZn5u79acvgkyQ1oq3gi4ilwHpgVWY+Per01W0sg0+S1IgW\n", "K753A68Ebq4mtfSBrwEPZ+bGiLgHeC1wdER8F/h0Zm4Y1ZjBJ0lqRIuTW74AfKFm/xmzac/gkyQ1\n", "wrU6JUmah6z4JEmN6ErFZ/BJkhph8EmSimLwSZKKYvBJkopi8EmSitKV4PPnDJKkoljxSZIa0ZWK\n", "z+CTJDXC4JMkFcXgkyQVxeCTJBWlK8HnrE5JUlGs+CRJjehKxWfwSZIaYfBJkopi8EmSimLwSZKK\n", "0pXgc1anJKkoVnySpEYsWtSNWmps8EXEG4DbgKsz89qI2ACcCOysDrkyM+9qsY+SpA5oc6hzahZN\n", "2XcB8LvAi8CDmXlhXVu1wRcRhwBXAZun7LooMzfNtuOSpIWrreCrySIiYinw74FjMrMfEXdHxJsz\n", "81uj2htXlz4PvAN4fD/6LEkqQK/Xm/g2Rl0W/aTavzQiDgJeBjxV11ht8GXm3sz86TS71kXEfRFx\n", "U0QcNq7HkqSFr63gq8kiMvMnwCeAHwJ/B3wzM39Q194kVyJvYDDUuQp4CLh0gjYkSdpvEXEo8AfA\n", "vwReB7w1In617jmzntWZmfcPPbwDuHbUsZKkcszR7/iOBX6YmT8GiIhvAG8CvjfqCbOu+CLilog4\n", "vnp4al3jkqRytHiNb5/TTHn8KHBsRBxcPX4TUDvUOW5W51uA64DDgRcj4t8ClwAbImI38AywZjY9\n", "liQtTC3O6pyaRR8CNgBbM3NjRFwJfD0iXgD+W2Z+o7af/X6/lY4Oaf0EkqRZaSWhPv7xj0/8fX/Z\n", "ZZcdsHFSV26RJDXCtTolSZqHrPgkSY3oSsVn8EmSGrFgFqmWJGkmrPgkSUUx+CRJRelK8HVjQFaS\n", "pIZY8WlB2rJly0TPu+GGGyZ63nve856JnnfyySdP9DxpPupKxWfwSZIaYfBJkopi8EmSimLwSZKK\n", "0pXgc1anJKkoVnySpEZ0peIz+CRJjXCtTklSUaz4JElFMfgkSUXpSvB1Y0BWkqSGWPFpQZp0Dczl\n", "y5dP9LzPfe5zEz1PWki6UvEZfJKkRhh8kqSitBl8EfEG4Dbg6sy8dsq+vwP+HtgL9IHfzcwdo9oy\n", "+CRJjWgr+CLiEOAqYPOIQ/rAWZn5TzNpz8ktkqRG9Hq9iW9jPA+8A3h81Kmr24wYfJKkeS0z92bm\n", "T8cc9p8i4m8i4vJx7Rl8kqRGtFjxjfMHwIXASuD4iPg3dQd7jU+S1Ii5WqszM//zS/cjYhNwPIOJ\n", "MNMy+CRJjThAP2fY5yQRsRS4E1idmc8DpwK31DVg8EmSGtHirM63ANcBhwMvRsSHgA3A1szcGBG3\n", "AFsiYjfwvzLz1rr2DD5JUiPaCr7M/O8Mhi9H7b8GuGam7Tm5RZJUFCs+aUi/35/oeeeff/5Ez3ON\n", "Ty0k/iFaSVJRXKtTklQUg0+SVBSDT5JUlK4EXzeuREqS1BArPklSI5zVKUkqSleGOg0+SVIjDD5J\n", "UlEMPklSUbpyja8bvZQkqSFWfJKkRjjUKRVk0sWmt2zZMvE5Tz755ImfK7XB4JMkFcXgkyQVxeCT\n", "JBXFWZ2SJM1DVnySpEY41ClJKsqCCb6IeANwG3B1Zl4bEa8FbmQwTLoDOC8zX2i3m5Kk+a7N4Jua\n", "RVP2vQ24HHgRyMxcW9dW7TW+iDgEuArYPLT5MuCazFwJ/BB4/6xfgSRpwVm0aNHEtzojsmjYnwLn\n", "ZuYpwNKIOKu2n2Nex/PAO4DHh7adBtxZ3b8TOH1MG5KkAvR6vYlvY0yXRcPelJnbq/tPAq+sa6w2\n", "+DJzb2b+dMrmJUNDm08AR9b3V5KkyY3IouH9/xcgIo4EzgA21bW3v5NbunElU5LUurmc3BIRrwbu\n", "AM7PzB/XHTtJ8O2OiIMz8yfAMmD7uCdImp7rbWohmavgi4hDGVR5F2fmfeOOn+QH7PcC51b3zwW+\n", "OkEbkqQFpsVrfPucZpptVzOY7XnPjBro9/sjd0bEW4DrgMMZTBN9ClgNfBE4GHgMWJOZe2rOMfoE\n", "kqS50Eppdvfdd0/8fb969eqRfRqRRRuArQxmej4FbGHwuvrATZl53aj2aoOvIQafJM0vrQTf5s2b\n", "J/6+P/PMMw/YOKlrdUqSiuKSZZKkRiyYJcskSZoJg0+SVJSu/D0+g0+S1IiuVHzdiGdJkhpi8EmS\n", "iuJQpySpEV0Z6jT4JEmNMPgkSUUx+CRJRTH4JElF6UrwOatTklQUKz5JUiO6UvEZfJKkRnQl+Bzq\n", "lCQVxYpPktSIrlR8Bp8kqRFdCT6HOiVJRbHikyQ1oisVn8EnSWqEwSdJKorBJ0kqSpvBFxFXAycB\n", "e4GPZOaDQ/vOAT4GPA/8l8z8k7q2nNwiSWpEr9eb+FYnIk4FXp+Zy4G1wGeH9vWAa4CzgJXAb0TE\n", "UXXtGXySpPluFXA7QGY+ArwiIl5e7XsV8OPMfCoz+8BfA6fXNWbwSZLmuyOAJ4ce76y2kZlPAodG\n", "xC9FxC8ApwCvqWvMa3ySpEYcwMktU0/0AeCLwOPAjmn278PgkyQ1osXg205V4VWOYhBwAGTm/cAK\n", "gIj4PPBoXWMGnySpES0G32bgE8AXIuIEYFtmPvvSzojYBJzHYMbnKuCiusYMPklSI9oKvszcEhH/\n", "IyK+CewBLoiI9wK7MnMj8HkG4bgY+FhmPlXbz36/30pHh7R+AknSrLSSUA899NDE3/dvfOMbD9gF\n", "Qis+SVIjXLlFklQUg0+SVBSDT5JUlK4Enyu3SJKKYvBJkoriUKckqRFdGeo0+CRJjTD4JElFMfgk\n", "SUUx+CRJRelK8DmrU5JUFCs+SVIjrPgkSZqHrPgkSY3oSsVn8EmSGtGV4HOoU5JUFINPklQUhzol\n", "SY3oylCnwSdJaoTBJ0kqSleCz2t8kqSiTFTxRcRK4EvA94Ae8N3M/HCTHZMkdUubFV9EXA2cBOwF\n", "PpKZDw7tey3wl8AvAP8zM3+vrq39qfi+npm/nplvM/QkSW2JiFOB12fmcmAt8Nkph1wFXJmZJwF7\n", "qiAcaX+CrxuDuZKkA6LX6018G2MVcDtAZj4CvCIiXg4QET1gBXBntf/fZeb/qWtsf4LvVyLi9oh4\n", "ICJO3492JEmqcwTw5NDjndU2gMOBZ4DPRMTfRMTl4xqbNPi+D3wiM38LeB9wfUQ4Q1SSCtZixfdz\n", "p5pyfxnwaWAl8GsR8fa6J08UfJm5PTO/VN3fCvyoOrEkqVAtBt92/n+FB3AUsKO6vxN4NDMfzcy9\n", "wH3AcXWNTRR8EfE7EXFJdf/VDErNbZO0JUlaGFoMvs3AOwEi4gRgW2Y+C5CZe4CtEfFL1bEnAlnb\n", "z36/P+sXV11UvAk4jEF4XpqZd484fPYnkCS1qZXJidu2bZv4+37ZsmW1faqu3a0E9gAXACcAuzJz\n", "YxV6f87gdT2cmefXtTVR8M2SwSdJ80vngq9JTkiRJDWiK0uWGXySpEYYfJKkonQl+FykWpJUFINP\n", "klQUhzolSY3oylCnwSdJakRXgs+hTklSUaz4JEmN6ErFZ/BJkhrRleBzqFOSVBQrPklSI6z4JEma\n", "h6z4JEmN6ErFZ/BJkhrRleBzqFOSVBSDT5JUFIc6JUmN6MpQp8EnSWpEV4LPoU5JUlGs+CRJjehK\n", "xWfwSZLmvYi4GjgJ2At8JDMfHNr3QeD9wIvAQ5m5rq4thzolSfNaRJwKvD4zlwNrgc8O7XsZ8NvA\n", "WzPzFODYiDiprj0rPklSI1oc6lwF3A6QmY9ExCsi4uWZ+Uxm/hNwBkBEHAIsBX5U15gVnyRpvjsC\n", "eHLo8c5q289ExEeB7wM3Z+ajdY0ZfJKkRvR6vYlvsz3V1A2Z+R+BY4C3R8TJdU82+CRJ89129q3w\n", "jgJ2AETEYRGxEiAzfwLcBby1rjGDT5LUiBYrvs3AOwEi4gRgW2Y+W+07CPiz6voewJuBrO1nv9+f\n", "/FXOTOsnkCTNSiuzUJ599tmJv++XLFlS26eIuBxYCewBLgBOAHZl5saIeA+wDniBwc8Zfq+uLYNP\n", "ksrTueBrkj9nkCQ1oisrt3iNT5JUFCs+SVIjrPgkSZqHDD5JUlEc6pQkNcKhTkmS5iGDT5JUFIc6\n", "JUmNcKhTkqR5yOCTJBXFoU5JUiMc6pQkaR6y4pMkNcKKT5KkeciKT5LUCCs+SZLmIYNPklQUhzol\n", "SY1wqFOSpHnIik+S1AgrPkmS5qGJK76IuBo4CdgLfCQzH2ysV5IkDanLnIg4HfgU8CJwV2Z+sq6t\n", "iSq+iDgVeH1mLgfWAp+dpB1J0sLR6/UmvtWZQeb8EfCvgRXAmRHxy3XtTTrUuQq4HSAzHwFeEREv\n", "n7AtSZLqjMyciHgd8I+ZuT0z+8Cm6viRJg2+I4Anhx7vrLZJkgrVVsVHfeZM3fcEcGRdY01NbunG\n", "VB5J0kJQlzlj82jSyS3b2bfCOwrYMWknJEkLQlvf93WZs519K7xl1baRJq34NgPvBIiIE4Btmfns\n", "hG1JklRnZOZk5mPAoRFxdEQcBJxdHT9Sr9/vT9SLiLgcWAnsAS7IzIcnakiSpDGmZg5wArArMzdG\n", "xApgPdAHbsnMT9e1NXHwSZLURa7cIkkqisEnSSqKwSdJKkqrf53B9TynFxErgS8B32Mw/fe7mfnh\n", "ue3V3IuINwC3AVdn5rUR8VrgRgb/QdsBnJeZL8xlH+fSNO/PBuBEBj/mBbgyM++asw7OoYhYz2C5\n", "qsXAFcC38bMDTPve/CaFf25aC77htdWqddP+DFje1vk66OuZ+dtz3Yn5IiIOAa5i32nIlwHXZOZt\n", "EfEp4P3An85F/+baiPcH4KLM3DQHXZo3IuI04Ljqu+Yw4DvAfcAfZ+atJX92at6boj83bQ51up5n\n", "PX/Yv6/ngXcAjw9tOw24s7p/J3D6Ae7TfDLd+6OBB4B3Vfd3AUsYTHu/o9pW8mdnuvdmMYV//7Q5\n", "1HkEMDy0+dLaaj9o8Zxd8isRcTtwGHBZZt471x2aS5m5F/hpRAxvXjI0PDV2/b2FbMT7A7AuIn6f\n", "QSCuy8ynDnjn5lj13jxXPfwA8BVgtZ+dn3tv1jJ4b/Yw+NxcSKGfmwM5uaXo/2FM8X3gE5n5W8D7\n", "gOurFQc0mp+fn3cDgyGrVcBDwKVz3J85FRHnMBjSXMe+n5fiPzvVe7OGwXtzI/DRkj83bQbfbNbz\n", "LEr15zO+VN3fCvyIwfpy2tfuiDi4uj92/b3SZOb9mfnd6uEdwK/OZX/mUkSsBi4GzsrM3fjZ+Zmp\n", "742fm3aDz/U8R4iI34mIS6r7rwYOB7bNba/mpXuBc6v75wJfncO+zDsRcUtEHF89PJXBLOHiRMRS\n", "BstVnZ2ZT1eb/eww/Xvj56blJctcz3N61SSfmxhc31sEXJqZd89tr+ZWRLwFuI7BfwJeBJ4CVgNf\n", "BA4GHgPWZOaeOevkHBrx/lwCfAzYDTzD4P3ZObKRBSoiPsjgvfhbBsOafeC9wPUU/tkZ8d5sAD5M\n", "wZ8b1+qUJBXFlVskSUUx+CRJRTH4JElFMfgkSUUx+CRJRTH4JElFMfgkSUUx+CRJRfl/3Frm7Cuu\n", "kq8AAAAASUVORK5CYII=\n" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Set the grid and agent parameters\n", "grid_size = 25\n", "num_cells = 10\n", "spread = 1\n", "\n", "# Create the space and activate random cells\n", "space = numpy.zeros((grid_size, grid_size))\n", "\n", "# Now sample the agents.\n", "for cell_id in range(num_cells):\n", " # Sample random position\n", " row = int(numpy.random.normal((grid_size) / 2.0, spread))\n", " col = int(numpy.random.normal((grid_size) / 2.0, spread))\n", "\n", " # \"Activate\" the cell by setting its value to 1.\n", " space[row, col] += 1\n", " \n", " # Output some info about the agent.\n", " print(\"Endowing cell ({0}, {1}).\".format(row, col))\n", "\n", "# Now show the space\n", "f = plt.figure()\n", "plt.pcolor(space, snap=True)\n", "plt.colorbar()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## What have we done (this time)?\n", "\n", " You should now see a small grid with blank background and a number of endowed cells. Unlike the previous example, the _intensity of these cells should vary with the quantity of resource that has been placed_.\n", "\n", "### Questions\n", "\n", " 1. How can the spatial distribution be characterized? How does the ``spread`` parameter come into play?\n", " 2. What is the range of possible values for cell quantities?" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Interactive plotting\n", "\n", " Next, let's create an interactive widget that helps us understand how the spread parameter affects the grid's initial conditions. In the code below, we wrap our example above in a method labeled ``gaussian_initial_grid``, which we then call via the ``interact`` method.\n", " \n", " When you run the code, perform the following visual \"experiments\":\n", " \n", " * Fixing ``num_cells`` and ``spread``, vary ``grid_size``. Does the qualitative character of the initial conditions change?\n", " * Fixing ``grid_size`` and ``spread``, vary ``num_cells``. Does the qualitative character of the initial conditions change?\n", " * Fixing ``num_cells`` and ``grid_size``, vary ``spread``. Does the qualitative character of the initial conditions change?" ] }, { "cell_type": "code", "execution_count": 34, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 34, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": [ "iVBORw0KGgoAAAANSUhEUgAAAb4AAAFXCAYAAADdxiujAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", "AAALEgAACxIB0t1+/AAAF7RJREFUeJzt3X/wXXV95/HnTehQiWRcFAXisiN1511K0Sm4CjEQbIDg\n", "SEu7aJ1pBzUaR1uyo0N3RhingzjKsqGglZbZCjS1bGmL/AqsQQKIpdpMla6LOLO8q6bQbhKBFMMG\n", "KArJ3T/uifvN1+899/u9OSffe76f52PmTu4959zP+dw7d+7r+/6cz/2k1+/3kSSpFIvmuwOSJB1M\n", "Bp8kqSgGnySpKAafJKkoBp8kqSgGnySpKIeMOiAi1gMrgMXAFcCvAicDO6tDrszMu1vroSSpaBHx\n", "MuBPgdcAhwKfyswvTdl/JvBp4CXg7sz8VF17tcEXEWcAJ2Tm8og4AvgWcD9wcWZuOoDXIUnSbP0K\n", "8M3M/P2IOBa4F/jSlP1/AJwF7AD+OiJuycxHhzU2quJ7EPhGdX8XsIRB5dcbs/OSJM1JZt485eGx\n", "wD/vexARrwP+JTO3V483AauA8YIvM/cCz1cP1zJI2D3Auoi4CHgCWJeZT8/9pUiSNHsR8XVgGXDu\n", "lM1HAU9NefwkcFxdO7Oa3BIR5wFrgHXAjcDHMnMV8DBw2ey7LUnSeDLzrcB5wJ/XHDZyRHI2k1tW\n", "A5cAqzNzN/DAlN13AteOaMLFQCVpsrRyuarX6439fd/v94f2KSJOBp7MzH/OzIcj4pCIeFVm7gS2\n", "A0dPOXxZtW2o2oovIpYC64FzM/OZatstEXFidcjpwHdGviJJksZ3GnARQES8BlhShR6Z+ThweEQc\n", "GxGHMBgG3VzXWK/uf2eIiA8ClwL/wOAvhD6wAfgIsBt4FlizrwNDWPFJ0mRppeJbtGjR2N/3e/fu\n", "rav4fha4Afi3wM8yuMT2KmBXZm6MiBUMirQ+cEtmfqbuXLXB1xCDT5ImSyvBt3jx4rG/7/fs2XPQ\n", "fi0w8hqfJEmz0et145duBp8kqRGLFnVjFUyDT5LUiK5UfN2IZ0mSGmLFJ0lqRFcqPoNPktQIg0+S\n", "VBSDT5JUFINPklSUrvycoRu9lCSpIVZ8kqRGONQpSSqKwSdJKorBJ0kqisEnSSpKV4LPWZ2SpKJY\n", "8UmSGtGV3/EZfJKkRnRlqNPgkyQ1wuCTJBXF4JMkFaUrwdeNK5GSJDXEik+S1Ig2K76IWA+sABYD\n", "V2Tm7dX2Y4A/B/pADzgO+Fhm/uWwtgw+SVIj2vo5Q0ScAZyQmcsj4gjgW8DtAJm5HXhbddxi4AHg\n", "ztp+ttJLSVJxer3e2LcRHgTeVd3fBRwWETM96X3ArZn5fF1jVnySpEa0NdSZmXuBfWG2FtiUmf0Z\n", "Dl0LnDWqPYNPktSItmd1RsR5wBrg7Bn2nQL878x8dlQ7Bp8kaeJFxGrgEmB1Zu6e4ZBzgftm05bB\n", "J0lqRFsVX0QsBdYDqzLzmSGH/QfgL2bTnsEnSWpEi0Od7wZeCdxcTWrpA18BHsnMjdUxRwFPzqax\n", "Xr8/0/XBRrV+AknSnLSSUMcdd9zY3/dbt249aMu+WPFJkhrRlSXLDD5JUiO6Enz+gF2SVBQrPklS\n", "I7pS8Rl8kqRGGHySpKK0tUh10ww+SVIjrPgkSUXpSvB1oy6VJKkhVnySpEZ4jU+SVJSuDHUafJKk\n", "RljxSZKKYsUnSSpKV4KvG3WpJEkNseKTJDXCa3ySpKJ0ZajT4JMkNcKKT5JUFCs+SVJRulLxdaOX\n", "kiQ1xIpPktSIBTPUGRHrgRXAYuAK4JvAjQyqxR3ABZn5YpudlCRNvjaDb3oWZebtMxzzX4BTMvNt\n", "dW3VDnVGxBnACZm5HHg78Fngk8AfZuZK4PvA+8d5EZKkhWXRokVj3+oMyaLpxxwPnAb0R/ZzxP4H\n", "gXdV93cBS4CVwJ3VtruAM0edRJK08PV6vbFvI0zPosMiYvqTfh+4ZDb9rB3qzMy9wPPVww8AXwJW\n", "TxnafBI4ejYnkiQtbG3N6pyWRWuBTZn5k8ouIt4L3A/802zam9Xklog4j8GQ5tnA96bs6saVTElS\n", "51VZtIZBFu3b9m+AC6ptxzKLXBoZzxGxmkH5eE5m7gZ2R8Sh1e5lwPY5916StOC0ONQ5Uxbt88vA\n", "a4CvAbcBvxQRV9W1VVvxRcRSYD2wKjOfqTbfB5wP3FT9++WRPZYkLXhtzeockkUAZOatwK3Vcf8O\n", "2JCZv1vX3qihzncDrwRuri4k9oH3AjdExIeAx4EvjPNCJEkLS4srt8yURV8BHsnMjXNtrNfvj5z5\n", "eaBaP4EkaU5aKc3OOuussb/v77333oM2Z8SVWyRJjXCtTkmSJpAVnySpEQtmrU5JkmbD4JMkFaUr\n", "1/gMPklSI6z4JElF6UrF141eSpLUECs+SVIjHOqUJBWlK0OdBp8kqRFWfJKkohh8kqSidCX4ujEg\n", "K0lSQ6z4JEmN6ErFZ/BJkhph8EmSimLwSZKKYvBJkorSleBzVqckqShWfJKkRrhkmSSpKG0OdUbE\n", "emAFsBi4IjNvn7LvUODzwPGZ+eZRbXUjniVJE6/X6419qxMRZwAnZOZy4O3AZ6cdciXwjdn20+CT\n", "JDWireADHgTeVd3fBRwWEVOfdDHwP2bbT4c6JUmNaGuoMzP3As9XD9cCmzKzP2X/8xEx6/YMPklS\n", "J0TEecAa4OwDacfgkyQ1ouXJLauBS4DVmbn7QNoy+CRJjWgr+CJiKbAeWJWZzww7fXUbyeCTJDWi\n", "xYrv3cArgZurSS194CvAI5m5MSLuBV4LHBsR3wY+k5kbhjVm8EmSGtHi5JbrgOtq9p81l/YMPklS\n", "I1yrU5KkCWTFJ0lqRFcqPoNPktQIg0+SVBSDT5JUFINPklQUg0+SVJSuBJ8/Z5AkFcWKT5LUiK5U\n", "fAafJKkRBp8kqSgGnySpKAafJKkoXQk+Z3VKkopixSdJakRXKj6DT5LUCINPklQUg0+SVBSDT5JU\n", "lK4En7M6JUlFseKTJDVi0aJu1FIjgy8i3gDcBlydmddGxAbgZGBndciVmXl3i32UJHVAm0Od07No\n", "2r4Lgd8CXgIeysyL6tqqDb6IOAy4Ctg8bdfFmblprh2XJC1cbQVfTRYREUuB/wwcl5n9iLgnIt6c\n", "md8Y1t6ouvQF4B3AEwfQZ0lSAXq93ti3Eeqy6EfV/qURcQjwMuDpusZqgy8z92bmj2fYtS4i7o+I\n", "myLiiFE9liQtfG0FX00WkZk/Aj4BfB/4R+Drmfm9uvbGuRL5ZwyGOlcBDwOXjdGGJEkHLCIOB34P\n", "+PfA64C3RsQv1j1nzrM6M/OBKQ/vBK4ddqzUNVu2bBnreaeeemrDPZG6Z55+x3c88P3M/CFARHwN\n", "eBPwnWFPmHPFFxG3RMSJ1cPT6xqXJJWjxWt8+51m2uPHgOMj4tDq8ZuA2qHOUbM63wJcDxwJvBQR\n", "HwYuBTZExG7gWWDNXHosSVqYWpzVOT2LPgRsALZm5saIuBL4akS8CPxtZn6trr3a4MvMvwNOnGHX\n", "7WP1XpK0YLUVfDVZtG//dcB1s23PlVskSY1wrU5JkiaQFZ8kqRFdqfgMPklSIxbMItWSJM2GFZ8k\n", "qSgGnySpKF0Jvm4MyEqS1BArPklSI7pS8Rl8kqRGGHySpKIYfJKkohh8kqSidCX4nNUpSSqKFZ8k\n", "qRFdqfgMPklSI1yrU5JUFCs+SVJRDD5JUlG6EnzdGJCVJKkhVnxakMb9y7Pf74/1vC1btoz1vFNP\n", "PXWs50mTqCsVn8EnSWqEwSdJKkqbwRcRbwBuA67OzGun7ftH4J+AvUAf+K3M3DGsLYNPktSItoIv\n", "Ig4DrgI2DzmkD5yTmf86m/ac3CJJakSv1xv7NsILwDuAJ4adurrNisEnSZpombk3M3884rD/FhF/\n", "ExGXj2rP4JMkNaLFim+U3wMuAlYCJ0bEf6w72Gt8kqRGzNdanZn53/fdj4hNwIkMJsLMyOCTJDXi\n", "IP2cYb+TRMRS4C5gdWa+AJwO3FLXgMEnSWpEi7M63wJcDxwJvBQRHwI2AFszc2NE3AJsiYjdwP/K\n", "zFvr2jP4JEmNaCv4MvPvGAxfDtt/DXDNbNtzcoskqShWfFqQPvzhDx/U84275ua4a3weyDmltvgf\n", "0UqSiuJanZKkohh8kqSiGHySpKJ0Jfi6cSVSkqSGWPFJkhrhrE5JUlG6MtRp8EmSGmHwSZKKYvBJ\n", "korSlWt83eilJEkNseKTJDXCoU5pHr3nPe+Z7y7MigtNayEx+CRJRTH4JElFMfgkSUVxVqckSRPI\n", "ik+S1AiHOiVJRVkwwRcRbwBuA67OzGsj4rXAjQyGSXcAF2Tmi+12U5I06doMvulZNG3f24DLgZeA\n", "zMy1dW3VXuOLiMOAq4DNUzZ/ErgmM1cC3wfeP+dXIElacBYtWjT2rc6QLJrqj4HzM/M0YGlEnFPb\n", "zxGv4wXgHcATU7adAdxV3b8LOHNEG5KkAvR6vbFvI8yURVO9KTO3V/efAl5Z11ht8GXm3sz88bTN\n", "S6YMbT4JHF3fX0mSxjcki6bu/78AEXE0cBawqa69A53c0o0rmZKk1s3n5JaIeDVwJ/DbmfnDumPH\n", "Cb7dEXFoZv4IWAZsH/UE6WBzDUzp4Juv4IuIwxlUeZdk5v2jjh/nB+z3AedX988HvjxGG5KkBabF\n", "a3z7nWaGbVczmO1576wa6Pf7Q3dGxFuA64EjGUwTfRpYDXwBOBR4HFiTmXtqzjH8BJKk+dBKaXbP\n", "PfeM/X2/evXqoX0akkUbgK0MZno+DWxh8Lr6wE2Zef2w9mqDryEGnyRNllaCb/PmzWN/35999tkH\n", "bZzUtTolSUVxyTJJUiMWzJJlkiTNhsEnSSpKV/4/PoNPktSIrlR83YhnSZIaYvBJkoriUKckqRFd\n", "Geo0+CRJjTD4JElFMfgkSUUx+CRJRelK8DmrU5JUFCs+SVIjulLxGXySpEZ0Jfgc6pQkFcWKT5LU\n", "iK5UfAafJKkRXQk+hzolSUWx4pMkNaIrFZ/BJ0lqhMEnSSqKwSdJKkqbwRcRVwOnAHuBj2bmQ1P2\n", "nQd8HHgB+KvM/KO6tpzcIklqRK/XG/tWJyJOB16fmcuBtcDnpuzrAdcA5wArgV+JiGPq2jP4JEmT\n", "bhVwB0BmPgq8IiJeXu17FfDDzHw6M/vAXwNn1jVm8EmSJt1RwFNTHu+stpGZTwGHR8TPRcTPAKcB\n", "r6lrzGt8kqRGHMTJLdNP9AHgC8ATwI4Z9u/H4JMkNaLF4NtOVeFVjmEQcABk5gPACoCI+DzwWF1j\n", "Bp8kqREtBt9m4BPAdRFxErAtM5/btzMiNgEXMJjxuQq4uK4xg0+S1Ii2gi8zt0TE30fE14E9wIUR\n", "8V5gV2ZuBD7PIBwXAx/PzKdr+9nv91vp6BStn0CSNCetJNTDDz889vf9G9/4xoN2gdCKT5LUCFdu\n", "kSQVxeCTJBXF4JMkFaUrwefKLZKkohh8kqSiONQpSWpEV4Y6DT5JUiMMPklSUQw+SVJRDD5JUlG6\n", "EnzO6pQkFcWKT5LUCCs+SZImkBWfJKkRXan4DD5JUiO6EnwOdUqSimLwSZKK4lCnJKkRXRnqNPgk\n", "SY0w+CRJRelK8HmNT5JUlLEqvohYCXwR+A7QA76dmR9psmOSpG5ps+KLiKuBU4C9wEcz86Ep+14L\n", "/AXwM8D/zMzfqWvrQCq+r2bmL2fm2ww9SVJbIuJ04PWZuRxYC3xu2iFXAVdm5inAnioIhzqQ4OvG\n", "YK4k6aDo9Xpj30ZYBdwBkJmPAq+IiJcDREQPWAHcVe3/T5n5f+oaO5Dg+4WIuCMiHoyIMw+gHUmS\n", "6hwFPDXl8c5qG8CRwLPAZyPibyLi8lGNjRt83wU+kZm/BrwPuCEinCEqSQVrseL7qVNNu78M+Ayw\n", "EviliHh73ZPHCr7M3J6ZX6zubwV+UJ1YklSoFoNvO/+/wgM4BthR3d8JPJaZj2XmXuB+4IS6xsYK\n", "voj4zYi4tLr/agal5rZx2pIkLQwtBt9m4J0AEXESsC0znwPIzD3A1oj4uerYk4Gs7We/35/zi6su\n", "Kt4EHMEgPC/LzHuGHD73E0iS2tTK5MRt27aN/X2/bNmy2j5V1+5WAnuAC4GTgF2ZubEKvT9l8Loe\n", "yczfrmtrrOCbI4NPkiZL54KvSU5IkSQ1oitLlhl8kqRGGHySpKJ0JfhcpFqSVBSDT5JUFIc6JUmN\n", "6MpQp8EnSWpEV4LPoU5JUlGs+CRJjehKxWfwSZIa0ZXgc6hTklQUKz5JUiOs+CRJmkBWfJKkRnSl\n", "4jP4JEmN6ErwOdQpSSqKwSdJKopDnZKkRnRlqNPgkyQ1oivB51CnJKkoVnySpEZ0peIz+CRJEy8i\n", "rgZOAfYCH83Mh6bs+yDwfuAl4OHMXFfXlkOdkqSJFhGnA6/PzOXAWuBzU/a9DPgN4K2ZeRpwfESc\n", "UteeFZ8kqREtDnWuAu4AyMxHI+IVEfHyzHw2M/8VOAsgIg4DlgI/qGvMik+SNOmOAp6a8nhnte0n\n", "IuJjwHeBmzPzsbrGDD5JUiN6vd7Yt7meavqGzPyvwHHA2yPi1LonG3ySpEm3nf0rvGOAHQARcURE\n", "rATIzB8BdwNvrWvM4JMkNaLFim8z8E6AiDgJ2JaZz1X7DgH+pLq+B/BmIGv72e/3x3+Vs9P6CSRJ\n", "c9LKLJTnnntu7O/7JUuW1PYpIi4HVgJ7gAuBk4BdmbkxIt4DrANeZPBzht+pa8vgk6TydC74muTP\n", "GSRJjejKyi1e45MkFcWKT5LUCCs+SZImkMEnSSqKQ52SpEY41ClJ0gQy+CRJRXGoU5LUCIc6JUma\n", "QAafJKkoDnVKkhrhUKckSRPIik+S1AgrPkmSJpAVnySpEVZ8kiRNIINPklQUhzolSY1wqFOSpAlk\n", "xSdJaoQVnyRJE2jsii8irgZOAfYCH83MhxrrlSRJU9RlTkScCXwaeAm4OzM/VdfWWBVfRJwOvD4z\n", "lwNrgc+N044kaeHo9Xpj3+rMInP+APh1YAVwdkT8fF174w51rgLuAMjMR4FXRMTLx2xLkqQ6QzMn\n", "Il4H/Etmbs/MPrCpOn6ocYPvKOCpKY93VtskSYVqq+KjPnOm73sSOLqusaYmt3RjKo8kaSGoy5yR\n", "eTTu5Jbt7F/hHQPsGLcTkqQFoa3v+7rM2c7+Fd6yattQ41Z8m4F3AkTEScC2zHxuzLYkSaozNHMy\n", "83Hg8Ig4NiIOAc6tjh+q1+/3x+pFRFwOrAT2ABdm5iNjNSRJ0gjTMwc4CdiVmRsjYgWwHugDt2Tm\n", "Z+raGjv4JEnqIldukSQVxeCTJBXF4JMkFaXV/53B9TxnFhErgS8C32Ew/ffbmfmR+e3V/IuINwC3\n", "AVdn5rUR8VrgRgZ/oO0ALsjMF+ezj/NphvdnA3Aygx/zAlyZmXfPWwfnUUSsZ7Bc1WLgCuCb+NkB\n", "ZnxvfpXCPzetBd/UtdWqddP+BFje1vk66KuZ+Rvz3YlJERGHAVex/zTkTwLXZOZtEfFp4P3AH89H\n", "/+bbkPcH4OLM3DQPXZoYEXEGcEL1XXME8C3gfuAPM/PWkj87Ne9N0Z+bNoc6Xc+znj/s398LwDuA\n", "J6ZsOwO4q7p/F3DmQe7TJJnp/dHAg8C7qvu7gCUMpr3fWW0r+bMz03uzmMK/f9oc6jwKmDq0uW9t\n", "te+1eM4u+YWIuAM4AvhkZt433x2aT5m5F/hxREzdvGTK8NTI9fcWsiHvD8C6iPhdBoG4LjOfPuid\n", "m2fVe/N89fADwJeA1X52fuq9WcvgvdnD4HNzEYV+bg7m5Jai/8KY5rvAJzLz14D3ATdUKw5oOD8/\n", "P+3PGAxZrQIeBi6b5/7Mq4g4j8GQ5jr2/7wU/9mp3ps1DN6bG4GPlfy5aTP45rKeZ1Gq/z7ji9X9\n", "rcAPGKwvp/3tjohDq/sj198rTWY+kJnfrh7eCfzifPZnPkXEauAS4JzM3I2fnZ+Y/t74uWk3+FzP\n", "c4iI+M2IuLS6/2rgSGDb/PZqIt0HnF/dPx/48jz2ZeJExC0RcWL18HQGs4SLExFLGSxXdW5mPlNt\n", "9rPDzO+Nn5uWlyxzPc+ZVZN8bmJwfW8RcFlm3jO/vZpfEfEW4HoGfwS8BDwNrAa+ABwKPA6sycw9\n", "89bJeTTk/bkU+DiwG3iWwfuzc2gjC1REfJDBe/EPDIY1+8B7gRso/LMz5L3ZAHyEgj83rtUpSSqK\n", "K7dIkopi8EmSimLwSZKKYvBJkopi8EmSimLwSZKKYvBJkopi8EmSivL/AD1O5i8cCc2JAAAAAElF\n", "TkSuQmCC\n" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# First, we'll wrap our experiments above in a method that takes as input our grid parameters.\n", "def gaussian_initial_grid(grid_size=25, num_cells=10, spread=1):\n", " \"\"\"\n", " Create an initial 2D grid with Gaussian/normal-distributed cells.\n", " \"\"\"\n", " # Create the space and activate random cells\n", " space = numpy.zeros((grid_size, grid_size))\n", "\n", " # Now sample the agents.\n", " for cell_id in range(num_cells):\n", " # Sample random position\n", " row = int(numpy.random.normal((grid_size) / 2.0, spread))\n", " col = int(numpy.random.normal((grid_size) / 2.0, spread))\n", "\n", " # \"Activate\" the cell by setting its value to 1.\n", " space[row, col] += 1\n", "\n", " # Now show the space\n", " f = plt.figure()\n", " plt.pcolor(space, snap=True)\n", " plt.colorbar()\n", "\n", "# Import widget methods\n", "from IPython.html.widgets import interact, fixed\n", "\n", "interact(gaussian_initial_grid, grid_size=(5, 100),\n", " num_cells = (1, 500),\n", " spread=(1, 100))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Boundaries\n", "\n", " If all went as planned, in your third experiment with ``spread``, you should have generated an error. This particular error is called an __IndexError__, because it occured when we tried to access or index a cell that did not exist in our space.\n", " \n", " For example, if we have a (10, 10) grid, there are no cells with the label (27, 4) or (-15, 8). However, based on our method for sampling the resource positions, there is some non-zero probability that we will try these cells.\n", " \n", " This is an example of __boundary__ in space. There are a number of approaches to addressing it:\n", " \n", " * change assumptions about distributions or dynamics so that the environment terminates; for example, we could:\n", " * clump all resources up at the edges; for example, if we drew ``-4`` as a column, place the resource instead in column 0\n", " * change to a distribution that allows for bounded support, i.e., a uniform distribution or truncated normal\n", " * __wrap__ cells around the boundary, similar to a torus or sphere; for example, if we drew ``-1`` as a column, we would wrap all the way around to the last column and place the resource there instead.\n", " \n", " In the example below, we'll go with the ``wrapping`` or torus approach. To obtain the desired effect, we'll use the [__modulo__ operator ``%``](http://en.wikipedia.org/wiki/Modulo_operation)." ] }, { "cell_type": "code", "execution_count": 42, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 42, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": [ "iVBORw0KGgoAAAANSUhEUgAAAb4AAAFXCAYAAADdxiujAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", "AAALEgAACxIB0t1+/AAAGTVJREFUeJzt3X2wXXV97/H3DrQ8Sa6CFBAaig/nK4PSKTKFGx6FUyIX\n", "OlQoA1NKkU5aNbEzltoZcIpVrtpMhIh2bqZOaFF6qx2qwZQhtPFAlYLWW+xMC3eG7ymgQA3DUw2N\n", "coOEnPvH3sR9jjnrnKysnbXWWe/XzB72Xmud3/7mPOTD97d+55fe1NQUkiR1xaK6C5AkaW8y+CRJ\n", "nWLwSZI6xeCTJHWKwSdJ6hSDT5LUKfvOdUFEnACsB9Zk5tqIOBr4S/qh+RRwRWa+PNoyJUldFxH7\n", "Aw8B12fmrUPHx4FPANuBuzLz40XjFHZ8EXEgcCOwaejw9cCfZuaZwKPAb5f6E0iStHuuA57fxfHP\n", "AO8GTgPOjYi3Fg0y11TnNuB84OmhY2cBdwye3wGMz6NYSZJKi4gAArhzxvFjgeczc3NmTgEbgXOK\n", "xioMvszckZk/nnH4oKGpzWeAI3eneEmSSrgBuBrozTh+BPDs0Os5c2lPF7fMLECSpEpFxBXANzLz\n", "icGhouyZM5fmXNyyC1sjYr/MfAk4CthcdPHk5GSjNgMdGxuru4RpLrroorpL2GnVqlV1lzBN075W\n", "ao/Jycm6S2issbGxkTUsvV6v9N/3U1NTRXWdDxwbERcDRwPbIuLJzLyHfgYNd3hz5lKZ4JsALga+\n", "OPjv35UYQ5KkecnMy159HhF/DHx3EHpk5uMRcXBELKEfeBcAv1E0XmHwRcTJwM3AYcD2iHgfsAz4\n", "QkS8F3gc+MIe/HkkSQtEr7dX7n5NAUTElcCWzNwAvB/468G5L2XmI0UDFAZfZn4bePsuTp1bqlxJ\n", "0oK1N4IvM6/fxbH7gKXzHaPMVKckST9lL3V8e8zgkyRVYtGiduyCafBJkirRlo6vHfEsSVJF7Pgk\n", "SZVoS8dn8EmSKmHwSZI6xeCTJHWKwSdJ6pS2/DpDO6qUJKkidnySpEo41SlJ6hSDT5LUKQafJKlT\n", "DD5JUqe0Jfhc1SlJ6hQ7PklSJdrye3wGnySpEm2Z6jT4JEmVMPgkSZ1i8EmSOqUtwdeOO5GSJFXE\n", "jk+SVIlRdXwRcQDweeBwYD/g45l559D5o4EvAT8D/Etmrigaz45PklSJRYsWlX7M4VeBf87Ms4BL\n", "gTUzzt8IfCozTwFeGQThrOz4JEmVGFXHl5m3Db1cAjz56ouI6AGnAZcNrv29ucYz+CRJlRj14paI\n", "uB84Crhg6PBhwA+BmyLiROAfM/PDReM41SlJqkSv1yv9mI/MPBW4EPir4belH4afBs4Efikizius\n", "c2pqqtyfcP5G/ga7Y+3atXWXMM34+HjdJailxsbG6i5hJ3+uil1zzTV1l7DT+vXrR9aWLVmypPTf\n", "90888cSsdUXEO4BnMvPJwev/C5yZmc9FxD7Av2bm2wbnPgSQmTfMNp4dnySpEiPs+E4HrgaIiMOB\n", "gzLzOYDMfAV4LCLeNLj2HUAWDeY9PklSJUZ4j+/PgD+PiHuB/YGVEXElsCUzNwC/D3x+sNDlwcy8\n", "o2gwg0+SVIlR/esMmbkNuLzg/KP0u8J5MfgkSZVoy5ZlBp8kqRJtCT4Xt0iSOsWOT5JUibZ0fAaf\n", "JKkSBp8kqVNGtaqzagafJKkSdnySpE5pS/C1oy+VJKkidnySpEp4j0+S1Cltmeo0+CRJlbDjkyR1\n", "ih2fJKlT2hJ87ehLJUmqiB2fJKkS3uOTJHVKW6Y6DT5JUiXs+CRJnWLHJ0nqlLZ0fO2oUpKkitjx\n", "SZIqsaCnOiPiIOBW4HXAzwLXZ+amKguTJLXLqIIvIg4APg8cDuwHfDwz7xw6/07gk8B2IDNzedF4\n", "Zac63wM8nJlnA5cAnyk5jiRpgVi0aFHpxxx+FfjnzDwLuBRYM+P854CLM/N0YHFEvKtosLJTnc8A\n", "bx88PwR4tuQ4kqQFYlQdX2beNvRyCfDkjEtOysz/Gjx/Fji0aLxSwZeZfxMR74mIfwf+G/A/yowj\n", "SVo4Rr2qMyLuB44CLhg+/mroRcSRwK8Af1Q0Ttl7fJcDT2bm+RFxArAOOLnMWHvbihUr6i5hmsnJ\n", "ybpL2GliYqLuEqYZHx+vu4Rpmvb5aZKm/Vw1zfr16+suYUHIzFMj4heBvwJ+cfhcRPwc8LfA+zPz\n", "B0XjlI3nU4G/HxTyb8DREdGO5TySpJHo9XqlH0Ui4h0R8fMAmfmvwL4R8fqh8wcDG4EPZ+bdc9VZ\n", "NvgeAU4ZvOExwA8zc6rkWJKkBWBUwQecDlwNEBGHAwdl5nND59cAazLza/Ops+zils8BfxERXwf2\n", "AX635DiSpAVihPf4/gz484i4F9gfWBkRVwJbgE3AbwJviojfAaaAL2bmzbMNVnZxy4/oLymVJAkY\n", "6arObcDlBZccsDvjuXOLJKkS7tUpSVID2fFJkiqxoPfqlCRpJoNPktQpbbnHZ/BJkiphxydJ6pS2\n", "dHztqFKSpIrY8UmSKuFUpySpU9oy1WnwSZIqYccnSeoUg0+S1CltCb52TMhKklQROz5JUiXa0vEZ\n", "fJKkShh8kqROMfgkSZ1i8EmSOqUtweeqTklSp9jxSZIq4ZZlkqROGeVUZ0SsBk4D9gFWZebtQ+dW\n", "ApcD24EHMvPqorHaEc+SpMbr9XqlH0Ui4izg+MxcCpwH3DR0bjHwIeDUzDwDOD4ifrloPINPklSJ\n", "UQUfcC9wyeD5FuDAiHj1g14CtgGLI2Jf4ADgP4sGc6pTklSJUU11ZuYO4MXBy+XAxsycGpx7KSI+\n", "CjwK/D/gf2fmI0Xj2fFJklohIi4ErgI+MHTsYOA64C3AscCpEfG2onFG3vFNTk6O+i12y9jYWN0l\n", "NNb4+HjdJTTaihUr6i6hsZr2cz4xMVF3CdN05XtnxItblgHXAssyc+vQqeOARzPzB4Pr7gNOAh6a\n", "bSw7PklSJUa4uGUxsBq4IDNfmHH6e8BxEbHf4PVJQOFUp/f4JEmVGGHHdylwKHDbYFHLFHAP8GBm\n", "boiITwFfj4iXgW9m5n1Fgxl8kqRKjHBxyzpgXdnzMxl8kqRKuFenJEkNZMcnSapEWzo+g0+SVAmD\n", "T5LUKQafJKlTDD5JUqcYfJKkTmlL8PnrDJKkTrHjkyRVoi0dn8EnSaqEwSdJ6hSDT5LUKQafJKlT\n", "2hJ8ruqUJHWKHZ8kqRJt6fgMPklSJQw+SVKnGHySpE4x+CRJndKW4HNVpySpU+z4JEmVWLSoHb1U\n", "6eCLiMuBPwReBj6SmXdVVpUkqXVGOdUZEauB04B9gFWZefsurvkT4JTMfGfRWKXiOSIOAT4CLAUu\n", "AC4sM44kaeHo9XqlH0Ui4izg+MxcCpwH3LSLa44DTgem5qqzbMc3DnwtM18EXgTeV3IcSdICMcKO\n", "717g/wyebwEOjIheZg6H3A3AtcDH5hqsbPD9AnBQRGwAXgt8LDPvKTmWJGkBGFXwZeYO+k0WwHJg\n", "43DoRcSVwN3AE/MZr2zw9YBDgF8DjgX+ATim5FiSJM0pIi4ErgLOHTr2OuCKwbEl9POpUNngexr4\n", "5iBxH4uIrRHx+sx8buaFExMTJd9iNMbGxuouYZom1XPRRRfVXcI0q1atqruEadauXVt3CdOsWLGi\n", "7hJ2atL3cRM16XtnlN83I17csoz+VOayzNw6dOps4HDgPmB/4I0RcWNm/sFsY5UNvk3ALYNVNocA\n", "B+0q9CRJ3TGq4IuIxcBq4JzMfGH4XGZ+BfjK4LpjgFuKQg9KBl9mbo6ILwP/RH8FzQfKjCNJWjhG\n", "2PFdChwK3BYRPfq5cw/wYGZu2N3BSv8eX2auA9aV/XhJ0sIywsUt88qbzHyc/tRnIXdukSRVwr06\n", "JUlqIDs+SVIl2tLxGXySpEos+E2qJUkaZscnSeoUg0+S1CltCb52TMhKklQROz5JUiXa0vEZfJKk\n", "Shh8kqROMfgkSZ1i8EmSOqUtweeqTklSp9jxSZIq0ZaOz+CTJFXCvTolSZ1ixydJ6hSDT5LUKW0J\n", "vnZMyEqSVBE7PklSJdrS8Rl8kqRKGHySpE4ZZfBFxGrgNGAfYFVm3j50bhz4BLAduCszP140lvf4\n", "JEmV6PV6pR9FIuIs4PjMXAqcB9w045LPAO+mH4znRsRbi8Yz+CRJlRhV8AH3ApcMnm8BDoyIHkBE\n", "HAs8n5mbM3MK2AicUzSYU52SpEbLzB3Ai4OXy4GNg5ADOAJ4dujyZ4A3Fo038uBbsWLFqN+i1SYn\n", "J+suYafx8fG6S2i0iYmJukuYxq9Xe3TlazXqxS0RcSFwFXBuURlzjWPHJ0mqxCj36oyIZcC1wLLM\n", "3Dp0ajNw5NDrowbHZmXwSZIqMaqOLyIWA6uBczLzheFzmfl4RBwcEUvoB94FwG8UjWfwSZIqMcKp\n", "zkuBQ4HbBotapoB7gAczcwPwfuCvB8e/lJmPFA1m8EmSKjGq4MvMdcC6gvP3AUvnO56/ziBJ6hQ7\n", "PklSJfyHaCVJneJenZKkTjH4JEmdYvBJkjqlLcHXjjuRkiRVxI5PklQJV3VKkjqlLVOdBp8kqRIG\n", "nySpUww+SVKntOUeXzuqlCSpInZ8kqRKONUpSeoUg0+S1CkGnySpUww+SVKnuKpTkqQGsuOTJFXC\n", "qU5JUqcs+OCLiP2Bh4DrM/PW6kqSJLXRKIMvIk4A1gNrMnPtjHNHA18Cfgb4l8xcUTTWntzjuw54\n", "fg8+XpK0gCxatKj0o0hEHAjcCGya5ZIbgU9l5inAK4MgnFWpji8iAgjgzjIfL0laeEbY8W0Dzgeu\n", "nXkiInrAacBlAJn5e3MNVrbjuwG4GmjHhK4kqbUyc0dm/niW04cBPwRuioh/jIhPzjXebgdfRFwB\n", "fCMznxgcMvwkSfR6vdKPPXlb4Cjg08CZwC9FxHlFH1BmqvN84NiIuBg4GtgWEU9m5j27unjt2rW7\n", "OlybFSsK73nudWNjY3WX0FhN+9ysX7++7hKmmZycrLuEnZr2tWrS5waa9/kZlZpWdT4HfC8zvwcQ\n", "EXcDxwN3zfYBux18mXnZq88j4o+B784WepKk7thLwTftTTLzlYh4LCLelJmPAu8Avlg0gL/HJ0mq\n", "xKi2LIuIk4Gb6d/P2x4R7wVuAR7LzA3A7wOfHyx0eTAz7ygab4+CLzM/ticfL0laOEbV8WXmt4G3\n", "F5x/FDh9vuO5V6ckqVOc6pQkVWLBb1kmSdIwg0+S1Clt+ff4DD5JUiXa0vG1I54lSaqIwSdJ6hSn\n", "OiVJlWjLVKfBJ0mqhMEnSeoUg0+S1CkGnySpU9oSfK7qlCR1ih2fJKkSben4DD5JUiXaEnxOdUqS\n", "OsWOT5JUibZ0fAafJKkSbQk+pzolSZ1ixydJqkRbOj6DT5JUCYNPktQpBp8kqVNGGXwRcQKwHliT\n", "mWtnnHsn8ElgO5CZubxoLBe3SJIq0ev1Sj+KRMSBwI3Aplku+RxwcWaeDiyOiHcVjWfwSZKabhtw\n", "PvD0LOdPyszNg+fPAocWDWbwSZIaLTN3ZOaPC87/F0BEHAn8CrCxaDzv8UmSKlHn4paI+Dngb4H3\n", "Z+YPiq4defCNj4+P+i12y+TkZN0lNNbExETdJUxzzTXX1F3CNOvXr6+7hGnGxsbqLmGnpv1cNelz\n", "A3DRRRfVXcJOo/w+riv4IuJg+l3etZl591zX2/FJkiqxl4JvV2+yhv5qz6/NZwCDT5JUiVEFX0Sc\n", "DNwMHAZsj4j3ArcAj9Ff6fmbwJsi4neAKeCLmXnzbOMZfJKkRsvMbwNvL7jkgN0Zz+CTJFXCnVsk\n", "SZ1i8EmSOsXgkyR1SluCz51bJEmdYvBJkjrFqU5JUiXaMtVp8EmSKmHwSZI6xeCTJHWKwSdJ6pS2\n", "BJ+rOiVJnWLHJ0mqhB2fJEkNZMcnSapEWzo+g0+SVIm2BJ9TnZKkTjH4JEmd4lSnJKkSbZnqNPgk\n", "SZUw+CRJndKW4PMenySpU0p3fBGxGjgN2AdYlZm3V1aVJKl1RtnxRcQa4BRgB/DBzHxg6NxK4HJg\n", "O/BAZl5dNFapji8izgKOz8ylwHnATWXGkSRpLhFxBvDmQeYsBz47dG4x8CHg1Mw8Azg+In65aLyy\n", "U533ApcMnm8BDoyIdkzuSpJGotfrlX7M4RzgqwCZ+TDw2oh4zeDcS8A2YHFE7AscAPxn0WClgi8z\n", "d2Tmi4OXy4GNmTlVZixJkuZwBPDs0OvnBsfIzJeAjwKPAt8F7s/MR4oG26NVnRFxIXAVcO6ejLM3\n", "XXPNNXWXMM369evrLmGniYmJukuYZnx8vO4Splm7dm3dJUyzcuXKukvYKTPrLmGapn2tmvRzPkp7\n", "cVXnzjeKiIOB64C3AFuBeyLibZn50GwfvCeLW5YB1wLLMnNr2XEkSQvDCINvM4MOb+ANwFOD58cB\n", "j2bmDwAi4j7gJGDW4Cu7uGUxsBq4IDNfKDOGJGlhGeE9vk3ArwNExInA9zPzR4Nz3wOOi4j9Bq9P\n", "AkYy1XkpcChw22BRyxTwW5n5HyXHkyRplzLzWxHxnYi4H3gFWBkRVwJbMnNDRHwK+HpEvAx8MzPv\n", "KxqvVPBl5jpgXZmPlSRpd2Xmh2ccenDo3G5lkluWSZIq0ZYtyww+SVIlDD5JUqe0JfjcpFqS1CkG\n", "nySpU5zqlCRVoi1TnQafJKkSbQk+pzolSZ1ixydJqkRbOj6DT5JUibYEn1OdkqROseOTJFXCjk+S\n", "pAay45MkVaItHZ/BJ0mqRFuCz6lOSVKnGHySpE5xqlOSVIm2THUafJKkSrQl+JzqlCR1ih2fJKkS\n", "ben4DD5JUuNFxBrgFGAH8MHMfGAX1/wJcEpmvrNoLKc6JUmNFhFnAG/OzKXAcuCzu7jmOOB0YGqu\n", "8Qw+SVIler1e6ccczgG+CpCZDwOvjYjXzLjmBuDa+dRp8EmSmu4I4Nmh188NjgEQEVcCdwNPzGcw\n", "7/FJkiqxFxe37HyjiHgdcAVwLrBk+NxsRh58Y2Njo36L3bJq1aq6S5hmcnKy7hJ2Gh8fr7uEaSYm\n", "JuouYZqm1TM1NeetjL2mSd/HWpA2M9ThAW8Anho8Pxs4HLgP2B94Y0TcmJl/MNtgdnySpEqMsOPb\n", "BHwUWBcRJwLfz8wfAWTmV4CvAETEMcAtRaEH3uOTJDVcZn4L+E5E3A/cBKyMiCsj4sIy49nxSZIa\n", "LzM/POPQg7u45nH6U5+FDD5JUiXasnOLU52SpE6x45MkVcKOT5KkBjL4JEmd4lSnJKkSTnVKktRA\n", "Bp8kqVOc6pQkVcKpTkmSGsjgkyR1ilOdkqRKONUpSVID2fFJkiphxydJUgPZ8UmSKmHHJ0lSAxl8\n", "kqROcapTklQJpzolSWogOz5JUiXs+CRJaqBSHV9ErAFOAXYAH8zMByqtSpKkIUW5ExHjwCeA7cBd\n", "mfnxorF2u+OLiDOAN2fmUmA58NndHUOStPD0er3SjyLzyJ3PAO8GTgPOjYi3Fo1XZqrzHOCrAJn5\n", "MPDaiHhNiXEkSZqPWXMnIo4Fns/MzZk5BWwcXD+rMsF3BPDs0OvnBsckSR02qo6P4tyZee4Z4Mii\n", "wapY3NKOZTySpIWiKHfmzKQyi1s2M73DewPw1J4UsTeNjY3VXYLmqWlfqxUrVtRdQmM17WvVtHo6\n", "ZFR/3xflzmamd3hHDY7NqkzHtwn4dYCIOBH4fmb+qMQ4kiTNx6y5k5mPAwdHxJKI2Be4YHD9rHpT\n", "U1O7XUFEfBI4E3gFWJmZD+72IJIkzdPM3AFOBLZk5oaIOA1YDUwBX87MTxeNVSr4JElqK3dukSR1\n", "isEnSeoUg0+S1Ckj/dcZ3NNzdhGxmv72OvsAqzLz9ppLapyI2B94CLg+M2+tu56miIjLgT8EXgY+\n", "kpl31VxSY0TEQcCtwOuAn6X/vVO4wm+hi4gTgPXAmsxcGxFHA39Jv/F5CrgiM1+us8a9bWQdn3t6\n", "zi4izgKOH3xuzgNuqreixroOeL7uIpokIg4BPgIspb9s+8J6K2qc9wAPZ+bZwCX093DsrIg4ELiR\n", "6cv7rwf+NDPPBB4FfruO2uo0yqlO9/Sc3b30fygBtgAHRkSjftG/bhERQAB31l1Lw4wDX8vMFzPz\n", "6cx8X90FNcwzwKGD54cwfSurLtoGnA88PXTsLOCOwfM76H9Pdcoog889PWeRmTsy88XBy+XAxsHm\n", "qvqJG4CradjOPw3wC8BBEbEhIr4REWfXXVCTZObfAD8fEf8O/AP976HOGvxd8+MZhw8amtqcc1/L\n", "hWhvLm7xL7AZIuJC4CrgA3XX0iQRcQXwjcx8YnDI752f6NHvZH6N/vfOLfWW0yyD+59PZuZb6Hcy\n", "/6vmkpqukz9bowy+3d3Ts1MiYhlwLfCuzNxadz0Ncz5wSUR8i35H/Ed2Njs9DXwzM6cy8zFga0S8\n", "vu6iGuRU4O8BMvPfgKO9jfBTtkbEfoPnc+5ruRCNMvjc03MWEbGY/vY6F2TmC3XX0zSZeVlmnpyZ\n", "/x24GfifmXlP3XU1xCbg7IjoRcSh9Ketnqu7qAZ5hP5KciLiGOCH3kb4KRPAxYPnFwN/V2MttRjZ\n", "rzNk5rci4jsRcT8/2VtNfZfSvwF/2+D/RqeA38rM/6i3LDVdZm6OiC8D/0T/+8Zp8uk+B/xFRHyd\n", "/q8K/W695dQrIk6m/z+PhwHbI+J9wDLgCxHxXuBx4As1llgL9+qUJHWKO7dIkjrF4JMkdYrBJ0nq\n", "FINPktQpBp8kqVMMPklSpxh8kqROMfgkSZ3y/wHlLdp10r0P+wAAAABJRU5ErkJggg==\n" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# First, we'll wrap our experiments above in a method that takes as input our grid parameters.\n", "def gaussian_initial_grid(grid_size=10, num_cells=100, spread=4):\n", " \"\"\"\n", " Create an initial 2D grid with Gaussian/normal-distributed cells with wrapping.\n", " \"\"\"\n", " # Create the space and activate random cells\n", " space = numpy.zeros((grid_size, grid_size))\n", "\n", " # Now sample the agents.\n", " for cell_id in range(num_cells):\n", " # Sample random position\n", " row = int(numpy.random.normal((grid_size) / 2.0, spread)) % grid_size\n", " col = int(numpy.random.normal((grid_size) / 2.0, spread)) % grid_size\n", "\n", " # \"Activate\" the cell by setting its value to 1.\n", " space[row, col] += 1\n", "\n", " # Now show the space\n", " f = plt.figure()\n", " plt.pcolor(space, snap=True)\n", " plt.colorbar()\n", "\n", "# Import widget methods\n", "from IPython.html.widgets import interact, fixed\n", "\n", "interact(gaussian_initial_grid, grid_size=(5, 100),\n", " num_cells = (1, 500),\n", " spread=(1, 100))" ] } ], "metadata": { "kernelspec": { "display_name": "IPython (Python 2)", "name": "python2" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 2 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython2", "version": "2.7.3" }, "signature": "sha256:4c6c9c278b9d19d5417f5c0a8d1b7aea73583e55559d5e1549c8d7bebe86d7b0" }, "nbformat": 4, "nbformat_minor": 0 }