Session_16_Traders_trade_part_4.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/edgeofchaos42/ComplexityExplorer/blob/main/Session_16_Traders_trade_part_4.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 1- Review lesson 15 and intro\n",
        "\n",
        "Script Notes: \n",
        "\n",
        "In lesson 15 we built the process to ensure the trade was worth it for each agent through an incremental sale process of one unit until one of two crtieria either worse off or the MRS crossing was met. Now tat we have seen this work we need to actually make the sale.     \n",
        "\n",
        "*Review each class and model set up*"
      ],
      "metadata": {
        "id": "1WxZVj47O4g0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CCWF0WnCu1_3",
        "outputId": "ce954c04-75c1-421c-a049-703634c877a0"
      },
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/drive\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "try: \n",
        "  import mesa\n",
        "except: \n",
        "  !pip install mesa --quiet\n",
        "  import mesa\n",
        "import numpy as np\n",
        "import math\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "\n",
        "\n",
        "%matplotlib inline "
      ],
      "metadata": {
        "id": "R-uRKmZUxS2S",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8e2892c4-89f6-4ff3-d868-4898b7cd5ef8"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\u001b[K     |████████████████████████████████| 2.5 MB 8.8 MB/s \n",
            "\u001b[K     |████████████████████████████████| 66 kB 4.3 MB/s \n",
            "\u001b[?25h"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def get_distance(pos_1, pos_2):\n",
        "    \"\"\"Calculate Euclidean distance between two positions.\n",
        "    Args:\n",
        "        pos_1, pos_2: Coordinate tuples for both points.\n",
        "    \n",
        "    used in trader.move()\n",
        "    \"\"\"\n",
        "    x1, y1 = pos_1\n",
        "    x2, y2 = pos_2\n",
        "    dx = x1 - x2\n",
        "    dy = y1 - y2\n",
        "    return math.sqrt(dx**2 + dy**2)"
      ],
      "metadata": {
        "id": "BVOrDIhE4EFe"
      },
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class Sugar(mesa.Agent):\n",
        "    \"\"\"\n",
        "    Sugar is a FSM that\n",
        "    - contains an amount of sugar\n",
        "    - grows 1 amount of sugar at each turn (rule G1).\n",
        "    \"\"\"\n",
        "    \n",
        "    \n",
        "    def __init__(self, unique_id, model, pos, max_sugar): \n",
        "      super().__init__(unique_id, model) #part 3\n",
        "      self.pos = pos\n",
        "      self.amount = max_sugar\n",
        "      self.max_sugar = max_sugar\n",
        "\n",
        "    def step(self): \n",
        "      self.amount = min([self.max_sugar,self.amount+1])\n",
        "      \n",
        "      "
      ],
      "metadata": {
        "id": "qLn3pp5X1Cp2"
      },
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class Spice(mesa.Agent):\n",
        "    \"\"\"\n",
        "    Spice is a FSM that\n",
        "    - contains an amount of spice\n",
        "    - grows 1 amount of spice at each turn. (rule G1)\n",
        "    \"\"\"\n",
        "\n",
        "    def __init__(self, unique_id, model, pos, max_spice): \n",
        "        super().__init__(unique_id, model) \n",
        "        self.pos = pos\n",
        "        self.amount = max_spice\n",
        "        self.max_spice = max_spice\n",
        "\n",
        "    def step(self): #Part 1\n",
        "      self.amount = min([self.max_spice,self.amount+1])\n",
        "       "
      ],
      "metadata": {
        "id": "vWcWMp2My8tJ"
      },
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Add Trade \n",
        "\n",
        "**Part 1**\n",
        "\n",
        "------------\n",
        "\n",
        "We are going to to go our maybe sell spice function and now add another function of actually sell_spice. In this case we will pass three parameters\n",
        "the other agent object, the int for the amount of spice to be exchanged and the int for the amount of sugar to be exchanged. \n",
        "\n",
        "Then we merely just increase one agents spice and decrease another agents spice and then do the same wih the sugar, we now return True from the maybe sell spice function to the Trade. \n",
        "\n",
        "Whhhewww that was a complicated process it took us 4 parts. TO emphasize what we did is we started with a trade and walked through what happenes all the way down to the invidiaul trade, but we actually have not finished our main functions.  \n",
        "\n",
        "So now when go back to our trade function we capture the one variation of which agent mrs is greater and capture the results.\n",
        "\n",
        "If no false were returned then the function contninues but if we get a false we need to end the function. \n",
        "\n",
        "**Part 2**\n",
        "\n",
        "------------\n",
        "\n",
        "Now we leverage the object oriented programming we discussed. if the MRS of our potential trading partner is less than our then we have them call the function. This reduces overall code and complex decision trees. \n",
        "\n",
        "**Part 3**\n",
        "\n",
        "------------\n",
        "\n",
        "Now we want to collect key information in the trade, first we want to collect the price, which remember is incremental, and we want to know who we are trading with. But we never built that as an attribute of our agent...too easy, we can just add it now. However, we don't want to add them every time, because the trade is incremental, so we only add the trading partner if the partner is not already in the list, no we reset the agent's list and as you will see later use the datacollector to collect this information. And since the trade is incremental we call the trade function again until we return when a criteria is not met.\n",
        "\n",
        "\n",
        "So now we go to our trade with neighbbors function and capture these results and return them to the mian function. \n",
        "\n",
        "So now we can go back to main model class to caputre the results\n"
      ],
      "metadata": {
        "id": "9Mxm0q6pAxUq"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Trader(mesa.Agent):\n",
        "    \"\"\"\n",
        "    TraderAgent is a \n",
        "    - has a metabolism for sugar and spice\n",
        "    - harvest and trades sugar and spice to survive and thrive\n",
        "    \"\"\"\n",
        "\n",
        "    def __init__(self, unique_id, model,pos,moore=False, sugar=0, \n",
        "                 spice=0, metabolism_sugar=0, metabolism_spice=0,\n",
        "                 vision=0): \n",
        "      super().__init__(unique_id, model)\n",
        "      self.pos = pos \n",
        "      self.moore = False \n",
        "      self.sugar = sugar \n",
        "      self.spice = spice \n",
        "      self.metabolism_sugar=metabolism_sugar \n",
        "      self.metabolism_spice=metabolism_spice \n",
        "      self.vision = vision \n",
        "      self.prices = []\n",
        "      self.trade_partners = []\n",
        "\n",
        "  \n",
        "    def get_sugar(self, pos): #part 2\n",
        "      '''\n",
        "      used in:\n",
        "         get_sugar_amount()\n",
        "         eat()\n",
        "\n",
        "      '''\n",
        "      this_cell = self.model.grid.get_cell_list_contents(pos)\n",
        "      for agent in this_cell:\n",
        "          if type(agent) is Sugar:\n",
        "              return agent\n",
        "      return None\n",
        "    \n",
        "    \n",
        "    def get_sugar_amount(self, pos):\n",
        "      '''\n",
        "      used in move()\n",
        "      '''\n",
        "      \n",
        "      sugar_patch = self.get_sugar(pos)\n",
        "      if sugar_patch:\n",
        "          return sugar_patch.amount\n",
        "      return 0\n",
        "    \n",
        "    \n",
        "    def get_spice(self, pos):\n",
        "      '''\n",
        "      used in get_spice_amount\n",
        "      '''\n",
        "      this_cell = self.model.grid.get_cell_list_contents(pos)\n",
        "      for agent in this_cell:\n",
        "          if type(agent) is Spice:\n",
        "              return agent\n",
        "      return None\n",
        "        \n",
        "    \n",
        "    def get_spice_amount(self, pos):\n",
        "        '''\n",
        "        used in move()\n",
        "        '''\n",
        "        spice_patch = self.get_spice(pos)\n",
        "        if spice_patch: \n",
        "          return spice_patch.amount\n",
        "        return 0\n",
        "  \n",
        "    def get_trader(self, pos):\n",
        "      '''\n",
        "      used in trade_with neighbors()\n",
        "      '''\n",
        "      this_cell =self.model.grid.get_cell_list_contents(pos)\n",
        "\n",
        "      for agent in this_cell: \n",
        "        if isinstance(agent, Trader):\n",
        "          return agent\n",
        "    \n",
        "    \n",
        "    def is_occupied(self, pos): \n",
        "      '''\n",
        "      Helper function for move()\n",
        "      '''\n",
        "      \n",
        "      this_cell = self.model.grid.get_cell_list_contents(pos)\n",
        "      for a in this_cell:\n",
        "          if isinstance(a, Trader) and a.pos != self.pos:\n",
        "              return True\n",
        "      return False\n",
        "       \n",
        "    def calculate_welfare(self, sugar, spice): #This will be built to be like the example later with none, but right now it wouldn't make any sense\n",
        "      '''\n",
        "      Helper function for:\n",
        "      move()\n",
        "      trade()\n",
        "\n",
        "      '''\n",
        "\n",
        "      #calculate total resources\n",
        "      m_total = self.metabolism_sugar + self.metabolism_spice\n",
        "      #Cobb-Douglas functional form\n",
        "      return sugar** (self.metabolism_sugar/m_total) * spice ** (\n",
        "          self.metabolism_spice/m_total)\n",
        "      \n",
        "    def is_starved(self): \n",
        "      '''\n",
        "      helper function for maybe_die()\n",
        "      '''\n",
        "\n",
        "      return (self.sugar <= 0) or (self.spice <=0)\n",
        "\n",
        "    def calculate_MRS(self): \n",
        "      '''\n",
        "      used in trade()\n",
        "      '''\n",
        "\n",
        "      return (self.spice/self.metabolism_spice) / (self.sugar/self.metabolism_sugar)\n",
        "    \n",
        "    def calculate_sell_spice_amount(self, price):\n",
        "      '''\n",
        "      Helper function for maybe_sell_spice() which is called from trade()\n",
        "      '''\n",
        "      if price >= 1:\n",
        "          sugar = 1\n",
        "          spice = int(price)\n",
        "      else:\n",
        "          sugar = int(1 / price)\n",
        "          spice = 1\n",
        "      return sugar, spice\n",
        "\n",
        "    def sell_spice(self, other, sugar, spice):\n",
        "      '''\n",
        "      used in maybe_sell_spice\n",
        "      :param: Agent object\n",
        "      :param: int sugar to be exchanged\n",
        "      :param: int spice to be exchanged\n",
        "      '''\n",
        "\n",
        "      self.sugar += sugar\n",
        "      other.sugar -= sugar\n",
        "      self.spice -= spice\n",
        "      other.spice += spice\n",
        "  \n",
        "    \n",
        "    def maybe_sell_spice(self, other, price, welfare_self, welfare_other):\n",
        "      '''\n",
        "      helper function for trade()\n",
        "      '''\n",
        "      sugar_exchanged, spice_exchanged = self.calculate_sell_spice_amount(price)\n",
        "\n",
        "      # Preparing the new sugar spice amount -- what if the exchange were to occur.\n",
        "      self_sugar = self.sugar + sugar_exchanged\n",
        "      other_sugar = other.sugar - sugar_exchanged\n",
        "      self_spice = self.spice - spice_exchanged\n",
        "      other_spice = other.spice + spice_exchanged\n",
        "\n",
        "      #Double Check to see if agents have resources\n",
        "\n",
        "      if (\n",
        "          (self_sugar <=0)\n",
        "       or (other_sugar <= 0)\n",
        "       or (self_spice <= 0)\n",
        "       or (other_spice <= 0)):\n",
        "        return False\n",
        "\n",
        "      #trade crtieria 1 are both agents better off?\n",
        "      both_agents_better_off = (\n",
        "          welfare_self < self.calculate_welfare(self_sugar, self_spice) and \n",
        "          (welfare_other < other.calculate_welfare(other_sugar, other_spice)))\n",
        "      \n",
        "      #trade criteria 2 is their mrs crossing\n",
        "      mrs_not_crossing = self.calculate_MRS() > other.calculate_MRS()\n",
        "\n",
        "      if not (both_agents_better_off and mrs_not_crossing):\n",
        "            return False\n",
        "\n",
        "      #add sell spice\n",
        "      self.sell_spice(other, sugar_exchanged, spice_exchanged)\n",
        "\n",
        "      return True\n",
        "       \n",
        "\n",
        "    \n",
        "    def trade(self, other):\n",
        "      '''\n",
        "      used in trade_with_neighbors()\n",
        "      '''\n",
        "      #Part 0\n",
        "      #sanity check to verify code is working the way we think\n",
        "      assert self.sugar > 0\n",
        "      assert self.spice > 0\n",
        "      assert other.sugar > 0 \n",
        "      assert other.spice > 0 \n",
        "\n",
        "      mrs_self = self.calculate_MRS()\n",
        "      mrs_other = other.calculate_MRS()\n",
        "      #part 1: \n",
        "      welfare_self = self.calculate_welfare(self.sugar, self.spice)\n",
        "      welfare_other = other.calculate_welfare(other.sugar, other.spice)\n",
        "\n",
        "      if math.isclose(mrs_self, mrs_other, rel_tol=1e-2): \n",
        "        return \n",
        "\n",
        "      price = math.sqrt(mrs_self*mrs_other)\n",
        "\n",
        "      if mrs_self > mrs_other: \n",
        "        #self is a sugar buyer\n",
        "        sold = self.maybe_sell_spice(other, price, welfare_self, welfare_other)\n",
        "        #part 2\n",
        "        if not sold: \n",
        "          return\n",
        "      else: \n",
        "        #self is a spice buyer\n",
        "        sold = other.maybe_sell_spice(self, price, welfare_other, welfare_self)\n",
        "        if not sold: \n",
        "          return\n",
        "      \n",
        "      #part 3\n",
        "      self.prices.append(price)\n",
        "      if other.unique_id not in self.trade_partners: \n",
        "        self.trade_partners.append(other.unique_id)\n",
        "\n",
        "      #continue trading\n",
        "      self.trade(other)\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "    ###########################################################################\n",
        "    #                                                                         #\n",
        "    #                            MAIN FUNCTIONS                               #\n",
        "    #                                                                         #\n",
        "    ###########################################################################\n",
        "\n",
        "    def move(self): \n",
        "           \n",
        "      # 1. Get neighbors within vision\n",
        "\n",
        "      neighbors = [i \n",
        "                   for i in self.model.grid.get_neighborhood(\n",
        "                       self.pos, self.moore,True, self.vision\n",
        "                       )\n",
        "                   if not self.is_occupied(i)\n",
        "      ]\n",
        "\n",
        "      # 2. Find the patch which produce the maximum welfare. \n",
        "\n",
        "      welfares = [\n",
        "            self.calculate_welfare(\n",
        "                self.sugar + self.get_sugar_amount(pos),\n",
        "                self.spice + self.get_spice_amount(pos),\n",
        "            )\n",
        "            for pos in neighbors] #part 2\n",
        "\n",
        "      #find the highest welfare in the cell \n",
        "      max_welfare = max(welfares)\n",
        "      #get the index of maximal welfare cells\n",
        "      candidate_indices = [i for i in range(len(welfares))\n",
        "                             if math.isclose(welfares[i], max_welfare,\n",
        "                                             rel_tol=1e-02)]\n",
        "      #convert index to positions of those cells\n",
        "      candidates = [neighbors[i] for i in candidate_indices]\n",
        "     \n",
        "      \n",
        "      # 3. Find the nearest patch among the candidate.\n",
        "      min_dist = min([get_distance(self.pos, pos) for pos in candidates])\n",
        "      final_candidates = [pos for pos in candidates if math.isclose(get_distance(self.pos, pos),\n",
        "                                                                   min_dist, rel_tol=1e-02)]\n",
        "      self.random.shuffle(final_candidates)\n",
        "\n",
        "      # 4. Move agent.\n",
        "      self.model.grid.move_agent(self, final_candidates[0])\n",
        "\n",
        "\n",
        "\n",
        "    def eat(self):\n",
        "      #get sugar\n",
        "      sugar_patch = self.get_sugar(self.pos)\n",
        "\n",
        "      if sugar_patch:\n",
        "        self.sugar = self.sugar - self.metabolism_sugar + sugar_patch.amount\n",
        "        sugar_patch.amount = 0\n",
        "        #print(self.sugar, sugar_patch.amount)\n",
        "      \n",
        "      #get_spice part 2\n",
        "      spice_patch = self.get_spice(self.pos)\n",
        "      #print(spice_patch)\n",
        "      if spice_patch: \n",
        "        self.spice = self.spice - self.metabolism_spice + spice_patch.amount\n",
        "        spice_patch.amount = 0\n",
        "        #print(self.spice, spice_patch.amount)\n",
        "\n",
        "    def maybe_die(self): \n",
        "\n",
        "      if self.is_starved(): \n",
        "        self.model.grid.remove_agent(self) \n",
        "        self.model.schedule.remove(self)\n",
        "          \n",
        "    def trade_with_neighbors(self):\n",
        "      \n",
        "      neighbor_agents =[self.get_trader(pos) for pos in self.model.grid.get_neighborhood(\n",
        "          self.pos, self.moore, False, radius=self.vision) if self.is_occupied(pos)]\n",
        "        \n",
        "      if len(neighbor_agents) == 0:\n",
        "            #part 4\n",
        "            return [], []\n",
        "      \n",
        "      for a in neighbor_agents: \n",
        "        if a: \n",
        "          self.trade(a)\n",
        "      #\n",
        "      prices = [p for p in self.prices if p ]\n",
        "      trader_partners = [t for t in self.trade_partners if t]\n",
        "      self.prices = []\n",
        "      self.trade_partners = []\n",
        "      print(prices, trader_partners)\n",
        "      return prices, trader_partners"
      ],
      "metadata": {
        "id": "89x-JNt-zQmK"
      },
      "execution_count": 18,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Add Trade \n",
        "\n",
        "**Part 4**\n",
        "\n",
        "------------\n",
        "So we want to add our trade with partners we decided we needed and then we run and uh-oh\n",
        "\n",
        "As you can see when we try to run this we get a value error, expected to unpack to 2 but got zero... so let's look at the traceback. We go to the trade with neighbors function ---its clearly coming from our trade_with_neighbors function so let's take look. we have two returns in our trade with neighbor function and if we have no trader agents to trade with we return only one empty list so we can add one and then add a print statement to make sure we are getting what we think we should get and viola it seems to be working. \n",
        "\n",
        "So we have reached a milestone, it seems we have a population of agents  "
      ],
      "metadata": {
        "id": "7G6PP33Gdk5N"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class SugarscapeG1mt(mesa.Model):\n",
        "\n",
        "  def __init__(self, width=50, height=50, initial_population=100,\n",
        "               endowment_min =25, endowment_max =50, metabolism_min = 1,\n",
        "                 metabolism_max = 5, vision_min = 1, vision_max =5): \n",
        "    \n",
        "    self.width = width\n",
        "    self.height = height\n",
        "    self.initial_population =initial_population \n",
        "    self.endowment_min = endowment_min \n",
        "    self.endowment_max = endowment_max \n",
        "    self.metabolism_min = metabolism_min\n",
        "    self.metabolism_max = metabolism_max\n",
        "    self.vision_min = vision_min\n",
        "    self.vision_max = vision_max\n",
        "\n",
        "\n",
        "    self.schedule = mesa.time.RandomActivationByType(self)\n",
        "    self.grid = mesa.space.MultiGrid(self.width, self.height, torus=True)\n",
        "\n",
        "    sugar_distribution = np.genfromtxt(\"/content/drive/MyDrive/sugar-map.txt\") \n",
        "    spice_distribution = spice = np.flip(sugar_distribution,1)\n",
        "    \n",
        "    #ensure unique id\n",
        "    agent_id = 0\n",
        "    for _, x, y in self.grid.coord_iter(): \n",
        "      max_sugar = sugar_distribution[x,y]\n",
        "      if max_sugar > 0: \n",
        "        sugar = Sugar(agent_id, self, (x,y),max_sugar)\n",
        "        self.grid.place_agent(sugar, (x, y))\n",
        "        #Place Agent\n",
        "        self.schedule.add(sugar) \n",
        "        agent_id += 1\n",
        "\n",
        "      max_spice = spice_distribution[x,y]\n",
        "      if max_spice > 0: \n",
        "        spice = Spice(agent_id, self, (x,y), max_spice)\n",
        "        self.grid.place_agent(spice,(x,y))\n",
        "        self.schedule.add(spice)\n",
        "        agent_id += 1\n",
        "         \n",
        "    \n",
        "    for i in range(self.initial_population):\n",
        "      #get agent position\n",
        "      x = self.random.randrange(self.width) \n",
        "      y = self.random.randrange(self.height) \n",
        "      # See GAS page 108 for parameters initialization.\n",
        "      # Each agent is endowed by a random amount of sugar and spice\n",
        "      sugar = self.random.uniform(self.endowment_min, self.endowment_max+1) \n",
        "      spice = self.random.uniform(self.endowment_min, self.endowment_max+1) \n",
        "      #add metabolism also on page #108\n",
        "      metabolism_sugar = self.random.uniform(self.metabolism_min, self.metabolism_max)\n",
        "      metabolism_spice = self.random.uniform(self.metabolism_min, self.metabolism_max)\n",
        "      #add vision\n",
        "      vision =int(self.random.uniform(self.vision_min, self.vision_max))\n",
        "      trader = Trader(\n",
        "                agent_id,\n",
        "                self,\n",
        "                (x, y),\n",
        "                False,\n",
        "                sugar,\n",
        "                spice,\n",
        "                metabolism_sugar,\n",
        "                metabolism_spice,\n",
        "                vision,\n",
        "            )\n",
        "      self.grid.place_agent(trader, (x, y))\n",
        "      self.schedule.add(trader)\n",
        "      agent_id += 1\n",
        "\n",
        "  \n",
        "  def randomize_traders(self): \n",
        "    \"\"\"\n",
        "    Helper function for step()\n",
        "\n",
        "    updates list of agents used in step function\n",
        "    \"\"\"\n",
        "    \n",
        "    Traders = self.schedule.agents_by_type[Trader].values()\n",
        "    Trader_shuffle = list(Traders)\n",
        "    self.random.shuffle(Trader_shuffle)\n",
        "\n",
        "    return Trader_shuffle\n",
        "  \n",
        "  \n",
        "  def step(self): \n",
        "    \n",
        "    for sugar in self.schedule.agents_by_type[Sugar].values(): \n",
        "      sugar.step()\n",
        "    \n",
        "    for spice in self.schedule.agents_by_type[Spice].values(): \n",
        "      spice.step()\n",
        "        \n",
        "    Trader_shuffle = self.randomize_traders()\n",
        "    \n",
        "    for agent in Trader_shuffle: \n",
        "      agent.move() \n",
        "      agent.eat() \n",
        "      agent.maybe_die() \n",
        "\n",
        "    Trader_shuffle = self.randomize_traders()\n",
        "    \n",
        "    #part 4\n",
        "    for agent in Trader_shuffle: \n",
        "      #agent.trade_with_neighbors()\n",
        "      agent.prices, agent.trade_partners = agent.trade_with_neighbors()\n",
        "    \n",
        "\n",
        "    self.schedule.time +=1\n",
        "    self.schedule.steps += 1\n",
        "    \n",
        "\n",
        "  \n",
        "  def run_model(self, step_count=1000):\n",
        "    \n",
        "    for i in range(step_count):\n",
        "      self.step()\n",
        "      \n",
        "\n",
        "    #self.schedule.step()_\n",
        "\n",
        "        "
      ],
      "metadata": {
        "id": "V3yTkyWz0Pi9"
      },
      "execution_count": 21,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Model Run \n"
      ],
      "metadata": {
        "id": "kYXO-SNTPnC-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "model = SugarscapeG1mt()\n",
        "model.run_model(step_count=10) \n",
        "\n"
      ],
      "metadata": {
        "id": "wbZ1-r5q1fe1"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}