{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "8979120e",
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "from matplotlib.patches import PathPatch\n",
    "from matplotlib.path import Path\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import random\n",
    "\n",
    "# This class creates a 8x8 board with a temperature field,\n",
    "# normalized to have values roughly of the order of -5 to +5,\n",
    "# changing over time due to the motion of heat sources which have\n",
    "# a short-ranged influence on the temperature.\n",
    "#\n",
    "# An agent is moving over the board; the aim of the agent is to avoid extreme\n",
    "# temperature zones in order to stay alive. (For that, see the Agent class below.)\n",
    "#\n",
    "class Surroundings:\n",
    "    grid_size = 8  # 8x8 grid like a chessboard\n",
    "    radius_of_sight = 2  # the agent can see two fields in each direction\n",
    "    \n",
    "    _num_heat_sources = 8  # how many heat sources there are on the board\n",
    "    _v_square_per_source = 0.25  # mean square velocity of the heat sources\n",
    "    \n",
    "    _base_temperature = -5    # temperature in the absence of a heat source\n",
    "    _influence_radius =  2.5  # radius within which an influence of the heat source is perceived\n",
    "    _temperature_scale = 2.5  # maximum temperature increase due to a single heat source\n",
    "    \n",
    "    \n",
    "    def __init__(self):\n",
    "        self._debug_output = False\n",
    "        self._temperature = np.zeros((Surroundings.grid_size, Surroundings.grid_size))\n",
    "        acceptable_starting_configuration = False\n",
    "        while not acceptable_starting_configuration:\n",
    "            self._heat_source_position = [(random.uniform(0, Surroundings.grid_size), \\\n",
    "                                           random.uniform(0, Surroundings.grid_size)) \\\n",
    "                                          for i in range(Surroundings._num_heat_sources)]\n",
    "            self._compute_temperature()\n",
    "            self._agent_position = [random.randrange(1, Surroundings.grid_size - 1), \\\n",
    "                                    random.randrange(1, Surroundings.grid_size - 1)]\n",
    "            T_start = self._temperature[self._agent_position[0], self._agent_position[1]]\n",
    "            if T_start > -0.2* Surroundings._temperature_scale \\\n",
    "            and T_start < 0.2* Surroundings._temperature_scale:\n",
    "                acceptable_starting_configuration = True\n",
    "        self._heat_source_velocity = [(0, 0) for i in range(Surroundings._num_heat_sources)]\n",
    "        for i in range(Surroundings._num_heat_sources):\n",
    "            vi0 = random.uniform(0, Surroundings._v_square_per_source)**0.5\n",
    "            if random.randrange(2) == 1:\n",
    "                vi0 = -vi0\n",
    "            vi1 = random.uniform(0, Surroundings._v_square_per_source)**0.5\n",
    "            if random.randrange(2) == 1:\n",
    "                vi1 = -vi1\n",
    "            self._heat_source_velocity[i] = (vi0, vi1)\n",
    "    \n",
    "    def _compute_temperature(self):\n",
    "        for x0 in range(Surroundings.grid_size):\n",
    "            for x1 in range(Surroundings.grid_size):\n",
    "                self._temperature[x0, x1] = Surroundings._base_temperature\n",
    "                for (q0, q1) in self._heat_source_position:\n",
    "                    distance = ((x0 - q0)**2 + (x1 - q1)**2)**0.5  # distance to heat source\n",
    "                    if distance < Surroundings._influence_radius:  # add temperature contribution\n",
    "                        self._temperature[x0][x1] += Surroundings._temperature_scale \\\n",
    "                        * (Surroundings._influence_radius - distance)\n",
    "    \n",
    "    def _move_heat_sources(self):\n",
    "        for i in range(Surroundings._num_heat_sources):\n",
    "            (qi0, qi1) = self._heat_source_position[i]\n",
    "            (vi0, vi1) = self._heat_source_velocity[i]\n",
    "            qi0 += vi0\n",
    "            if qi0 < 0:  # hard-wall boundary condition in x0 direction\n",
    "                qi0 = -qi0\n",
    "                vi0 = -vi0\n",
    "            if qi0 > Surroundings.grid_size:\n",
    "                qi0 = 2*Surroundings.grid_size - qi0\n",
    "                vi0 = -vi0\n",
    "            qi1 += vi1\n",
    "            if qi1 < 0:  # hard-wall boundary condition in x1 direction\n",
    "                qi1 = -qi1\n",
    "                vi1 = -vi1\n",
    "            if qi1 > Surroundings.grid_size:\n",
    "                qi1 = 2*Surroundings.grid_size - qi1\n",
    "                vi1 = -vi1\n",
    "            self._heat_source_position[i] = (qi0, qi1)\n",
    "            self._heat_source_velocity[i] = (vi0, vi1)\n",
    "        self._compute_temperature()\n",
    "        if self._debug_output:\n",
    "            print(\"Agent at:\", self._agent_position, end=\"\\t\\t\")\n",
    "            print(\"Local temperature:\", \\\n",
    "                  round(self._temperature[self._agent_position[0], self._agent_position[1]], 2))\n",
    "    \n",
    "    def activate_debug_output(self):\n",
    "        self._debug_output = True\n",
    "    \n",
    "    def visualize(self):\n",
    "        fig, ax = plt.subplots()\n",
    "        fig.set_size_inches(7, 7)\n",
    "        plt.xticks(fontsize=18, color=\"#322300\")\n",
    "        plt.yticks(fontsize=18, color=\"#322300\")\n",
    "        ax.set_xlabel(\"coordinate x1\", fontsize=24, color=\"#322300\")\n",
    "        ax.set_ylabel(\"coordinate x0\", fontsize=24, color=\"#322300\")\n",
    "        im = plt.imshow(self._temperature, extent=[-0.5, Surroundings.grid_size-0.5, \\\n",
    "                                              Surroundings.grid_size-0.5, -0.5])\n",
    "        cb = plt.colorbar()\n",
    "        q0 = self._agent_position[0]\n",
    "        q1 = self._agent_position[1]\n",
    "        path = Path([[q1, q0+0.5], [q1+0.5, q0], [q1, q0-0.5], [q1-0.5, q0], [q1, q0+0.5]])\n",
    "        patch = PathPatch(path, facecolor='#ff0000')\n",
    "        ax.add_patch(patch)\n",
    "    \n",
    "    def perceive_local_temperature(self):\n",
    "        return self._temperature[self._agent_position[0], self._agent_position[1]]\n",
    "    \n",
    "    # returns a percept list consisting of the temperature value\n",
    "    # 0) at the position with x0 increased by one, and 1) with x0 increased by 2\n",
    "    #\n",
    "    # if we are at the edge of the board, infinity is returned as the temperature value\n",
    "    #\n",
    "    def perceive_temperature_x0_higher(self):\n",
    "        percept = []\n",
    "        for i in range(Surroundings.radius_of_sight):\n",
    "            q0 = self._agent_position[0] + i + 1\n",
    "            q1 = self._agent_position[1]\n",
    "            if q0 < Surroundings.grid_size:\n",
    "                percept.append(self._temperature[q0, q1])\n",
    "            else:\n",
    "                percept.append(math.inf)\n",
    "        return percept\n",
    "    \n",
    "    # returns a percept list consisting of the temperature value\n",
    "    # 0) at the position with x0 decreased by one, and 1) with x0 decreased by 2\n",
    "    #\n",
    "    # if we are at the edge of the board, infinity is returned as the temperature value\n",
    "    #\n",
    "    def perceive_temperature_x0_lower(self):\n",
    "        percept = []\n",
    "        for i in range(Surroundings.radius_of_sight):\n",
    "            q0 = self._agent_position[0] - i - 1\n",
    "            q1 = self._agent_position[1]\n",
    "            if q0 >= 0:\n",
    "                percept.append(self._temperature[q0, q1])\n",
    "            else:\n",
    "                percept.append(math.inf)\n",
    "        return percept\n",
    "    \n",
    "    # returns a percept list consisting of the temperature value\n",
    "    # 0) at the position with x1 increased by one, and 1) with x1 increased by 2\n",
    "    #\n",
    "    # if we are at the edge of the board, infinity is returned as the temperature value\n",
    "    #\n",
    "    def perceive_temperature_x1_higher(self):\n",
    "        percept = []\n",
    "        for i in range(Surroundings.radius_of_sight):\n",
    "            q0 = self._agent_position[0]\n",
    "            q1 = self._agent_position[1] + i + 1\n",
    "            if q1 < Surroundings.grid_size:\n",
    "                percept.append(self._temperature[q0, q1])\n",
    "            else:\n",
    "                percept.append(math.inf)\n",
    "        return percept\n",
    "    \n",
    "    # returns a percept list consisting of the temperature value\n",
    "    # 0) the position with x1 decreased by one, and 1) with x1 decreased by 2\n",
    "    #\n",
    "    # if we are at the edge of the board, infinity is returned as the temperature value\n",
    "    #\n",
    "    def perceive_temperature_x1_lower(self):\n",
    "        percept = []\n",
    "        for i in range(Surroundings.radius_of_sight):\n",
    "            q0 = self._agent_position[0]\n",
    "            q1 = self._agent_position[1] - i - 1\n",
    "            if q1 >= 0:\n",
    "                percept.append(self._temperature[q0, q1])\n",
    "            else:\n",
    "                percept.append(math.inf)\n",
    "        return percept\n",
    "    \n",
    "    # agent decides to increase x0 by one\n",
    "    #\n",
    "    def action_increment_x0(self):\n",
    "        if self._agent_position[0] < Surroundings.grid_size - 1:\n",
    "            self._agent_position[0] += 1\n",
    "        else:\n",
    "            print(\"\\tWarning: action_increment_x0 at\", self._agent_position, \"failed due to wall\")\n",
    "        self._move_heat_sources()\n",
    "    \n",
    "    # agent decides to decrease x0 by one\n",
    "    #\n",
    "    def action_decrement_x0(self):\n",
    "        if self._agent_position[0] > 0:\n",
    "            self._agent_position[0] -= 1\n",
    "        else:\n",
    "            print(\"\\tWarning: action_decrement_x0 at\", self._agent_position, \"failed due to wall\")\n",
    "        self._move_heat_sources()\n",
    "    \n",
    "    # agent decides to increase x1 by one\n",
    "    #\n",
    "    def action_increment_x1(self):\n",
    "        if self._agent_position[1] < Surroundings.grid_size - 1:\n",
    "            self._agent_position[1] += 1\n",
    "        else:\n",
    "            print(\"\\tWarning: action_increment_x1 at\", self._agent_position, \"failed due to wall\")\n",
    "        self._move_heat_sources()\n",
    "    \n",
    "    # agent decides to decrease x1 by one\n",
    "    #\n",
    "    def action_decrement_x1(self):\n",
    "        if self._agent_position[1] > 0:\n",
    "            self._agent_position[1] -= 1\n",
    "        else:\n",
    "            print(\"\\tWarning: action_decrement_x1 at\", self._agent_position, \"failed due to wall\")\n",
    "        self._move_heat_sources()\n",
    "    \n",
    "    # agent decides to sit around and do nothing\n",
    "    #\n",
    "    def action_wait(self):\n",
    "        self._move_heat_sources()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "d4a9db14",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x504 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x504 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import time\n",
    "\n",
    "landscape = Surroundings()\n",
    "landscape.visualize()\n",
    "for i in range(1):\n",
    "    landscape._move_heat_sources()\n",
    "landscape.visualize()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "f5cc57d1",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Agent:\n",
    "    temperature_tolerance = 4  # if temperature is outside the range from -4 to +4, the agent dies\n",
    "    \n",
    "    def __init__(self, landscape):\n",
    "        self._alive = True\n",
    "        self._environment = landscape\n",
    "        self._timestep = 0\n",
    "    \n",
    "    # gather percepts\n",
    "    #\n",
    "    def sensor_input(self):\n",
    "        self._local_temperature = self._environment.perceive_local_temperature()\n",
    "        self._percept_x0_higher = self._environment.perceive_temperature_x0_higher()\n",
    "        self._percept_x0_lower = self._environment.perceive_temperature_x0_lower()\n",
    "        self._percept_x1_higher = self._environment.perceive_temperature_x1_higher()\n",
    "        self._percept_x1_lower = self._environment.perceive_temperature_x1_lower()\n",
    "        \n",
    "        # check whether the agent dies due to extreme temperature\n",
    "        #\n",
    "        if abs(self._local_temperature) > Agent.temperature_tolerance:\n",
    "            self._alive = False\n",
    "\n",
    "    \n",
    "    # keep gathering percepts and calling the agent function until, eventually, the agent dies\n",
    "    #\n",
    "    # the function returns the number of timesteps that it takes until the agent dies\n",
    "    #\n",
    "    def live_original(self):\n",
    "        self.sensor_input()\n",
    "        while self._alive:\n",
    "            self._timestep += 1\n",
    "            self.agent_function_original()\n",
    "            self.sensor_input()\n",
    "        return self._timestep\n",
    "    \n",
    "    ## Tauheed A. Mir, Jamie Pickering, Jamie Liddiard\n",
    "    def live_tauheed_mir_et_al(self):\n",
    "        self.sensor_input()\n",
    "        while self._alive:\n",
    "            self._timestep += 1\n",
    "            self.agent_function_tauheed_mir_et_al()\n",
    "            self.sensor_input()\n",
    "        return self._timestep\n",
    "    \n",
    "    def live_justyna_kwiatkowska(self):\n",
    "        self.sensor_input()\n",
    "        while self._alive:\n",
    "            self._timestep += 1\n",
    "            self.agent_function_justyna_kwiatkowska()\n",
    "            self.sensor_input()\n",
    "        return self._timestep\n",
    "    \n",
    "    def live_katib_hussain(self):\n",
    "        self.sensor_input()\n",
    "        while self._alive:\n",
    "            self._timestep += 1\n",
    "            self.agent_function_katib_hussain()\n",
    "            self.sensor_input()\n",
    "        return self._timestep\n",
    "    \n",
    "    def live_justyna_kwiatkowska_edited(self):\n",
    "        self.sensor_input()\n",
    "        while self._alive:\n",
    "            self._timestep += 1\n",
    "            self.agent_function_justyna_kwiatkowska_edited()\n",
    "            self.sensor_input()\n",
    "        return self._timestep\n",
    "    \n",
    "    def live_biased(self, bias):\n",
    "        self.sensor_input()\n",
    "        while self._alive:\n",
    "            self._timestep += 1\n",
    "            self.agent_function_biased(bias)\n",
    "            self.sensor_input()\n",
    "        return self._timestep\n",
    "    \n",
    "    \n",
    "    # original agent function\n",
    "    #\n",
    "    # average life time: 18.3 steps\n",
    "    #\n",
    "    def agent_function_original(self):\n",
    "        \n",
    "        # look for a direction that decreases abs(temperature) and walk there\n",
    "        #\n",
    "        # we are using the percept for the temperature two fields away in each direction,\n",
    "        # e.g., _percept_x0_higher[1] corresponds to the field with x0 increased by 2\n",
    "        #\n",
    "        if abs(self._percept_x0_higher[1]) < abs(self._local_temperature):\n",
    "            self._environment.action_increment_x0()\n",
    "        elif abs(self._percept_x0_lower[1]) < abs(self._local_temperature):\n",
    "            self._environment.action_decrement_x0()\n",
    "        elif abs(self._percept_x1_higher[1]) < abs(self._local_temperature):\n",
    "            self._environment.action_increment_x1()\n",
    "        elif abs(self._percept_x1_lower[1]) < abs(self._local_temperature):\n",
    "            self._environment.action_decrement_x1()\n",
    "        else:\n",
    "            self._environment.action_wait()\n",
    "\n",
    "            \n",
    "    # Tauheed A. Mir, Jamie Pickering, Jamie Liddiard\n",
    "    #\n",
    "    # average life time: 26.6 steps\n",
    "    #\n",
    "    def agent_function_tauheed_mir_et_al(self):\n",
    "        \n",
    "        # Collect known percepts as easy to type values\n",
    "        currentSelectedTemp = abs(self._local_temperature)\n",
    "        yPlus2 = self._percept_x1_higher[1]\n",
    "        yPlus1 = self._percept_x1_higher[0]\n",
    "        yMinus1 = self._percept_x1_lower[0]\n",
    "        yMinus2 = self._percept_x1_lower[1]\n",
    "        xPlus2 = self._percept_x0_higher[1]\n",
    "        xPlus1 = self._percept_x0_higher[0]\n",
    "        xMinus1 = self._percept_x0_lower[0]\n",
    "        xMinus2 = self._percept_x0_lower[1]\n",
    "        \n",
    "        # 5x5 grid of percept values centered on AI\n",
    "        tempGrid = [[    -10,     -10,             yMinus2,    -10,    -10], \n",
    "                    [    -10,     -10,             yMinus1,    -10,    -10], \n",
    "                    [xMinus2, xMinus1, currentSelectedTemp, xPlus1, xPlus2], \n",
    "                    [    -10,     -10,              yPlus1,    -10,    -10], \n",
    "                    [    -10,     -10,              yPlus2,    -10,    -10]]\n",
    "        \n",
    "        # Out of bounds checks\n",
    "        # Positive Y\n",
    "        if (math.isinf(yPlus1)):\n",
    "            for i in range (5):\n",
    "                tempGrid[4][i] = math.inf\n",
    "                tempGrid[3][i] = math.inf\n",
    "        elif (math.isinf(yPlus2)):\n",
    "            for i in range (5):\n",
    "                tempGrid[4][i] = math.inf\n",
    "        # Negative Y\n",
    "        if (math.isinf(yMinus1)):\n",
    "            for i in range (5):\n",
    "                tempGrid[0][i] = math.inf\n",
    "                tempGrid[1][i] = math.inf\n",
    "        elif (math.isinf(yMinus2)):\n",
    "            for i in range (5):\n",
    "                tempGrid[0][i] = math.inf\n",
    "        # Positive X\n",
    "        if (math.isinf(xPlus1)):\n",
    "            for i in range (5):\n",
    "                tempGrid[i][4] = math.inf\n",
    "                tempGrid[i][3] = math.inf\n",
    "        elif (math.isinf(xPlus2)):\n",
    "            for i in range (5):\n",
    "                tempGrid[i][4] = math.inf\n",
    "        # Negative X\n",
    "        if (math.isinf(xMinus1)):\n",
    "            for i in range (5):\n",
    "                tempGrid[i][0] = math.inf\n",
    "                tempGrid[i][1] = math.inf\n",
    "        elif (math.isinf(xMinus2)):\n",
    "            for i in range (5):\n",
    "                tempGrid[i][0] = math.inf\n",
    "    \n",
    "        # Guesses on squares with neighbours from known percepts            \n",
    "        def FindAverage(tx, ty):\n",
    "            count = 0\n",
    "            total = 0\n",
    "            if (math.isfinite(tempGrid[tx][ty])):\n",
    "                for i in range (-1, 2, 1):\n",
    "                    if ((tx + i) >= 0 and (tx + i) <= 4):\n",
    "                        for j in range (-1, 2, 1):\n",
    "                            if ((ty + j) >= 0 and (ty + j) <= 4):\n",
    "                                if (tempGrid[tx+i][ty+j] != -10 and math.isfinite(tempGrid[tx+i][ty+j])):\n",
    "                                    count += 1\n",
    "                                    total += tempGrid[tx+i][ty+j]\n",
    "            if (count != 0):\n",
    "                tempGrid[tx][ty] = total/count\n",
    "                \n",
    "        # compute estimates for the 16 fields from tempGrid with unknown temperatures\n",
    "        #\n",
    "        # in that matrix, \"2\" is the present coordinate\n",
    "        #\n",
    "        FindAverage(1,1)\n",
    "        FindAverage(3,1)\n",
    "        FindAverage(1,3)\n",
    "        FindAverage(3,3)\n",
    "        \n",
    "        FindAverage(1,0)\n",
    "        FindAverage(0,1)\n",
    "        FindAverage(0,3)\n",
    "        FindAverage(1,4)\n",
    "        FindAverage(3,4)\n",
    "        FindAverage(4,3)\n",
    "        FindAverage(4,1)\n",
    "        FindAverage(3,0)\n",
    "        \n",
    "        FindAverage(0,0)\n",
    "        FindAverage(4,0)\n",
    "        FindAverage(0,4)\n",
    "        FindAverage(4,4)\n",
    "        \n",
    "        # So now we get to do some logic to determine movement direction\n",
    "        averageList = [0, 0, 0, 0, currentSelectedTemp]\n",
    "        upAverage     = abs((tempGrid[0][0] + tempGrid[0][1] \\\n",
    "                             + tempGrid[0][2] + tempGrid[0][3] \\\n",
    "                             + tempGrid[0][4] + tempGrid[1][1] \\\n",
    "                             + tempGrid[2][1] + tempGrid[3][1]) / 8)\n",
    "        downAverage   = abs((tempGrid[4][0] + tempGrid[4][1] \\\n",
    "                             + tempGrid[4][2] + tempGrid[4][3] \\\n",
    "                             + tempGrid[4][4] + tempGrid[3][1] \\\n",
    "                             + tempGrid[3][2] + tempGrid[3][3]) / 8)\n",
    "        leftAverage   = abs((tempGrid[0][0] + tempGrid[1][0] + tempGrid[2][0] + tempGrid[3][0] + tempGrid[4][0] + tempGrid[1][1] + tempGrid[1][2] + tempGrid[1][3]) / 8)\n",
    "        rightAverage  = abs((tempGrid[0][4] + tempGrid[1][4] + tempGrid[2][4] + tempGrid[3][4] + tempGrid[4][4] + tempGrid[1][3] + tempGrid[2][3] + tempGrid[3][3]) / 8)\n",
    "        averageList[0] = upAverage\n",
    "        averageList[1] = downAverage\n",
    "        averageList[2] = leftAverage\n",
    "        averageList[3] = rightAverage\n",
    "        averageList.sort()\n",
    "\n",
    "        if (averageList[0] == upAverage):\n",
    "            self._environment.action_decrement_x1()\n",
    "        if (averageList[0] == downAverage):\n",
    "            self._environment.action_increment_x1()\n",
    "        if (averageList[0] == leftAverage):\n",
    "            self._environment.action_decrement_x0()\n",
    "        if (averageList[0] == rightAverage):\n",
    "            self._environment.action_increment_x0()\n",
    "        if (averageList[0] == currentSelectedTemp):\n",
    "            self._environment.action_wait()\n",
    "\n",
    "\n",
    "    # average life time: 47.8 steps\n",
    "    #\n",
    "    def agent_function_justyna_kwiatkowska(self):\n",
    "        \n",
    "        # Consider the temperature of both tiles in each direction\n",
    "        x0h = abs(self._percept_x0_higher[0]) + abs(self._percept_x0_higher[1])\n",
    "        x0l = abs(self._percept_x0_lower[0]) + abs(self._percept_x0_lower[1])\n",
    "        x1h = abs(self._percept_x1_higher[0]) + abs(self._percept_x1_higher[1])\n",
    "        x1l = abs(self._percept_x1_lower[0]) + abs(self._percept_x1_lower[1])\n",
    "        current = abs(self._local_temperature) * 2\n",
    "        \n",
    "        # Look for the direction with the lowest abs(temperature) and go there\n",
    "        lowest = min(x0h, x0l, x1h, x1l, current)\n",
    "        \n",
    "        if (lowest == x0h):\n",
    "            self._environment.action_increment_x0()\n",
    "        elif (lowest == x0l):\n",
    "            self._environment.action_decrement_x0()\n",
    "        elif (lowest == x1h):\n",
    "            self._environment.action_increment_x1()\n",
    "        elif (lowest == x1l):\n",
    "            self._environment.action_decrement_x1()\n",
    "        else:\n",
    "            self._environment.action_wait()\n",
    "\n",
    "    \n",
    "    # average life time: 52.3 steps\n",
    "    #\n",
    "    def agent_function_katib_hussain(self):\n",
    "        if abs(self._percept_x0_higher[0]) < abs(self._local_temperature):\n",
    "            self._environment.action_increment_x0()\n",
    "        elif abs(self._percept_x0_higher[1]) < abs(self._local_temperature) and \\\n",
    "        abs(self._percept_x0_higher[1]) < abs(self._percept_x0_higher[0]):\n",
    "            self._environment.action_increment_x0()\n",
    "            self._environment.action_increment_x0()\n",
    "        elif abs(self._percept_x0_lower[0]) < abs(self._local_temperature):\n",
    "            self._environment.action_decrement_x0()\n",
    "        elif abs(self._percept_x0_lower[1]) < abs(self._local_temperature) and \\\n",
    "        abs(self._percept_x0_lower[1]) < abs(self._percept_x0_lower[0]):\n",
    "            self._environment.action_decrement_x0()\n",
    "            self._environment.action_decrement_x0()\n",
    "        elif abs(self._percept_x1_higher[0]) < abs(self._local_temperature):\n",
    "            self._environment.action_increment_x1()\n",
    "        elif abs(self._percept_x1_higher[1]) < abs(self._local_temperature) and \\\n",
    "        abs(self._percept_x1_higher[1]) < abs(self._percept_x1_lower[0]):\n",
    "            self._environment.action_increment_x1()\n",
    "            self._environment.action_increment_x1()\n",
    "        elif abs(self._percept_x1_lower[0]) < abs(self._local_temperature):\n",
    "            self._environment.action_decrement_x1()\n",
    "        elif abs(self._percept_x1_lower[1]) < abs(self._local_temperature) and \\\n",
    "        abs(self._percept_x1_lower[1]) < abs(self._percept_x1_lower[0]):\n",
    "            self._environment.action_decrement_x1()\n",
    "            self._environment.action_decrement_x1()\n",
    "        else:\n",
    "            self._environment.action_wait()\n",
    "\n",
    "\n",
    "    # like Justyna's function, but simplified:\n",
    "    # We completely ignore the second fields (index [1])\n",
    "    # and focus completely on the immediately adjacent fields (index [0])\n",
    "    #\n",
    "    # average life time: 133.6 steps\n",
    "    #\n",
    "    def agent_function_justyna_kwiatkowska_edited(self):\n",
    "        \n",
    "        x0h = abs(self._percept_x0_higher[0])\n",
    "        x0l = abs(self._percept_x0_lower[0])\n",
    "        x1h = abs(self._percept_x1_higher[0])\n",
    "        x1l = abs(self._percept_x1_lower[0])\n",
    "        current = abs(self._local_temperature)\n",
    "        \n",
    "        # Look for the direction with the lowest abs(temperature) and go there\n",
    "        lowest = min(x0h, x0l, x1h, x1l, current)\n",
    "        \n",
    "        if (lowest == x0h):\n",
    "            self._environment.action_increment_x0()\n",
    "        elif (lowest == x0l):\n",
    "            self._environment.action_decrement_x0()\n",
    "        elif (lowest == x1h):\n",
    "            self._environment.action_increment_x1()\n",
    "        elif (lowest == x1l):\n",
    "            self._environment.action_decrement_x1()\n",
    "        else:\n",
    "            self._environment.action_wait()\n",
    "    \n",
    "    \n",
    "    # Justyna's function, with the simplification above,\n",
    "    # but extended by a bias; now we use abs(T - bias) instead of abs(T)\n",
    "    #\n",
    "    # for bias = -1/3 this leads to an average life time of 146.0 steps\n",
    "    #\n",
    "    def agent_function_biased(self, bias):\n",
    "        \n",
    "        x0h = abs(self._percept_x0_higher[0] - bias)\n",
    "        x0l = abs(self._percept_x0_lower[0] - bias)\n",
    "        x1h = abs(self._percept_x1_higher[0] - bias)\n",
    "        x1l = abs(self._percept_x1_lower[0] - bias)\n",
    "        current = abs(self._local_temperature - bias)\n",
    "        \n",
    "        # Look for the direction with the lowest abs(temperature - bias) and go there\n",
    "        lowest = min(x0h, x0l, x1h, x1l, current)\n",
    "        \n",
    "        if (lowest == x0h):\n",
    "            self._environment.action_increment_x0()\n",
    "        elif (lowest == x0l):\n",
    "            self._environment.action_decrement_x0()\n",
    "        elif (lowest == x1h):\n",
    "            self._environment.action_increment_x1()\n",
    "        elif (lowest == x1l):\n",
    "            self._environment.action_decrement_x1()\n",
    "        else:\n",
    "            self._environment.action_wait()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "bea35d8f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Agent at: [5, 6]\t\tLocal temperature: 1.8\n",
      "Agent at: [4, 6]\t\tLocal temperature: 2.03\n",
      "Agent at: [5, 6]\t\tLocal temperature: 1.81\n",
      "Agent at: [4, 6]\t\tLocal temperature: 0.29\n",
      "Agent at: [4, 6]\t\tLocal temperature: 0.09\n",
      "Agent at: [4, 6]\t\tLocal temperature: 0.34\n",
      "Agent at: [4, 6]\t\tLocal temperature: 0.59\n",
      "Agent at: [5, 6]\t\tLocal temperature: 2.01\n",
      "Agent at: [4, 6]\t\tLocal temperature: 2.49\n",
      "Agent at: [5, 6]\t\tLocal temperature: 0.04\n",
      "Agent at: [5, 6]\t\tLocal temperature: -1.66\n",
      "Agent at: [5, 6]\t\tLocal temperature: -2.79\n",
      "Agent at: [6, 6]\t\tLocal temperature: -2.32\n",
      "Agent at: [5, 6]\t\tLocal temperature: -3.16\n",
      "Agent at: [6, 6]\t\tLocal temperature: -0.09\n",
      "Agent at: [6, 6]\t\tLocal temperature: 0.75\n",
      "Agent at: [6, 6]\t\tLocal temperature: 0.09\n",
      "Agent at: [6, 6]\t\tLocal temperature: -1.0\n",
      "Agent at: [6, 6]\t\tLocal temperature: -2.13\n",
      "Agent at: [5, 6]\t\tLocal temperature: -1.64\n",
      "Agent at: [5, 6]\t\tLocal temperature: -2.71\n",
      "Agent at: [4, 6]\t\tLocal temperature: -2.95\n",
      "Agent at: [3, 6]\t\tLocal temperature: -1.22\n",
      "Agent at: [3, 6]\t\tLocal temperature: -0.68\n",
      "Agent at: [3, 6]\t\tLocal temperature: -0.16\n",
      "Agent at: [3, 6]\t\tLocal temperature: 0.96\n",
      "Agent at: [3, 6]\t\tLocal temperature: 2.52\n",
      "Agent at: [2, 6]\t\tLocal temperature: 2.94\n",
      "Agent at: [3, 6]\t\tLocal temperature: 4.6\n",
      "\n",
      "****\n",
      "The agent died after 29 steps\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x504 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x504 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "landscape = Surroundings()\n",
    "landscape.activate_debug_output()\n",
    "landscape.visualize()\n",
    "\n",
    "agent = Agent(landscape)\n",
    "time = agent.live_original()\n",
    "print(\"\\n****\\nThe agent died after\", time, \"steps\")\n",
    "\n",
    "landscape.visualize()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "4fe2a05c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\t6\t6.0\n",
      "100\t19\t19.228\n",
      "200\t25\t18.289\n",
      "300\t14\t18.628\n",
      "400\t18\t18.908\n",
      "500\t43\t18.729\n",
      "600\t7\t18.541\n",
      "700\t15\t18.465\n",
      "800\t10\t18.557\n",
      "900\t83\t18.541\n",
      "1000\t27\t18.273\n",
      "1100\t5\t18.215\n",
      "1200\t16\t18.439\n",
      "1300\t18\t18.336\n",
      "1400\t6\t18.275\n",
      "1500\t26\t18.185\n",
      "1600\t6\t18.066\n",
      "1700\t22\t18.049\n",
      "1800\t7\t18.052\n",
      "1900\t8\t18.12\n",
      "2000\t40\t18.065\n",
      "2100\t14\t18.212\n",
      "2200\t50\t18.129\n",
      "2300\t13\t18.173\n",
      "2400\t9\t18.176\n",
      "2500\t7\t18.242\n",
      "2600\t15\t18.302\n",
      "2700\t10\t18.348\n",
      "2800\t19\t18.34\n",
      "2900\t13\t18.387\n",
      "3000\t18\t18.373\n",
      "3100\t7\t18.325\n",
      "3200\t19\t18.358\n",
      "3300\t22\t18.371\n",
      "3400\t25\t18.338\n",
      "3500\t8\t18.256\n",
      "3600\t12\t18.251\n",
      "3700\t28\t18.313\n",
      "3800\t11\t18.329\n",
      "3900\t28\t18.309\n",
      "4000\t4\t18.328\n",
      "4100\t18\t18.359\n",
      "4200\t16\t18.394\n",
      "4300\t27\t18.384\n",
      "4400\t54\t18.419\n",
      "4500\t25\t18.361\n",
      "4600\t12\t18.456\n",
      "4700\t5\t18.445\n",
      "4800\t28\t18.379\n",
      "4900\t17\t18.356\n",
      "****\n",
      "Average life: 18.333 steps\n"
     ]
    }
   ],
   "source": [
    "repetitions = 5000\n",
    "\n",
    "total_life = 0\n",
    "for i in range(repetitions):\n",
    "    landscape = Surroundings()\n",
    "    agent = Agent(landscape)\n",
    "    this_life = agent.live_original()\n",
    "    total_life += this_life\n",
    "    if i%100 == 0:\n",
    "        print(i, this_life, round(total_life/(i+1), 3), sep=\"\\t\")\n",
    "\n",
    "print(\"****\\nAverage life:\", round(total_life/repetitions, 3), \"steps\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "1f75f8c9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\t73\t73.0\n",
      "100\t3\t28.099\n",
      "200\t4\t27.697\n",
      "300\t12\t27.442\n",
      "400\t3\t28.362\n",
      "500\t10\t28.479\n",
      "600\t7\t28.106\n",
      "700\t15\t27.285\n",
      "800\t4\t26.963\n",
      "900\t5\t27.198\n",
      "1000\t47\t27.144\n",
      "1100\t56\t27.062\n",
      "1200\t31\t27.171\n",
      "1300\t17\t27.179\n",
      "1400\t50\t26.935\n",
      "1500\t24\t26.85\n",
      "1600\t3\t26.681\n",
      "1700\t28\t26.735\n",
      "1800\t13\t26.716\n",
      "1900\t5\t26.858\n",
      "2000\t7\t26.764\n",
      "2100\t38\t26.576\n",
      "2200\t5\t26.506\n",
      "2300\t8\t26.266\n",
      "2400\t21\t26.294\n",
      "2500\t28\t26.363\n",
      "2600\t9\t26.376\n",
      "2700\t3\t26.307\n",
      "2800\t4\t26.393\n",
      "2900\t13\t26.399\n",
      "3000\t94\t26.416\n",
      "3100\t58\t26.376\n",
      "3200\t2\t26.325\n",
      "3300\t7\t26.223\n",
      "3400\t48\t26.104\n",
      "3500\t4\t26.142\n",
      "3600\t8\t26.121\n",
      "3700\t38\t26.193\n",
      "3800\t110\t26.225\n",
      "3900\t58\t26.148\n",
      "4000\t22\t26.041\n",
      "4100\t48\t26.013\n",
      "4200\t36\t26.114\n",
      "4300\t40\t26.137\n",
      "4400\t6\t26.155\n",
      "4500\t3\t26.028\n",
      "4600\t35\t25.968\n",
      "4700\t8\t25.964\n",
      "4800\t59\t25.979\n",
      "4900\t17\t25.987\n",
      "****\n",
      "Average life: 25.98 steps\n"
     ]
    }
   ],
   "source": [
    "repetitions = 5000\n",
    "\n",
    "total_life = 0\n",
    "for i in range(repetitions):\n",
    "    landscape = Surroundings()\n",
    "    agent = Agent(landscape)\n",
    "    this_life = agent.live_tauheed_mir_et_al()\n",
    "    total_life += this_life\n",
    "    if i%100 == 0:\n",
    "        print(i, this_life, round(total_life/(i+1), 3), sep=\"\\t\")\n",
    "\n",
    "print(\"****\\nAverage life:\", round(total_life/repetitions, 3), \"steps\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "fed5c048",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\t2\t2.0\n",
      "100\t119\t49.188\n",
      "200\t21\t46.279\n",
      "300\t48\t48.538\n",
      "400\t53\t49.975\n",
      "500\t19\t49.19\n",
      "600\t32\t48.175\n",
      "700\t33\t47.959\n",
      "800\t81\t49.17\n",
      "900\t64\t49.036\n",
      "1000\t195\t50.067\n",
      "1100\t245\t50.507\n",
      "1200\t5\t50.349\n",
      "1300\t75\t49.686\n",
      "1400\t87\t49.458\n",
      "1500\t15\t49.475\n",
      "1600\t189\t49.6\n",
      "1700\t113\t49.698\n",
      "1800\t49\t49.934\n",
      "1900\t73\t49.378\n",
      "2000\t25\t49.239\n",
      "2100\t63\t49.442\n",
      "2200\t37\t49.701\n",
      "2300\t45\t49.366\n",
      "2400\t30\t49.442\n",
      "2500\t22\t49.38\n",
      "2600\t65\t49.213\n",
      "2700\t3\t49.137\n",
      "2800\t168\t49.285\n",
      "2900\t32\t49.33\n",
      "3000\t46\t48.932\n",
      "3100\t33\t48.732\n",
      "3200\t109\t48.374\n",
      "3300\t135\t48.272\n",
      "3400\t27\t48.245\n",
      "3500\t37\t48.304\n",
      "3600\t239\t48.192\n",
      "3700\t23\t48.14\n",
      "3800\t64\t48.142\n",
      "3900\t143\t47.993\n",
      "4000\t85\t47.894\n",
      "4100\t14\t48.002\n",
      "4200\t90\t48.056\n",
      "4300\t29\t47.934\n",
      "4400\t75\t47.834\n",
      "4500\t51\t47.912\n",
      "4600\t47\t47.934\n",
      "4700\t7\t48.016\n",
      "4800\t31\t47.882\n",
      "4900\t22\t47.734\n",
      "****\n",
      "Average life: 47.765 steps\n"
     ]
    }
   ],
   "source": [
    "repetitions = 5000\n",
    "\n",
    "total_life = 0\n",
    "for i in range(repetitions):\n",
    "    landscape = Surroundings()\n",
    "    agent = Agent(landscape)\n",
    "    this_life = agent.live_justyna_kwiatkowska()\n",
    "    total_life += this_life\n",
    "    if i%100 == 0:\n",
    "        print(i, this_life, round(total_life/(i+1), 3), sep=\"\\t\")\n",
    "\n",
    "print(\"****\\nAverage life:\", round(total_life/repetitions, 3), \"steps\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "eb26f404",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\t59\t59.0\n",
      "100\t57\t47.337\n",
      "200\t3\t51.692\n",
      "300\t82\t52.266\n",
      "400\t77\t52.918\n",
      "500\t27\t53.339\n",
      "600\t6\t53.363\n",
      "700\t22\t53.05\n",
      "800\t82\t52.675\n",
      "900\t14\t52.635\n",
      "1000\t37\t52.479\n",
      "1100\t34\t52.539\n",
      "1200\t6\t52.873\n",
      "1300\t76\t52.728\n",
      "1400\t9\t52.35\n",
      "1500\t165\t52.898\n",
      "1600\t39\t52.563\n",
      "1700\t11\t52.143\n",
      "1800\t6\t51.47\n",
      "1900\t12\t51.638\n",
      "2000\t120\t51.337\n",
      "2100\t202\t51.423\n",
      "2200\t167\t51.713\n",
      "2300\t6\t51.847\n",
      "2400\t97\t52.302\n",
      "2500\t73\t51.889\n",
      "2600\t83\t51.738\n",
      "2700\t45\t51.415\n",
      "2800\t54\t51.54\n",
      "2900\t73\t51.643\n",
      "3000\t77\t51.825\n",
      "3100\t6\t51.809\n",
      "3200\t91\t51.635\n",
      "3300\t15\t51.575\n",
      "3400\t90\t51.555\n",
      "3500\t29\t51.383\n",
      "3600\t25\t51.32\n",
      "3700\t8\t51.357\n",
      "3800\t128\t51.565\n",
      "3900\t163\t51.551\n",
      "4000\t26\t51.615\n",
      "4100\t53\t51.629\n",
      "4200\t13\t51.857\n",
      "4300\t42\t52.06\n",
      "4400\t129\t51.929\n",
      "4500\t22\t51.899\n",
      "4600\t13\t51.924\n",
      "4700\t177\t51.908\n",
      "4800\t23\t52.109\n",
      "4900\t86\t52.338\n",
      "****\n",
      "Average life: 52.288 steps\n"
     ]
    }
   ],
   "source": [
    "repetitions = 5000\n",
    "\n",
    "total_life = 0\n",
    "for i in range(repetitions):\n",
    "    landscape = Surroundings()\n",
    "    agent = Agent(landscape)\n",
    "    this_life = agent.live_katib_hussain()\n",
    "    total_life += this_life\n",
    "    if i%100 == 0:\n",
    "        print(i, this_life, round(total_life/(i+1), 3), sep=\"\\t\")\n",
    "\n",
    "print(\"****\\nAverage life:\", round(total_life/repetitions, 3), \"steps\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "5510b66e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\t134\t134.0\n",
      "100\t48\t145.277\n",
      "200\t255\t147.557\n",
      "300\t110\t136.528\n",
      "400\t29\t134.771\n",
      "500\t50\t133.519\n",
      "600\t17\t129.454\n",
      "700\t107\t128.499\n",
      "800\t25\t131.055\n",
      "900\t205\t130.083\n",
      "1000\t4\t132.301\n",
      "1100\t335\t132.433\n",
      "1200\t12\t130.887\n",
      "1300\t265\t131.052\n",
      "1400\t34\t130.957\n",
      "1500\t127\t131.526\n",
      "1600\t286\t131.435\n",
      "1700\t28\t129.559\n",
      "1800\t199\t130.411\n",
      "1900\t107\t129.373\n",
      "2000\t74\t130.102\n",
      "2100\t156\t130.296\n",
      "2200\t37\t129.717\n",
      "2300\t155\t130.382\n",
      "2400\t228\t130.164\n",
      "2500\t36\t129.364\n",
      "2600\t94\t129.358\n",
      "2700\t95\t130.05\n",
      "2800\t473\t129.929\n",
      "2900\t350\t129.37\n",
      "3000\t119\t129.97\n",
      "3100\t36\t130.074\n",
      "3200\t52\t130.296\n",
      "3300\t1086\t130.885\n",
      "3400\t46\t130.408\n",
      "3500\t9\t130.738\n",
      "3600\t74\t130.834\n",
      "3700\t136\t130.629\n",
      "3800\t59\t130.712\n",
      "3900\t224\t131.46\n",
      "4000\t308\t131.9\n",
      "4100\t160\t132.78\n",
      "4200\t50\t133.024\n",
      "4300\t313\t132.914\n",
      "4400\t292\t133.049\n",
      "4500\t69\t133.307\n",
      "4600\t244\t133.849\n",
      "4700\t36\t134.156\n",
      "4800\t335\t134.222\n",
      "4900\t70\t133.781\n",
      "****\n",
      "Average life: 133.602 steps\n"
     ]
    }
   ],
   "source": [
    "repetitions = 5000\n",
    "\n",
    "total_life = 0\n",
    "for i in range(repetitions):\n",
    "    landscape = Surroundings()\n",
    "    agent = Agent(landscape)\n",
    "    this_life = agent.live_justyna_kwiatkowska_edited()\n",
    "    total_life += this_life\n",
    "    if i%100 == 0:\n",
    "        print(i, this_life, round(total_life/(i+1), 3), sep=\"\\t\")\n",
    "\n",
    "print(\"****\\nAverage life:\", round(total_life/repetitions, 3), \"steps\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "ef2f83c4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-0.9\t115.914\n",
      "-0.87\t126.0\n",
      "-0.84\t113.056\n",
      "-0.81\t129.654\n",
      "-0.78\t125.81\n",
      "-0.75\t142.628\n",
      "-0.72\t144.242\n",
      "-0.69\t135.728\n",
      "-0.66\t136.72\n",
      "-0.63\t132.272\n",
      "-0.6\t129.656\n",
      "-0.57\t135.776\n",
      "-0.54\t139.258\n",
      "-0.51\t139.156\n",
      "-0.48\t146.148\n",
      "-0.45\t149.396\n",
      "-0.42\t140.67\n",
      "-0.39\t142.812\n",
      "-0.36\t152.75\n",
      "-0.33\t140.85\n",
      "-0.3\t142.042\n",
      "-0.27\t132.782\n",
      "-0.24\t139.768\n",
      "-0.21\t137.22\n",
      "-0.18\t135.838\n",
      "-0.15\t139.368\n",
      "-0.12\t142.204\n",
      "-0.09\t144.074\n",
      "-0.06\t139.48\n",
      "-0.03\t136.832\n",
      "0.0\t140.086\n",
      "0.03\t138.778\n",
      "0.06\t132.842\n",
      "0.09\t126.94\n",
      "0.12\t133.238\n",
      "0.15\t120.564\n",
      "0.18\t127.146\n",
      "0.21\t119.3\n",
      "0.24\t130.346\n",
      "0.27\t113.878\n",
      "0.3\t118.16\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "repetitions = 500\n",
    "\n",
    "average_lifetime = {}\n",
    "\n",
    "for bias in np.arange(-0.9, 0.301, 0.03):\n",
    "    total_life = 0\n",
    "    for i in range(repetitions):\n",
    "        landscape = Surroundings()\n",
    "        agent = Agent(landscape)\n",
    "        this_life = agent.live_biased(bias)\n",
    "        total_life += this_life\n",
    "    average_lifetime[bias] = total_life/repetitions\n",
    "    print(round(bias, 3), round(average_lifetime[bias], 3), sep=\"\\t\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "d4cc73b1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:xlabel='temperature bias (i.e., preferred temperature level)', ylabel='average lifetime (in number of steps)'>"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 792x936 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import seaborn as sbn\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "keylist_lifetime = list(average_lifetime.keys())\n",
    "vallist_lifetime = list(average_lifetime.values())\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "fig.set_size_inches(11, 13)\n",
    "plt.xticks(fontsize=18, color=\"#322300\")\n",
    "plt.yticks(fontsize=18, color=\"#322300\")\n",
    "ax.set_xlabel(\"temperature bias (i.e., preferred temperature level)\", fontsize=24, color=\"#322300\")\n",
    "ax.set_ylabel(\"average lifetime (in number of steps)\", fontsize=24, color=\"#322300\")\n",
    "\n",
    "sbn.regplot(x=keylist_lifetime, y=vallist_lifetime, \\\n",
    "            color='#002855', order=2, scatter_kws={'s':10})  # blue for mergesort"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "789432e9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\t150\t150.0\n",
      "100\t107\t147.703\n",
      "200\t48\t150.303\n",
      "300\t23\t143.611\n",
      "400\t88\t135.793\n",
      "500\t42\t142.11\n",
      "600\t54\t142.712\n",
      "700\t42\t145.026\n",
      "800\t182\t144.318\n",
      "900\t124\t147.326\n",
      "1000\t457\t146.886\n",
      "1100\t500\t146.45\n",
      "1200\t174\t147.743\n",
      "1300\t8\t148.03\n",
      "1400\t374\t146.547\n",
      "1500\t73\t145.588\n",
      "1600\t368\t144.766\n",
      "1700\t15\t144.878\n",
      "1800\t123\t144.485\n",
      "1900\t51\t146.205\n",
      "2000\t101\t145.317\n",
      "2100\t3\t144.699\n",
      "2200\t40\t144.511\n",
      "2300\t94\t144.558\n",
      "2400\t67\t143.895\n",
      "2500\t153\t144.381\n",
      "2600\t26\t144.945\n",
      "2700\t279\t145.659\n",
      "2800\t177\t145.231\n",
      "2900\t31\t144.774\n",
      "3000\t526\t146.679\n",
      "3100\t21\t146.371\n",
      "3200\t28\t146.471\n",
      "3300\t170\t146.223\n",
      "3400\t62\t146.856\n",
      "3500\t41\t146.191\n",
      "3600\t128\t146.032\n",
      "3700\t262\t146.105\n",
      "3800\t13\t146.31\n",
      "3900\t18\t145.946\n",
      "4000\t255\t145.372\n",
      "4100\t139\t145.342\n",
      "4200\t236\t145.53\n",
      "4300\t505\t145.535\n",
      "4400\t63\t145.344\n",
      "4500\t71\t145.641\n",
      "4600\t154\t145.86\n",
      "4700\t134\t146.088\n",
      "4800\t286\t146.406\n",
      "4900\t63\t146.16\n",
      "****\n",
      "Average life: 145.984 steps\n"
     ]
    }
   ],
   "source": [
    "repetitions = 5000\n",
    "\n",
    "total_life = 0\n",
    "for i in range(repetitions):\n",
    "    landscape = Surroundings()\n",
    "    agent = Agent(landscape)\n",
    "    this_life = agent.live_biased(-1/3)\n",
    "    total_life += this_life\n",
    "    if i%100 == 0:\n",
    "        print(i, this_life, round(total_life/(i+1), 3), sep=\"\\t\")\n",
    "\n",
    "print(\"****\\nAverage life:\", round(total_life/repetitions, 3), \"steps\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d10b171d",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}