2D Delivery System Simulation - EpicCool.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "4ed9783e",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Simulation and Optimizing of 2D mail delivery system with Monte Carlo\n",
    "> By **Team EpicCool** (Zayan, Kabir and Prannaya)<br>\n",
    "> _8 and 9 December 2021_"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eb26f592",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "de8eab95",
   "metadata": {
    "deletable": false,
    "editable": false,
    "jupyter": {
     "outputs_hidden": true
    },
    "run_control": {
     "frozen": true
    },
    "scrolled": true,
    "tags": []
   },
   "outputs": [],
   "source": [
    "import Pkg;\n",
    "Pkg.add(\"Plots\")\n",
    "Pkg.add(\"Statistics\")\n",
    "Pkg.add(\"StatsBase\")\n",
    "Pkg.add(\"WebIO\")\n",
    "Pkg.add(\"DelimitedFiles\") \n",
    "Pkg.add(\"PyPlot\") #on-the-fly animation using pyplot backend seems less flickers\n",
    "Pkg.add(\"Evolutionary\")\n",
    "Pkg.add(\"Optim\")\n",
    "Pkg.add(\"NLopt\")\n",
    "Pkg.build(\"PyCall\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "8b038f1d",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-12-09T14:35:28.171000+08:00",
     "start_time": "2021-12-09T06:35:15.301Z"
    },
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "using Plots, Statistics,Random, StatsBase, DelimitedFiles"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2725cfb9",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "## Rules and policy"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e45c7aee",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-12-09T12:57:30.747000+08:00",
     "start_time": "2021-12-09T04:57:29.164Z"
    }
   },
   "source": [
    "In this subject, we consider a mail delivery system where mails are delivered on a network of connected stations,  \n",
    "and they can only be delivered from station to station, say via mail service workers on horses.   \n",
    "It starts at $0$ (the source), with two types of mails (A and B. It can be more than two types in a more complicated setup).   \n",
    "Stations $3$(B) and $6$(A) are the respective destinations. After going to the correct destination, the mails are sent to $7$ (the drain).  \n",
    "Here a few basic rules for delivery the mails:  \n",
    "- For each time step, the mails move only one step.\n",
    "- One station can have at most one mail at each time step.\n",
    "- The mail is allowed to be delivered to any of the available connected stations.\n",
    "- The probabilities of going to any station is user-defined\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "394e554d",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<img src='assets/cmap.gif' width=\"400\" height=\"300\">"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b9219ff3",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Core functions for delivery algorithm"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eb30f849",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "\n",
    "\n",
    "The connectivity matrix describes all connections of the stations to one another.  \n",
    "We indicate 1 in the corresponding row and columns to indicate a connection.  \n",
    "For eg. where 1 connects to 2, the matrix (row,column)->(1,2)=1  \n",
    "At this stage, this is manually input.  \n",
    "The connectivity matrix describing the above node connections that **allows for all directions** is as follows:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f9fe207",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Connectivity matrix for the delivery path (tested)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "893b6192",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-12-09T14:35:31.315000+08:00",
     "start_time": "2021-12-09T06:35:15.317Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "connect_matrix_2D (generic function with 1 method)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# connectivity matrix\n",
    "# Vetically, the mail can be delivered back; Horizontally, the mail can only be delivered forward to the destination.\n",
    "function connect_matrix_2D()\n",
    "    #1st row is source, last row is drain. all entries are connected to source, all exits are connected to drain!\n",
    "    C = zeros(Float64,8,8);\n",
    "    C[1,2] = 1;\n",
    "    \n",
    "    C[2,3] = 1;\n",
    "    C[2,5] = 1;\n",
    "    \n",
    "    C[3,2] = 1;\n",
    "    C[3,4] = 1;\n",
    "    C[3,6] = 1;\n",
    "    \n",
    "    C[4,3] = 1;\n",
    "    C[4,8] = 1;\n",
    "    \n",
    "    C[5,2] = 1;\n",
    "    C[5,6] = 1;\n",
    "    \n",
    "    C[6,3] = 1;\n",
    "    C[6,5] = 1;\n",
    "    C[6,7] = 1;\n",
    "    \n",
    "    C[7,6] = 1; \n",
    "    C[7,8] = 1;\n",
    "    \n",
    "    C[8,8] = 1;\n",
    "    return C\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "e79e088b",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-12-09T14:35:31.519000+08:00",
     "start_time": "2021-12-09T06:35:15.325Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "connect_matrix_A (generic function with 1 method)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function connect_matrix_A()\n",
    "    A = zeros(Float64,8,8);\n",
    "    A[1,2] = 1;\n",
    "    \n",
    "    A[2,3] = 0.1;\n",
    "    A[2,5] = 0.9;\n",
    "    \n",
    "    A[3,2] = 0.1;\n",
    "    A[3,4] = 0.1;\n",
    "    A[3,6] = 0.8;\n",
    "    \n",
    "    A[4,3] = 1; #if A mail reaches B(3), mail returns to station 2 with 100% probability.\n",
    "    \n",
    "    A[5,2] = 0.1;\n",
    "    A[5,6] = 0.9;\n",
    "    \n",
    "    A[6,3] = 0.1;\n",
    "    A[6,5] = 0.1;\n",
    "    A[6,7] = 0.8;\n",
    "    \n",
    "    A[7,8] = 1; \n",
    " \n",
    "    return A\n",
    "end\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "55dbb681",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-12-09T14:35:31.697000+08:00",
     "start_time": "2021-12-09T06:35:15.332Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "connect_matrix_B (generic function with 1 method)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function connect_matrix_B()\n",
    "    B = zeros(Float64,8,8);\n",
    "    B[1,2] = 1;\n",
    "    \n",
    "    B[2,3] = 0.9;\n",
    "    B[2,5] = 0.1;\n",
    "    \n",
    "    B[3,2] = 0.1;\n",
    "    B[3,4] = 0.8;\n",
    "    B[3,6] = 0.1;\n",
    "    \n",
    "    B[4,8] = 1;\n",
    "        \n",
    "    B[5,2] = 0.9;\n",
    "    B[5,6] = 0.1;\n",
    "    \n",
    "    B[6,3] = 0.8;\n",
    "    B[6,5] = 0.1;\n",
    "    B[6,7] = 0.1;\n",
    "     \n",
    "    B[7,6] = 1; #if B mail reaches A(6), mail returns to station 5 with 100% probability.  \n",
    " \n",
    "    return B\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "98f6561c",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-12-09T14:35:33.611000+08:00",
     "start_time": "2021-12-09T06:35:15.339Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8×8 Matrix{Float64}:\n",
       " 0.0  1.0  0.0  0.0  0.0  0.0  0.0  0.0\n",
       " 0.0  0.0  1.0  0.0  1.0  0.0  0.0  0.0\n",
       " 0.0  1.0  0.0  1.0  0.0  1.0  0.0  0.0\n",
       " 0.0  0.0  1.0  0.0  0.0  0.0  0.0  1.0\n",
       " 0.0  1.0  0.0  0.0  0.0  1.0  0.0  0.0\n",
       " 0.0  0.0  1.0  0.0  1.0  0.0  1.0  0.0\n",
       " 0.0  0.0  0.0  0.0  0.0  1.0  0.0  1.0\n",
       " 0.0  0.0  0.0  0.0  0.0  0.0  0.0  1.0"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C = connect_matrix_2D()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "70d582fb",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-12-09T14:35:33.652000+08:00",
     "start_time": "2021-12-09T06:35:15.347Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8×8 Matrix{Float64}:\n",
       " 0.0  1.0  0.0  0.0  0.0  0.0  0.0  0.0\n",
       " 0.0  0.0  0.1  0.0  0.9  0.0  0.0  0.0\n",
       " 0.0  0.1  0.0  0.1  0.0  0.8  0.0  0.0\n",
       " 0.0  0.0  1.0  0.0  0.0  0.0  0.0  0.0\n",
       " 0.0  0.1  0.0  0.0  0.0  0.9  0.0  0.0\n",
       " 0.0  0.0  0.1  0.0  0.1  0.0  0.8  0.0\n",
       " 0.0  0.0  0.0  0.0  0.0  0.0  0.0  1.0\n",
       " 0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "conn_matA = connect_matrix_A()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "a39b49a4",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-12-09T14:35:33.688000+08:00",
     "start_time": "2021-12-09T06:35:15.356Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8×8 Matrix{Float64}:\n",
       " 0.0  1.0  0.0  0.0  0.0  0.0  0.0  0.0\n",
       " 0.0  0.0  0.9  0.0  0.1  0.0  0.0  0.0\n",
       " 0.0  0.1  0.0  0.8  0.0  0.1  0.0  0.0\n",
       " 0.0  0.0  0.0  0.0  0.0  0.0  0.0  1.0\n",
       " 0.0  0.9  0.0  0.0  0.0  0.1  0.0  0.0\n",
       " 0.0  0.0  0.8  0.0  0.1  0.0  0.1  0.0\n",
       " 0.0  0.0  0.0  0.0  0.0  1.0  0.0  0.0\n",
       " 0.0  0.0  0.0  0.0  0.0  0.0  0.0  0.0"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "conn_matB = connect_matrix_B()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1966de02",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Function that initializes the matrix of histories (tested)\n",
    "Entries of history matrix, $H$, are initialized to 0.  \n",
    "All mails get ready at position 0.  \n",
    "This matrix stores the trajectory of the mails across time.  \n",
    "Each **row** corresponds to a mail in the system and each **column** stores the positions of all the mails at a snapshot in time.  \n",
    "Going across the row tells you the position of a particular mail across time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "7a74d501",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-12-09T14:35:33.845000+08:00",
     "start_time": "2021-12-09T06:35:16.167Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "initialize_H (generic function with 1 method)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function initialize_H(NC,tM)\n",
    "    # tM maximum number of time steps\n",
    "    # NC is the number of mails\n",
    "    return H = zeros(Int16,NC, tM+2); #this tM+2 can be alterd to taste    \n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7fc84574",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Function that finds available next positions (tested)\n",
    "Given a mail's position (for example, ip), the following procedures are used to determine the available positions\n",
    "- Determine the **reachable positions** by inspecting the corresponding row of the connectivity matrix, $C$\n",
    "- Determine the **occupied positions** by inspecting the column of history matrix, $H$, corresponds to the time step.  \n",
    "However, $0$, $L+1$ are excluded.  \n",
    "Recall the position $0$ is the source which hosts the awaiting of mails, and $L+1$ is for the drain of mails, respectively. \n",
    "- **Positions available** are the positions which are reachable but not occupied. Equivalently, set of reachable subtract set of occupied."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "eb7a6354",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-12-09T14:35:34.017000+08:00",
     "start_time": "2021-12-09T06:35:16.173Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "find_pos_available_k (generic function with 1 method)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function find_pos_available_k(ic,it,H,C,L,conn_mat) \n",
    "    # ic is the mail number \n",
    "    # it is the time step \n",
    "    # H matrix of histories \n",
    "    # C connectivity matrix \n",
    "    # L is the number of stations \n",
    "    # for a particular mail at a particular time, \n",
    "    aux = size(H);\n",
    "    NC = copy(aux[1]); #NC returns the total number of mails \n",
    "    vec_pos0 = Int64.(zeros(0)); \n",
    "    vec_pos = Int64.(zeros(0)); \n",
    "    vec_prob0 = Float64.(zeros(0)); \n",
    "    vec_prob = Float64.(zeros(0)); \n",
    "    \n",
    "    ip = copy(H[ic,it]); #obtain current position of the mail from history matrix    \n",
    "    for iL = 1:L+2 #check all possible positions, +2 to account for source and drain\n",
    "        if C[ip+1,iL] == 1 #(row,col) check whether this station is connected to station ip (it would be a 1 in the connectivity matrix)\n",
    "                           #ip+1 to account for numbering of station, 0th station starts at 1st row. \n",
    "            if conn_mat[ip+1,iL] != 0 #check whether mail type has prob of moving to station iL, if so, store position and corresponding probability\n",
    "                vec_pos0 = append!(vec_pos0, iL-1); #stores all reachable stations\n",
    "                vec_prob0 = append!(vec_prob0, conn_mat[ip+1,iL]); #store prob of respective reachable stations\n",
    "            end\n",
    "        end\n",
    "    end\n",
    "    \n",
    "    #conflict resolution\n",
    "    aux = size(vec_pos0) #total number of reachable stations\n",
    "    for ipos = 1:aux[1] #going across all possible stations\n",
    "        s=0;\n",
    "        if (vec_pos0[ipos] != L+1)  #if the mail is not outside, which is at L+1   \n",
    "            for iNC = 1:NC #going across all mails\n",
    "                if H[iNC,it] == copy(vec_pos0[ipos]); #checks if stations is already occupied by other mails. if so, add 1 to s. \n",
    "                    s+=1;\n",
    "                end\n",
    "            end\n",
    "        end    \n",
    "        if s==0 #if s!=1, proceed\n",
    "            vec_pos = append!(vec_pos,vec_pos0[ipos]); # if there are no collisions, store particular reachable station in vec_pos which is returned by this function.\n",
    "            vec_prob = append!(vec_prob,vec_prob0[ipos]);\n",
    "            \n",
    "        end\n",
    "    end\n",
    "    if !isempty(vec_prob) #if probability vector is not empty, normalise it\n",
    "        vec_prob = vec_prob./sum(vec_prob);#normalise probability here!\n",
    "    end\n",
    "    return vec_pos, vec_prob\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "8bd9cfb3",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-12-09T14:35:34.778000+08:00",
     "start_time": "2021-12-09T06:35:16.180Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4×12 Matrix{Int16}:\n",
       " 0  0  0  0  0  0  0  0  0  0  0  0\n",
       " 0  0  0  0  0  0  0  0  0  0  0  0\n",
       " 0  0  0  0  0  0  0  0  0  0  0  0\n",
       " 0  0  0  0  0  0  0  0  0  0  0  0"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "H = initialize_H(4,10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "a992f1ae",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-12-09T14:35:34.793000+08:00",
     "start_time": "2021-12-09T06:35:16.185Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4×12 Matrix{Int16}:\n",
       " 7  0  0  0  0  0  0  0  0  0  0  0\n",
       " 5  0  0  0  0  0  0  0  0  0  0  0\n",
       " 3  0  0  0  0  0  0  0  0  0  0  0\n",
       " 0  0  0  0  0  0  0  0  0  0  0  0"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "H[1,1]=7;\n",
    "H[2,1]=5;\n",
    "H[3,1]=3;\n",
    "H"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "deec4d73",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-12-09T14:35:36.168000+08:00",
     "start_time": "2021-12-09T06:35:16.193Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([2, 4, 6], [0.1, 0.1, 0.8])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vec_pos, Avec_prob=find_pos_available_k(2,1,H,C,6,conn_matA) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f66470c",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Function that delivers a single mail (tested)\n",
    "The mail worker first decides whether to deliver the mail according to the dictated probability. If so, it randomly picks one position from available positions and registers the intention into the corresponding column of history matrix, $H$. Note that, at this stage, the movement is not final due to possible conflicts with other mails."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "5938fda7",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-12-09T14:35:36.201000+08:00",
     "start_time": "2021-12-09T06:35:16.201Z"
    },
    "slideshow": {
     "slide_type": "skip"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "#Demonstrates how to draw weighted sampling\n",
    "# Pkg.add(\"StatsBase\")  # Only do this once, obviously\n",
    "# using StatsBase\n",
    "# items = [\"a\", 2, 5, \"h\", \"hello\", 3]\n",
    "# weights = [0.1, 0.1, 0.2, 0.2, 0.1, 0.3]\n",
    "# sample(items, Weights(weights))\n",
    "# choice_weighted = sample(vec_pos, Weights(Avec_prob))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "1cf64681",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-12-09T14:35:36.351000+08:00",
     "start_time": "2021-12-09T06:35:16.207Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "move_position_k (generic function with 1 method)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function move_position_k(ic,it,H,vec_pos, Avec_prob,conn_matA)\n",
    "   #applies probability of moving via prob connectivity matrix A and B\n",
    "    current_pos = copy(H[ic,it]); # current mail position\n",
    "    aux = size(vec_pos);\n",
    "    n_pos = copy(aux[1]);\n",
    "    if n_pos > 0\n",
    "        H[ic,it+1] = sample(vec_pos, Weights(Avec_prob)); #draw randomly from weighted distribution\n",
    "    end\n",
    "    return H\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "23117ba0",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-12-09T14:35:36.516000+08:00",
     "start_time": "2021-12-09T06:35:16.213Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "deliver_mail_k (generic function with 1 method)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function deliver_mail_k(ic,numA,it,H,C,L,conn_matA,conn_matB)\n",
    "    # numA is number of mails belonging to A. Above numA, all mails belong to B\n",
    "    # if A execute connectivity matrix A\n",
    "    # ic is the mail number\n",
    "    # H matrix of histories\n",
    "    # it time step\n",
    "    # C connectivity matrix\n",
    "    H[ic, it+1] = copy(H[ic, it]); \n",
    "    # vec_pos, vec_prob= find_pos_available_k(ic,it,H,C,L);\n",
    "    if ic <= numA\n",
    "            vec_pos, Avec_prob= find_pos_available_k(ic,it,H,C,L,conn_matA);\n",
    "            H = move_position_k(ic,it,H,vec_pos, Avec_prob,conn_matA)\n",
    "    else\n",
    "            vec_pos, Bvec_prob= find_pos_available_k(ic,it,H,C,L,conn_matB);\n",
    "            H = move_position_k(ic,it,H,vec_pos, Bvec_prob,conn_matB)\n",
    "\n",
    "    end\n",
    "    return H\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e7c1bbf",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Check for and resolve conflicts (tested)\n",
    "\n",
    "Given a position in the mail delivery path, following procedure is used to resolve conflicts:\n",
    "- Determine a list of mails delivering to the same station by inspecting the column of history matrix, $H$, correspond to current time step. For example, given $\\text{it}$ (time step) and $\\text{iL}$ (position of the station in connected network), the index of entries in $H[:,\\text{it}]==\\text{iL}$ are the mails which are going into the station iL.\n",
    "- More than one mails going into the same position constitue a conflict.\n",
    "- To resolve conflict, we randomly let one mail to move on and make the rest stay put.\n",
    "- Iterate over all positions in the connected delivery network, rinse and repeat."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "834fec76",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-12-09T14:35:36.689000+08:00",
     "start_time": "2021-12-09T06:35:16.222Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "find_resolve_conflicts (generic function with 1 method)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function find_resolve_conflicts(H,L,it)\n",
    "    #conflicts only happen for new positions. conflicts from old to new has been resolved in find_pos_available\n",
    "    # it is the time step \n",
    "    # H matrix of histories \n",
    "    # L is the number of positions \n",
    "    Hn = copy(H); \n",
    "    aux = size(H); \n",
    "    NC = aux[1]; \n",
    "    # finds list of cars that are in conflict.\n",
    "    for iL = 1:L\n",
    "        list_cars = Int64.(zeros(0)); \n",
    "        for ic = 1:NC \n",
    "            if H[ic,it] == iL \n",
    "                list_cars = append!(list_cars, ic);\n",
    "            end\n",
    "        end\n",
    "        aux = size(list_cars); \n",
    "        #in list of cars with conflict, randomly let one car progress and keep the rest stationary.\n",
    "        if aux[1]>1\n",
    "            i_pos = rand(1:aux[1],1,1);\n",
    "            keep_pos = copy(i_pos[1]); \n",
    "            for ipos = 1:aux[1]\n",
    "                Hn[list_cars[ipos], it] = copy(H[list_cars[ipos], it-1]); #the rest are sent back to their prev station\n",
    "            end\n",
    "            Hn[list_cars[keep_pos], it] = copy(H[list_cars[keep_pos], it]); #selected mail proceeds to new position\n",
    "        end\n",
    "    end\n",
    "    return Hn \n",
    "    \n",
    "end\n",
    "\n",
    "# H = initialize_H(4,4)\n",
    "# H[1,2] = 1\n",
    "# H[2,2] = 1\n",
    "# H[3,2] = 1\n",
    "# H[4,2] = 1\n",
    "# H = find_resolve_conflicts(H,L,2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "305aba26",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Function that delivery all the mails (tested) \n",
    "All mails are to be delivered to the next station, and conflicts are resolved, the movements are final."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "7f58b0e8",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-12-09T14:35:36.842000+08:00",
     "start_time": "2021-12-09T06:35:16.230Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "next_step_k (generic function with 1 method)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function next_step_k(H,it,C,L,numA,conn_matA,conn_matB)\n",
    "    # H matrix of histories\n",
    "    # p_mov probability of moving\n",
    "    # it time step\n",
    "    # C connectivity matrix\n",
    "    aux = size(H);\n",
    "    NC = copy(aux[1]); \n",
    "    for ic = 1:NC\n",
    "         H = deliver_mail_k(ic,numA,it,H,C,L,conn_matA,conn_matB); # \n",
    "    end\n",
    "    H = find_resolve_conflicts(H,L,it+1); # \n",
    "    return H\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "83f9360a",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Example 1\n",
    "In this example, we simulate a delivery process consisting of two kinds of mails (A and B). They are supposed to be sent to two destinations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "3b4d71d9",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-12-09T14:35:37.072000+08:00",
     "start_time": "2021-12-09T06:35:16.238Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4×12 Matrix{Int16}:\n",
       " 0  1  4  5  6  7  7  7  7  7  7  7\n",
       " 0  0  0  1  4  5  6  7  7  7  7  7\n",
       " 0  0  0  0  0  1  2  2  3  7  7  7\n",
       " 0  0  0  0  0  0  0  1  4  1  2  3"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "NMail = 4; # number of mails\n",
    "tM = 10; # total time steps\n",
    "L = 6; # number of sites\n",
    "numA = 2 # mail A number\n",
    "numB = NMail - numA # mail B number\n",
    "\n",
    "C = connect_matrix_2D();\n",
    "conn_matA = connect_matrix_A()\n",
    "conn_matB = connect_matrix_B()\n",
    "H = initialize_H(NMail,tM);\n",
    "\n",
    "for it = 1:tM+1\n",
    "    H = next_step_k(H,it,C,L,numA,conn_matA,conn_matB);\n",
    "end\n",
    "H"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "47ed2d15",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Measurement"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c9b30d9",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Analyze the time spent travelling between station a and station b\n",
    "We determine the time spent for each type of mail (A or B) to get from station a to station b. The distribution is visualized using histogram. Following that, average and standard deviation of time spent are reported. The function itself returns a list of mail numbers corresponding to those which accomplished the journey between station a and station b.|"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "f5848f6a",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-12-09T14:35:37.284000+08:00",
     "start_time": "2021-12-09T06:35:16.244Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "time_start_end (generic function with 1 method)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function time_start_end(H,numA,numB)\n",
    "    # calculate the time taken by each mail from initial station to destination position given the history matrix\n",
    "    # H history matrix\n",
    "    \n",
    "    sv = size(H);\n",
    "    max_time = sv[2]; \n",
    "    A_first_time_check = zeros(Int16, numA, 1); \n",
    "    B_first_time_check = zeros(Int16, numB, 1); \n",
    "    A_second_time_check = zeros(Int16, numA, 1); \n",
    "    B_second_time_check = zeros(Int16, numB, 1); \n",
    "    init_pos_A = 1; \n",
    "    init_pos_B = 1; \n",
    "    fina_pos_A = 6; \n",
    "    fina_pos_B = 3; \n",
    "\n",
    "    #find first and second time for A mails \n",
    "    for i in 1:numA\n",
    "        aux = findfirst(x -> x == init_pos_A, H[i,:]); \n",
    "        if aux == nothing \n",
    "            aux = 0; \n",
    "        end\n",
    "        A_first_time_check[i] = aux; \n",
    "        aux = findfirst(x -> x == fina_pos_A, H[i,:]); \n",
    "        if aux == nothing \n",
    "            aux = 0; \n",
    "        end\n",
    "        A_second_time_check[i] = aux; \n",
    "    end\n",
    "    \n",
    "    #find first and second time for B mails \n",
    "    for i in 1:numB\n",
    "        aux = findfirst(x -> x == init_pos_B, H[numA+i,:]); \n",
    "        if aux == nothing \n",
    "            aux = 0; \n",
    "        end\n",
    "        B_first_time_check[i] = aux; \n",
    "        aux = findfirst(x -> x == fina_pos_B, H[numA+i,:]); \n",
    "        if aux == nothing \n",
    "            aux = 0; \n",
    "        end\n",
    "        B_second_time_check[i] = aux; \n",
    "    end\n",
    "    \n",
    "    #compute the difference between first and last time \n",
    "    diff_A =  A_second_time_check - A_first_time_check; \n",
    "    diff_B =  B_second_time_check - B_first_time_check; \n",
    "    \n",
    "    # if the result is 0, it means that it never entered and it should not be counted \n",
    "    # if the results is negative, it means that it never reached the destination, so now we do not count it  \n",
    "    time_diff_A = sort(diff_A[findall(x->x>0, diff_A)]);   \n",
    "    time_diff_B = sort(diff_B[findall(x->x>0, diff_B)]);   \n",
    "    \n",
    "    return time_diff_A, time_diff_B       \n",
    "end "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "10080a48",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-12-09T14:35:40.697000+08:00",
     "start_time": "2021-12-09T06:35:16.249Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2-element Vector{Int16}:\n",
       " 3\n",
       " 3"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "2-element Vector{Int16}:\n",
       " 3\n",
       " 4"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "time_diff_A, time_diff_B = time_start_end(H,numA,numB); \n",
    "display(time_diff_A)\n",
    "display(time_diff_B)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ca2fdc4",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Evolution Testing"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0dca569e",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Mock Test and Fitness Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "30dd2fbf",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-12-09T14:35:40.942000+08:00",
     "start_time": "2021-12-09T06:35:16.257Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "test_function (generic function with 1 method)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function test_function(x)\n",
    "    NMail = 10; # number of mails\n",
    "    tM = 10; # total time steps\n",
    "    L = 6; # number of sites\n",
    "    numA = 5 # mail A number\n",
    "    numB = NMail - numA # mail B number\n",
    "    \n",
    "    A = zeros(Float64,8,8);\n",
    "    A[1,2] = 1;\n",
    "    A[2,3] = x[1];\n",
    "    A[2,5] = x[2];\n",
    "    A[3,2] = x[3];\n",
    "    A[3,4] = x[4];\n",
    "    A[3,6] = x[5];\n",
    "    A[4,3] = 1; #if A mail reaches B(3), mail returns to station 2 with 100% probability.\n",
    "    A[5,2] = x[6];\n",
    "    A[5,6] = x[7];\n",
    "    A[6,3] = x[8];\n",
    "    A[6,5] = x[9];\n",
    "    A[6,7] = x[10];\n",
    "    A[7,8] = 1;\n",
    "\n",
    "    C = connect_matrix_2D();\n",
    "    B = connect_matrix_B();\n",
    "    H = initialize_H(NMail,tM);\n",
    "    for it = 1:tM+1\n",
    "        H = next_step_k(H,it,C,L,numA,conn_matA,conn_matB);\n",
    "    end\n",
    "    return time_start_end(H,numA,numB)\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "19509405",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-12-09T14:35:41.193000+08:00",
     "start_time": "2021-12-09T06:35:16.265Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "fitness_function (generic function with 1 method)"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function fitness_function(x)\n",
    "    NMail = 10; # number of mails\n",
    "    tM = 10; # total time steps\n",
    "    L = 6; # number of sites\n",
    "    numA = 5 # mail A number\n",
    "    numB = NMail - numA # mail B number\n",
    "    \n",
    "    A = zeros(Float64,8,8);\n",
    "    A[1,2] = 1;\n",
    "    A[2,3] = x[1];\n",
    "    A[2,5] = x[2];\n",
    "    A[3,2] = x[3];\n",
    "    A[3,4] = x[4];\n",
    "    A[3,6] = x[5];\n",
    "    A[4,3] = 1; #if A mail reaches B(3), mail returns to station 2 with 100% probability.\n",
    "    A[5,2] = x[6];\n",
    "    A[5,6] = x[7];\n",
    "    A[6,3] = x[8];\n",
    "    A[6,5] = x[9];\n",
    "    A[6,7] = x[10];\n",
    "    A[7,8] = 1;\n",
    "\n",
    "    C = connect_matrix_2D();\n",
    "    B = connect_matrix_B();\n",
    "    time_diff_A_overall = Int64.(zeros(0));\n",
    "    time_diff_B_overall = Int64.(zeros(0));\n",
    "    for i = 1:100\n",
    "        H = initialize_H(NMail,tM);\n",
    "        for it = 1:tM+1\n",
    "            H = next_step_k(H,it,C,L,numA,conn_matA,conn_matB);\n",
    "        end\n",
    "        time_diff_A, time_diff_B = time_start_end(H,numA,numB)\n",
    "        time_diff_A_overall = append!(time_diff_A_overall, time_diff_A)\n",
    "        time_diff_B_overall = append!(time_diff_B_overall, time_diff_B)\n",
    "    end\n",
    "    return sum(time_diff_A_overall) * 1/size(time_diff_A_overall)[1] + sum(time_diff_B_overall) * 1/size(time_diff_B_overall)[1]\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7a9daf1b",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Testing Evolutionary (Genetic Algorithms)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "2472353f",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-12-09T14:35:42.069000+08:00",
     "start_time": "2021-12-09T06:35:16.271Z"
    }
   },
   "outputs": [],
   "source": [
    "using Evolutionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "e7d2adfa",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-12-09T14:38:09.478000+08:00",
     "start_time": "2021-12-09T06:35:16.276Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\n",
       " * Status: failure (reached maximum number of iterations)\n",
       "\n",
       " * Candidate solution\n",
       "    Minimizer:  [0.0, 0.0, 0.6475982666015625,  ...]\n",
       "    Minimum:    5.883273331487123\n",
       "    Iterations: 100\n",
       "\n",
       " * Found with\n",
       "    Algorithm: GA[P=100,x=0.8,μ=0.1,ɛ=0]\n",
       "\n",
       " * Work counters\n",
       "    Seconds run:   142.901 (vs limit Inf)\n",
       "    Iterations:    100\n",
       "    f(x) calls:    10199\n"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result = Evolutionary.optimize(fitness_function, [0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0],\n",
    "    [1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0],\n",
    "    [0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0], \n",
    "    GA(populationSize = 100, selection = susinv, crossover = discrete, mutation = domainrange(ones(10))),\n",
    "    Evolutionary.Options(iterations=100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "5fc45787",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-12-09T14:38:11.142000+08:00",
     "start_time": "2021-12-09T06:35:16.280Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10-element Vector{Float64}:\n",
       " 0.0\n",
       " 0.0\n",
       " 0.6475982666015625\n",
       " 0.1640777587890625\n",
       " 0.0\n",
       " 0.0\n",
       " 0.6248178482055664\n",
       " 0.007803916931152344\n",
       " 0.0019655227661132812\n",
       " 0.06043434143066406"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = Evolutionary.minimizer(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "89ad0efd",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Node-Based Optimization"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "effe00bf",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Utility and Helper Functions + Constants"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "fb80497b",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-12-09T14:38:13.099000+08:00",
     "start_time": "2021-12-09T06:35:16.289Z"
    }
   },
   "outputs": [],
   "source": [
    "using Optim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "c2102b03",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-12-09T14:38:14.903000+08:00",
     "start_time": "2021-12-09T06:35:16.293Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "sigmoid (generic function with 1 method)"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function sigmoid(x)\n",
    "    return 1/(1 + exp(-x))\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "0f56d342",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-12-09T14:38:15.751000+08:00",
     "start_time": "2021-12-09T06:35:16.299Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10-element Vector{Float64}:\n",
       " 0.5\n",
       " 0.5\n",
       " 0.5\n",
       " 0.5\n",
       " 0.5\n",
       " 0.5\n",
       " 0.5\n",
       " 0.5\n",
       " 0.5\n",
       " 0.5"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "global_x = [0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "144b6891",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-12-09T14:38:16.159000+08:00",
     "start_time": "2021-12-09T06:35:16.303Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "NMail = 10; # number of mails\n",
    "tM = 30; # total time steps\n",
    "L = 6; # number of sites\n",
    "numA = 5 # mail A number\n",
    "numB = NMail - numA # mail B number"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6b6c782",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Node-Based Fitness Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "da21b212",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-12-09T14:38:16.400000+08:00",
     "start_time": "2021-12-09T06:35:16.309Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "fitness_function_node_2 (generic function with 1 method)"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#2 values\n",
    "function fitness_function_node_2(x)\n",
    "    A = zeros(Float64,8,8);\n",
    "    A[1,2] = 1;\n",
    "    \n",
    "    A[2,3] = sigmoid(x[1]);\n",
    "    A[2,5] = sigmoid(x[2]);\n",
    "    A[2,3] = A[2,3] * (1.0/(A[2,3] + A[2,5]))\n",
    "    A[2,5] = A[2,5] * (1.0/(A[2,3] + A[2,5]))\n",
    "    \n",
    "    A[3,2] = sigmoid(global_x[3]);\n",
    "    A[3,4] = sigmoid(global_x[4]);\n",
    "    A[3,6] = sigmoid(global_x[5]);\n",
    "    A[3,2] = A[3,2] * (1.0/(A[3,2] + A[3,4] + A[3,6]))\n",
    "    A[3,4] = A[3,4] * (1.0/(A[3,2] + A[3,4] + A[3,6]))\n",
    "    A[3,6] = A[3,6] * (1.0/(A[3,2] + A[3,4] + A[3,6]))\n",
    "    \n",
    "    A[4,3] = 1; #if A mail reaches B(3), mail returns to station 2 with 100% probability.\n",
    "    \n",
    "    A[5,2] = sigmoid(global_x[6]);\n",
    "    A[5,6] = sigmoid(global_x[7]);\n",
    "    A[5,2] = A[5,2] * (1.0/(A[5,2] + A[5,6]))\n",
    "    A[5,6] = A[5,6] * (1.0/(A[5,2] + A[5,6]))\n",
    "    \n",
    "    A[6,3] = sigmoid(global_x[8]);\n",
    "    A[6,5] = sigmoid(global_x[9]);\n",
    "    A[6,7] = sigmoid(global_x[10]);\n",
    "    A[6,3] = A[6,3] * (1.0/(A[6,3] + A[6,5] + A[6,7]))\n",
    "    A[6,5] = A[6,5] * (1.0/(A[6,3] + A[6,5] + A[6,7]))\n",
    "    A[6,7] = A[6,7] * (1.0/(A[6,3] + A[6,5] + A[6,7]))\n",
    "    \n",
    "    A[7,8] = 1;\n",
    "\n",
    "    C = connect_matrix_2D();\n",
    "    B = connect_matrix_B();\n",
    "    loss = 0.0\n",
    "    for i = 1:100\n",
    "        H = initialize_H(NMail,tM);\n",
    "        for it = 1:tM+1\n",
    "            H = next_step_k(H,it,C,L,numA,conn_matA,conn_matB);\n",
    "        end\n",
    "        if(count(x->x==7, H[:,end]) == 0)\n",
    "            loss += 2\n",
    "        else\n",
    "            loss += 1.0/(count(x->x==7, H[:,end]))\n",
    "        end\n",
    "    end\n",
    "    return loss\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "id": "66a8f096",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-12-09T15:19:38.259000+08:00",
     "start_time": "2021-12-09T07:19:38.225Z"
    },
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8×8 Matrix{Float64}:\n",
       " 0.0  1.0            0.0         0.0       …  0.0         0.0         0.0\n",
       " 0.0  0.0          NaN           0.0          0.0         0.0         0.0\n",
       " 0.0  7.04041e-11    0.0         0.835768     0.19026     0.0         0.0\n",
       " 0.0  0.0            1.0         0.0          0.0         0.0         0.0\n",
       " 0.0  0.999942       0.0         0.0          5.78409e-5  0.0         0.0\n",
       " 0.0  0.0            4.45178e-5  0.0       …  0.0         3.72252e-5  0.0\n",
       " 0.0  0.0            0.0         0.0          0.0         0.0         1.0\n",
       " 0.0  0.0            0.0         0.0          0.0         0.0         0.0"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "A = zeros(Float64,8,8);\n",
    "A[1,2] = 1;\n",
    "\n",
    "#A[2,3] = sigmoid(x[1]);\n",
    "#A[2,5] = sigmoid(x[2]);\n",
    "A[2,3] = A[2,3] * (1.0/(A[2,3] + A[2,5]))\n",
    "A[2,5] = A[2,5] * (1.0/(A[2,3] + A[2,5]))\n",
    "\n",
    "A[3,2] = sigmoid(global_x[3]);\n",
    "A[3,4] = sigmoid(global_x[4]);\n",
    "A[3,6] = sigmoid(global_x[5]);\n",
    "A[3,2] = A[3,2] * (1.0/(A[3,2] + A[3,4] + A[3,6]))\n",
    "A[3,4] = A[3,4] * (1.0/(A[3,2] + A[3,4] + A[3,6]))\n",
    "A[3,6] = A[3,6] * (1.0/(A[3,2] + A[3,4] + A[3,6]))\n",
    "\n",
    "A[4,3] = 1; #if A mail reaches B(3), mail returns to station 2 with 100% probability.\n",
    "\n",
    "A[5,2] = sigmoid(global_x[6]);\n",
    "A[5,6] = sigmoid(global_x[7]);\n",
    "A[5,2] = A[5,2] * (1.0/(A[5,2] + A[5,6]))\n",
    "A[5,6] = A[5,6] * (1.0/(A[5,2] + A[5,6]))\n",
    "\n",
    "A[6,3] = sigmoid(global_x[8]);\n",
    "A[6,5] = sigmoid(global_x[9]);\n",
    "A[6,7] = sigmoid(global_x[10]);\n",
    "A[6,3] = A[6,3] * (1.0/(A[6,3] + A[6,5] + A[6,7]))\n",
    "A[6,5] = A[6,5] * (1.0/(A[6,3] + A[6,5] + A[6,7]))\n",
    "A[6,7] = A[6,7] * (1.0/(A[6,3] + A[6,5] + A[6,7]))\n",
    "\n",
    "A[7,8] = 1;\n",
    "display(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "69d84247",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-12-09T14:38:16.599000+08:00",
     "start_time": "2021-12-09T06:35:16.314Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "fitness_function_node_3 (generic function with 1 method)"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#2 values\n",
    "function fitness_function_node_3(x)\n",
    "    A = zeros(Float64,8,8);\n",
    "    A[1,2] = 1;\n",
    "    \n",
    "    A[2,3] = sigmoid(global_x[1]);\n",
    "    A[2,5] = sigmoid(global_x[2]);\n",
    "    A[2,3] = A[2,3] * (1.0/(A[2,3] + A[2,5]))\n",
    "    A[2,5] = A[2,5] * (1.0/(A[2,3] + A[2,5]))\n",
    "    \n",
    "    A[3,2] = sigmoid(x[1]);\n",
    "    A[3,4] = sigmoid(x[2]);\n",
    "    A[3,6] = sigmoid(x[3]);\n",
    "    A[3,2] = A[3,2] * (1.0/(A[3,2] + A[3,4] + A[3,6]))\n",
    "    A[3,4] = A[3,4] * (1.0/(A[3,2] + A[3,4] + A[3,6]))\n",
    "    A[3,6] = A[3,6] * (1.0/(A[3,2] + A[3,4] + A[3,6]))\n",
    "    \n",
    "    A[4,3] = 1; #if A mail reaches B(3), mail returns to station 2 with 100% probability.\n",
    "    \n",
    "    A[5,2] = sigmoid(global_x[6]);\n",
    "    A[5,6] = sigmoid(global_x[7]);\n",
    "    A[5,2] = A[5,2] * (1.0/(A[5,2] + A[5,6]))\n",
    "    A[5,6] = A[5,6] * (1.0/(A[5,2] + A[5,6]))\n",
    "    \n",
    "    A[6,3] = sigmoid(global_x[8]);\n",
    "    A[6,5] = sigmoid(global_x[9]);\n",
    "    A[6,7] = sigmoid(global_x[10]);\n",
    "    A[6,3] = A[6,3] * (1.0/(A[6,3] + A[6,5] + A[6,7]))\n",
    "    A[6,5] = A[6,5] * (1.0/(A[6,3] + A[6,5] + A[6,7]))\n",
    "    A[6,7] = A[6,7] * (1.0/(A[6,3] + A[6,5] + A[6,7]))\n",
    "    \n",
    "    A[7,8] = 1;\n",
    "\n",
    "    C = connect_matrix_2D();\n",
    "    B = connect_matrix_B();\n",
    "    loss = 0.0\n",
    "    for i = 1:100\n",
    "        H = initialize_H(NMail,tM);\n",
    "        for it = 1:tM+1\n",
    "            H = next_step_k(H,it,C,L,numA,conn_matA,conn_matB);\n",
    "        end\n",
    "        if(count(x->x==7, H[:,end]) == 0)\n",
    "            loss += 2\n",
    "        else\n",
    "            loss += 1.0/(count(x->x==7, H[:,end]))\n",
    "        end\n",
    "    end\n",
    "    return loss\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "fd695f52",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-12-09T14:38:16.799000+08:00",
     "start_time": "2021-12-09T06:35:16.319Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "fitness_function_node_5 (generic function with 1 method)"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function fitness_function_node_5(x)\n",
    "    A = zeros(Float64,8,8);\n",
    "    A[1,2] = 1;\n",
    "    \n",
    "    A[2,3] = sigmoid(global_x[1]);\n",
    "    A[2,5] = sigmoid(global_x[2]);\n",
    "    A[2,3] = A[2,3] * (1.0/(A[2,3] + A[2,5]))\n",
    "    A[2,5] = A[2,5] * (1.0/(A[2,3] + A[2,5]))\n",
    "    \n",
    "    A[3,2] = sigmoid(global_x[3]);\n",
    "    A[3,4] = sigmoid(global_x[4]);\n",
    "    A[3,6] = sigmoid(global_x[5]);\n",
    "    A[3,2] = A[3,2] * (1.0/(A[3,2] + A[3,4] + A[3,6]))\n",
    "    A[3,4] = A[3,4] * (1.0/(A[3,2] + A[3,4] + A[3,6]))\n",
    "    A[3,6] = A[3,6] * (1.0/(A[3,2] + A[3,4] + A[3,6]))\n",
    "    \n",
    "    A[4,3] = 1; #if A mail reaches B(3), mail returns to station 2 with 100% probability.\n",
    "    \n",
    "    A[5,2] = sigmoid(x[1]);\n",
    "    A[5,6] = sigmoid(x[2]);\n",
    "    A[5,2] = A[5,2] * (1.0/(A[5,2] + A[5,6]))\n",
    "    A[5,6] = A[5,6] * (1.0/(A[5,2] + A[5,6]))\n",
    "    \n",
    "    A[6,3] = sigmoid(global_x[8]);\n",
    "    A[6,5] = sigmoid(global_x[9]);\n",
    "    A[6,7] = sigmoid(global_x[10]);\n",
    "    A[6,3] = A[6,3] * (1.0/(A[6,3] + A[6,5] + A[6,7]))\n",
    "    A[6,5] = A[6,5] * (1.0/(A[6,3] + A[6,5] + A[6,7]))\n",
    "    A[6,7] = A[6,7] * (1.0/(A[6,3] + A[6,5] + A[6,7]))\n",
    "    \n",
    "    A[7,8] = 1;\n",
    "\n",
    "    C = connect_matrix_2D();\n",
    "    B = connect_matrix_B();\n",
    "    loss = 0.0\n",
    "    for i = 1:100\n",
    "        H = initialize_H(NMail,tM);\n",
    "        for it = 1:tM+1\n",
    "            H = next_step_k(H,it,C,L,numA,conn_matA,conn_matB);\n",
    "        end\n",
    "        if(count(x->x==7, H[:,end]) == 0)\n",
    "            loss += 2\n",
    "        else\n",
    "            loss += 1.0/(count(x->x==7, H[:,end]))\n",
    "        end\n",
    "    end\n",
    "    return loss\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "49243925",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-12-09T14:38:17.039000+08:00",
     "start_time": "2021-12-09T06:35:16.324Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "fitness_function_node_6 (generic function with 1 method)"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function fitness_function_node_6(x)\n",
    "    A = zeros(Float64,8,8);\n",
    "    A[1,2] = 1;\n",
    "    \n",
    "    A[2,3] = sigmoid(global_x[1]);\n",
    "    A[2,5] = sigmoid(global_x[2]);\n",
    "    A[2,3] = A[2,3] * (1.0/(A[2,3] + A[2,5]))\n",
    "    A[2,5] = A[2,5] * (1.0/(A[2,3] + A[2,5]))\n",
    "    \n",
    "    A[3,2] = sigmoid(global_x[3]);\n",
    "    A[3,4] = sigmoid(global_x[4]);\n",
    "    A[3,6] = sigmoid(global_x[5]);\n",
    "    A[3,2] = A[3,2] * (1.0/(A[3,2] + A[3,4] + A[3,6]))\n",
    "    A[3,4] = A[3,4] * (1.0/(A[3,2] + A[3,4] + A[3,6]))\n",
    "    A[3,6] = A[3,6] * (1.0/(A[3,2] + A[3,4] + A[3,6]))\n",
    "    \n",
    "    A[4,3] = 1; #if A mail reaches B(3), mail returns to station 2 with 100% probability.\n",
    "    \n",
    "    A[5,2] = sigmoid(global_x[6]);\n",
    "    A[5,6] = sigmoid(global_x[7]);\n",
    "    A[5,2] = A[5,2] * (1.0/(A[5,2] + A[5,6]))\n",
    "    A[5,6] = A[5,6] * (1.0/(A[5,2] + A[5,6]))\n",
    "    \n",
    "    A[6,3] = sigmoid(x[1]);\n",
    "    A[6,5] = sigmoid(x[2]);\n",
    "    A[6,7] = sigmoid(x[3]);\n",
    "    A[6,3] = A[6,3] * (1.0/(A[6,3] + A[6,5] + A[6,7]))\n",
    "    A[6,5] = A[6,5] * (1.0/(A[6,3] + A[6,5] + A[6,7]))\n",
    "    A[6,7] = A[6,7] * (1.0/(A[6,3] + A[6,5] + A[6,7]))\n",
    "    \n",
    "    A[7,8] = 1;\n",
    "\n",
    "    C = connect_matrix_2D();\n",
    "    B = connect_matrix_B();\n",
    "    loss = 0.0\n",
    "    for i = 1:100\n",
    "        H = initialize_H(NMail,tM);\n",
    "        for it = 1:tM+1\n",
    "            H = next_step_k(H,it,C,L,numA,conn_matA,conn_matB);\n",
    "        end\n",
    "        if(count(x->x==7, H[:,end]) == 0)\n",
    "            loss += 2\n",
    "        else\n",
    "            loss += 1.0/(count(x->x==7, H[:,end]))\n",
    "        end\n",
    "    end\n",
    "    return loss\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e7ea5482",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Testing Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "f9f2dc3f",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-12-09T14:38:17.252000+08:00",
     "start_time": "2021-12-09T06:35:16.332Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "test_function_2 (generic function with 1 method)"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function test_function_2()\n",
    "    A = zeros(Float64,8,8);\n",
    "    A[1,2] = 1;\n",
    "    \n",
    "    A[2,3] = sigmoid(global_x[1]);\n",
    "    A[2,5] = sigmoid(global_x[2]);\n",
    "    A[2,3] = A[2,3] * (1.0/(A[2,3] + A[2,5]))\n",
    "    A[2,5] = A[2,5] * (1.0/(A[2,3] + A[2,5]))\n",
    "    \n",
    "    A[3,2] = sigmoid(global_x[3]);\n",
    "    A[3,4] = sigmoid(global_x[4]);\n",
    "    A[3,6] = sigmoid(global_x[5]);\n",
    "    A[3,2] = A[3,2] * (1.0/(A[3,2] + A[3,4] + A[3,6]))\n",
    "    A[3,4] = A[3,4] * (1.0/(A[3,2] + A[3,4] + A[3,6]))\n",
    "    A[3,6] = A[3,6] * (1.0/(A[3,2] + A[3,4] + A[3,6]))\n",
    "    \n",
    "    A[4,3] = 1; #if A mail reaches B(3), mail returns to station 2 with 100% probability.\n",
    "    \n",
    "    A[5,2] = sigmoid(global_x[6]);\n",
    "    A[5,6] = sigmoid(global_x[7]);\n",
    "    A[5,2] = A[5,2] * (1.0/(A[5,2] + A[5,6]))\n",
    "    A[5,6] = A[5,6] * (1.0/(A[5,2] + A[5,6]))\n",
    "    \n",
    "    A[6,3] = sigmoid(global_x[8]);\n",
    "    A[6,5] = sigmoid(global_x[9]);\n",
    "    A[6,7] = sigmoid(global_x[10]);\n",
    "    A[6,3] = A[6,3] * (1.0/(A[6,3] + A[6,5] + A[6,7]))\n",
    "    A[6,5] = A[6,5] * (1.0/(A[6,3] + A[6,5] + A[6,7]))\n",
    "    A[6,7] = A[6,7] * (1.0/(A[6,3] + A[6,5] + A[6,7]))\n",
    "    \n",
    "    A[7,8] = 1;\n",
    "\n",
    "    C = connect_matrix_2D();\n",
    "    B = connect_matrix_B();\n",
    "    loss = 0.0\n",
    "    for i = 1:100\n",
    "        H = initialize_H(NMail,tM);\n",
    "        for it = 1:tM+1\n",
    "            H = next_step_k(H,it,C,L,numA,conn_matA,conn_matB);\n",
    "        end\n",
    "        if(count(x->x==7, H[:,end]) == 0)\n",
    "            loss += 2\n",
    "        else\n",
    "            loss += 1.0/(count(x->x==7, H[:,end]))\n",
    "        end\n",
    "    end\n",
    "    return loss\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "6bd7063e",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-12-09T14:38:17.464000+08:00",
     "start_time": "2021-12-09T06:35:16.338Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "test_function_3 (generic function with 1 method)"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function test_function_3(x)\n",
    "    A = zeros(Float64,8,8);\n",
    "    A[1,2] = 1;\n",
    "    A[2,3] = x[1];\n",
    "    A[2,5] = x[2];\n",
    "    A[3,2] = x[3];\n",
    "    A[3,4] = x[4];\n",
    "    A[3,6] = x[5];\n",
    "    A[4,3] = 1; #if A mail reaches B(3), mail returns to station 2 with 100% probability.\n",
    "    A[5,2] = x[6];\n",
    "    A[5,6] = x[7];\n",
    "    A[6,3] = x[8];\n",
    "    A[6,5] = x[9];\n",
    "    A[6,7] = x[10];\n",
    "    A[7,8] = 1;\n",
    "\n",
    "    C = connect_matrix_2D();\n",
    "    B = connect_matrix_B();\n",
    "    loss = 0.0\n",
    "    for i = 1:100\n",
    "        H = initialize_H(NMail,tM);\n",
    "        for it = 1:tM+1\n",
    "            H = next_step_k(H,it,C,L,numA,conn_matA,conn_matB);\n",
    "        end\n",
    "        if(count(x->x==7, H[:,end]) == 0)\n",
    "            loss += 2\n",
    "        else\n",
    "            loss += 1.0/(count(x->x==7, H[:,end]))\n",
    "        end\n",
    "    end\n",
    "    return loss\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "c1c74e10",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-12-09T14:38:17.746000+08:00",
     "start_time": "2021-12-09T06:35:16.342Z"
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "individual_test (generic function with 1 method)"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function individual_test()\n",
    "    A = zeros(Float64,8,8);\n",
    "    A[1,2] = 1;\n",
    "    \n",
    "    A[2,3] = sigmoid(global_x[1]);\n",
    "    A[2,5] = sigmoid(global_x[2]);\n",
    "    A[2,3] = A[2,3] * (1.0/(A[2,3] + A[2,5]))\n",
    "    A[2,5] = A[2,5] * (1.0/(A[2,3] + A[2,5]))\n",
    "    \n",
    "    A[3,2] = sigmoid(global_x[3]);\n",
    "    A[3,4] = sigmoid(global_x[4]);\n",
    "    A[3,6] = sigmoid(global_x[5]);\n",
    "    A[3,2] = A[3,2] * (1.0/(A[3,2] + A[3,4] + A[3,6]))\n",
    "    A[3,4] = A[3,4] * (1.0/(A[3,2] + A[3,4] + A[3,6]))\n",
    "    A[3,6] = A[3,6] * (1.0/(A[3,2] + A[3,4] + A[3,6]))\n",
    "    \n",
    "    A[4,3] = 1; #if A mail reaches B(3), mail returns to station 2 with 100% probability.\n",
    "    \n",
    "    A[5,2] = sigmoid(global_x[6]);\n",
    "    A[5,6] = sigmoid(global_x[7]);\n",
    "    A[5,2] = A[5,2] * (1.0/(A[5,2] + A[5,6]))\n",
    "    A[5,6] = A[5,6] * (1.0/(A[5,2] + A[5,6]))\n",
    "    \n",
    "    A[6,3] = sigmoid(global_x[8]);\n",
    "    A[6,5] = sigmoid(global_x[9]);\n",
    "    A[6,7] = sigmoid(global_x[10]);\n",
    "    A[6,3] = A[6,3] * (1.0/(A[6,3] + A[6,5] + A[6,7]))\n",
    "    A[6,5] = A[6,5] * (1.0/(A[6,3] + A[6,5] + A[6,7]))\n",
    "    A[6,7] = A[6,7] * (1.0/(A[6,3] + A[6,5] + A[6,7]))\n",
    "    \n",
    "    A[7,8] = 1;\n",
    "\n",
    "    C = connect_matrix_2D();\n",
    "    B = connect_matrix_B();\n",
    "    H = initialize_H(NMail,tM);\n",
    "    for it = 1:tM+1\n",
    "        H = next_step_k(H,it,C,L,numA,conn_matA,conn_matB);\n",
    "    end\n",
    "    return H\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e82e506",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Optimization Algorithm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "ea3aa677",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-12-09T14:41:29.049000+08:00",
     "start_time": "2021-12-09T06:35:16.348Z"
    }
   },
   "outputs": [],
   "source": [
    "for i = 1:50\n",
    "    node = rand([2,3,5,6])\n",
    "    if(node == 2)\n",
    "        result = Optim.optimize(fitness_function_node_2, global_x[1:2], SimulatedAnnealing(), Optim.Options(iterations=100))\n",
    "        global_x[1:2] = Optim.minimizer(result)\n",
    "    elseif(node == 3)\n",
    "        result = Optim.optimize(fitness_function_node_3, global_x[3:5], SimulatedAnnealing(), Optim.Options(iterations=100))\n",
    "        global_x[3:5] = Optim.minimizer(result)\n",
    "    elseif(node == 5)\n",
    "        result = Optim.optimize(fitness_function_node_5, global_x[6:7], SimulatedAnnealing(), Optim.Options(iterations=100))\n",
    "        global_x[6:7] = Optim.minimizer(result)\n",
    "    else\n",
    "        result = Optim.optimize(fitness_function_node_6, global_x[8:10], SimulatedAnnealing(), Optim.Options(iterations=100))\n",
    "        global_x[8:10] = Optim.minimizer(result)\n",
    "    end\n",
    "    \n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "57ccad40",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Verification of Results and Comparison with Base Case"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd7834eb",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Predicted Model Loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "420e6e48",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-12-09T14:42:12.785000+08:00",
     "start_time": "2021-12-09T06:42:12.733Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20.471428571428582"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_function_2()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "53ff2f48",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Base Model Loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "id": "01bcc4b7",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-12-09T14:42:25.744000+08:00",
     "start_time": "2021-12-09T06:42:25.713Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "40.53730158730162"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_function_3([0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "74c4eb67",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### History Matrix, H of our Predicted Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "id": "36815b8f",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-12-09T14:50:17.292000+08:00",
     "start_time": "2021-12-09T06:50:17.259Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10×32 Matrix{Int16}:\n",
       " 0  0  0  0  0  0  0  0  0  0  0  0  0  …  0  0  0  0  0  0  0  1  1  1  1  1\n",
       " 0  0  0  0  0  0  0  0  0  0  0  0  0     3  3  3  3  3  3  3  3  3  3  3  3\n",
       " 0  0  0  0  0  0  0  0  0  0  0  1  4     4  4  4  1  1  1  2  2  2  2  2  2\n",
       " 0  0  0  0  0  1  4  5  6  7  7  7  7     7  7  7  7  7  7  7  7  7  7  7  7\n",
       " 0  0  0  0  0  0  0  0  0  0  0  0  0     1  1  2  2  2  5  5  5  5  5  5  5\n",
       " 0  1  2  3  7  7  7  7  7  7  7  7  7  …  7  7  7  7  7  7  7  7  7  7  7  7\n",
       " 0  0  0  0  0  0  0  0  0  1  2  3  7     7  7  7  7  7  7  7  7  7  7  7  7\n",
       " 0  0  0  0  0  0  0  0  0  0  0  0  0     2  5  5  5  4  4  4  4  4  4  4  4\n",
       " 0  0  0  1  2  3  7  7  7  7  7  7  7     7  7  7  7  7  7  7  7  7  7  7  7\n",
       " 0  0  0  0  0  0  0  1  4  4  5  6  5     6  6  6  6  6  6  6  6  6  6  6  6"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "individual_test()"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Julia 1.7.0",
   "language": "julia",
   "name": "julia-1.7"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.7.0"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}