4. Types for Agents.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4. Types for agents"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We are getting towards our goal of putting everything together to make a model of people moving around and interacting with one another. Most people start off susceptible, but when an infectious person meets a susceptible the infection is transmitted with a certain probability"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will make an **individual-based model**, also called an **agent-based model**. We need a `struct` called `Agent` that contains whatever information an agent needs. In our case we will need a position and an infection status.\n",
    "\n",
    "The position will behave almost like a normal random walk that we have seen before, while the infection status needs to reflect whether the agent is susceptible (S), infectious (I) or recovered / removed (R)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Enums"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We could represent the infection status simply using an integer, e.g. 0, 1 or 2. \n",
    "But then our code will be hard to read, since we will be comparing the infection status to numbers all the time without remembering which one is which.\n",
    "\n",
    "Rather we would prefer to have the symbols `S`, `I` and `R`. \n",
    "We could just define global constants for these, but there is a better alternative: an `Enum`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`Enum` is short for \"*enum*erated type\". We want a new *type*, `InfectionStatus`, with possible values `S`, `I` and `R`. \n",
    "    We can achieve this as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@enum InfectionStatus S=1 I R   # specify that `S` corresponds to the value 1 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "I"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see that I is an object of type `InfectionStatus`, which has the value 2, in the sense that we can convert it to an integer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "status = I\n",
    "Int(status)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can check the status with"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if status == I\n",
    "    println(\"infected!\")\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In our application the integer values corresponding to each state are arbitrary, but in other applications you may want to give meaning to the numerical values."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Agent type: Inheritance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How can we create an `Agent` type for an agent that lives in 2D? Perhaps the simplest way is as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "struct SimpleAgent1\n",
    "    x::Int\n",
    "    y::Int\n",
    "    status::InfectionStatus\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Note that in Julia you cannot redefine a `struct` to have different fields in the same session. We will make several versions so we are just adding a number to each one.]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Write a method of `move` for `SimpleAgent1`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The problem with this is that we have duplicated codfe: `move` for `SimpleAgent1` looks identical to the one for `Walker2D`. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One way to reduce duplication is using a form of **inheritance**, by making both types **subtypes** of a common type. The subtype relation is written `X <: Y` (read \"`X` is a subtype of `Y`\"). The common type is an **abstract type**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "abstract type AbstractWalker2D end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "struct SimpleWalker2D <: AbstractWalker2D\n",
    "    x::Int64\n",
    "    y::Int64\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "struct SimpleAgent2 <: AbstractWalker2D\n",
    "    x::Int64\n",
    "    y::Int64\n",
    "    status::InfectionStatus\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since these two types share common fields, we can write the `move` method just *once*, giving the abstract type as the type annotation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. How can you create an object of type `SimpleAgent2`?\n",
    "\n",
    "\n",
    "2. Can you extend the `move` function such that it works for both `SimpleWalker2D` and `SimpleAgent2`?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Composition"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An alternative method, which [is usually more powerful and general](https://en.wikipedia.org/wiki/Composition_over_inheritance), is to use **composition**, i.e. placing one object *inside* another:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "struct Agent1\n",
    "    position::SimpleWalker2D\n",
    "    status::InfectionStatus\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "At first glance this may look a little strange, since we seem to be saying that an agent contains a walker. But really it is just a way to maintain the data inside its pacakge and be able to reuse the infrastructure that we have already built up for that type."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise\n",
    "\n",
    "1. How can you construct an object of type `Agent1`?\n",
    "\n",
    "\n",
    "2. How would you extend `move` for `Agent1`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Parametrised types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, now suppose we want to have agents that live in 1D or 2D, or on a network etc. Currently we would have to make different types `Agent2D`, `Agent1D`, ... that look almost identical.\n",
    "\n",
    "We have already seen a few times that whenever we observe **code duplication** like this, it's a hint that there is a possible **abstraction**. \n",
    "Basically we want to be able to say \"an agent has some kind of position, and an infection status\".\n",
    "\n",
    "We could write this as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "struct Agent2\n",
    "    position\n",
    "    status::InfectionStatus\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "with no type annotation on `position`. However, it turns out that this is *very bad for performance* in Julia.\n",
    "\n",
    "> Never define a composite type with untyped or abstractly-typed fields. \n",
    "\n",
    "[Unless you really know what you are doing, or don't care at all about performance.]\n",
    "\n",
    "To get high performance we need to always allow Julia to be able to work out the types of everything."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The correct solution is to use a **parametrised type**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "struct Agent3{P}\n",
    "    position::P\n",
    "    status::InfectionStatus\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, `P` is a **type parameter**. You can think of it as a special kind of variable that holds a type. Julia will work out what this type should be, based on the kind of object you supply for the `position` field."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*If* there is a common abstract type `AbstractWalker` for all of the possible types that we want to be able to use for `P`, then we can instead write"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "struct Agent4{P <: AbstractWalker}\n",
    "    position::P\n",
    "    status::InfectionStatus\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This *restricts* the allowed types that can be used for `P`, which is often desirable. However, it may exclude other possible types, for example `Int`, which cannot be made into a subtype of `AbstractWalker`. \n",
    "In this case the previous, unrestricted version may be better.\n",
    "\n",
    "[You can also use `Union` to specify different allowed types.]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise\n",
    "\n",
    "1. Construct objects of type `Agent3` with different types for `P`. Hint: You *don't need* to explicitly tell Julia the type parameter &ndash; it should be worked out automatically!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "@webio": {
   "lastCommId": null,
   "lastKernelId": null
  },
  "kernelspec": {
   "display_name": "Julia 1.4.2",
   "language": "julia",
   "name": "julia-1.4"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.4.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}