TempNet_01_classes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Temporal Networks v1.0 #\n",
    "\n",
    "**Original code by** Mathieu Génois\n",
    "\n",
    "**Contact:** genois.mathieu@gmail.com\n",
    "\n",
    "**Adapted in Python3 by** Thomas Robiglio\n",
    "\n",
    "**Contact:** robigliothomas@gmail.com\n",
    "\n",
    "## Presentation ##\n",
    "\n",
    "Temporal Networks is a python library aiming at providing tools for the analysis of temporal networks. It relies only on the usual random library, the scientific numpy library, and the plotting library matplotlib.\n",
    "\n",
    "Some functions returns networkx objects, and some plotting functions require the library graph-tools (see https://git.skewed.de/count0/graph-tool/wikis/installation-instructions#debian-ubuntu).\n",
    "\n",
    "The library is including by calling:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import RandTempNet as tn"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Classes ##\n",
    "\n",
    "This library defines four different representations of temporal networks. This representations, as well as the classes used to build them, are accessible in the `classes` module.\n",
    "\n",
    "### `link(i,j)` ###\n",
    "The `link()` class is the basic element of this library. It represents an undirected link between two nodes `i` and `j` in the temporal network. Node values can only be integers. Node values are initialized when a `link()` object is created:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from RandTempNet.classes import link\n",
    "\n",
    "a = link(0, 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Node values can be accessed using the attributes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1\n"
     ]
    }
   ],
   "source": [
    "print(a.i, a.j)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By definition, the `i` attribute contains the lowest node value, the `j` attribute contains the highest node value:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1\n"
     ]
    }
   ],
   "source": [
    "a = link(1, 0)\n",
    "print(a.i, a.j)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The whole link can be returned using the `display()` method, which returns a tuple with node values ordered in increasing order:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0, 1)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.display()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`link()` objects can be compared, and the comparison follows the rule for undirected links:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = link(0, 1)\n",
    "b = link(0, 2)\n",
    "c = link(1, 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a == b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a == c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, `link()` objects are hashable and can thus be used as entries for a dictionary for example.\n",
    "### `event(t,i,j)` ###\n",
    "An `event()` object is a `link()` object with a `time` attribute `t`, indicating when the event starts. It is used to represent an *instantaneous event*. The `time` attribute can only be an integer. The nodes `i` and `j` and the `time` attribute `t` of an `event()` object are assigned when the object is created:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "from RandTempNet.classes import event\n",
    "\n",
    "a = event(1, 2, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The time value can be recovered using the `time` attribute:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.time"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It can be changed directly:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.time = 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The link can be recovered using the `display()` method of the `link()` object:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 3)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.link.display()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "or using the `i` and `j` attributes of the `link()` object:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 3\n"
     ]
    }
   ],
   "source": [
    "print(a.link.i, a.link.j)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `link` attribute can be updated using the `change_link(i,j)` method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.change_link(2, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `event()` object can be returned using the `out()` method as a tuple `(t,link(i,j))`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5, <RandTempNet.classes.link at 0x7fab9899f130>)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.out()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `event()` object can be displayed using the `display()` method as a triplet `(t,i,j)`, using the same standard as for the link in the node ordering:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5, 2, 3)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.display()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As for `link()` objects, `event()` objects can be compared:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = event(1, 2, 4)\n",
    "b = event(1, 4, 2)\n",
    "a == b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "event(1, 2, 4) == event(2, 3, 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, `event()` objects are hashable and can thus be used as entries for a dictionary for example.\n",
    "### `contact(t,tau)` ###\n",
    "A `contact()` object is a `time` `t` and a `duration` `tau`, indicating when a contact starts and how long it lasts. It is used to represent an *event with duration*. The value of the `time` and `duration` attributes can only be integers. They are assigned when the object is created:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "from RandTempNet.classes import contact\n",
    "\n",
    "a = contact(1, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The time and duration values can be recovered using the `time` and `duration` attributes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2\n"
     ]
    }
   ],
   "source": [
    "print(a.time, a.duration)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "They can be changed directly:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.time = 5\n",
    "a.duration = 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `contact()` object can be displayed using the `display()` method as a triplet `(t,i,j)`, using the same standard as for the link in the node ordering:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5, 5)"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.display()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As for `link()` objects, `contact()` objects can be compared:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "contact(1, 2) == contact(1, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "contact(1, 2) == contact(2, 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, `contact()` objects are hashable and can thus be used as entries for a dictionary for example.\n",
    "### `snapshot(list_link)` ###\n",
    "A `snapshot()` object is a network of links. It has a `list_link` attribute which is the set of `link()` objects that are active. As the `list_link` is a set, it ensures the unicity of the links. The `list_link` is assigned directly when the `snapshot()` object is created:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "from RandTempNet.classes import snapshot\n",
    "\n",
    "a = snapshot([link(0, 1), link(2, 3), link(0, 2), link(1, 2)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One link can be added to the `snapshot()` object using the `add_link(i,j)` method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.add_link(0, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Multiple links can be added using the `add_links(list_link)` method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.add_links([(0, 3), (3, 4), (2, 4)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One link can be removed using the `del_link(i,j)` method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.del_link(0, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Multiple links can be removed using the `del_links(list_link)` method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.del_links([(0, 3), (3, 4), (2, 4)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `out()` method returns the list of `link()` objects:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{<RandTempNet.classes.link at 0x7faba88d27c0>,\n",
       " <RandTempNet.classes.link at 0x7faba88d8130>,\n",
       " <RandTempNet.classes.link at 0x7faba88d8490>,\n",
       " <RandTempNet.classes.link at 0x7faba88d87f0>}"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.out()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `display()` method returns the snapshot as a list of tuples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(0, 1), (2, 3), (0, 2), (1, 2)]"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.display()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `tij()` ###\n",
    "The `tij()` class is one of the four representations for temporal networks used in this library. It simply lists events. It is mainly used for data input and output. A `tij()` object is created empty:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "from RandTempNet.classes import tij\n",
    "\n",
    "a = tij()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An event can be added using the `add_event(t,i,j)` method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.add_event(4, 5, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An event can be removed using the `del_event(t,i,j)` method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.del_event(4, 5, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This can be also done in bunch using lists:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.add_events([(2, 3, 2), (1, 4, 1)])\n",
    "a.del_events([(2, 3, 2), (1, 4, 1)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `out()` method returns the list of events sorted by time:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<RandTempNet.classes.event at 0x7faba88ef4f0>,\n",
       " <RandTempNet.classes.event at 0x7faba88ef430>]"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.add_events([(2, 3, 2), (1, 4, 1)])\n",
    "a.out()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `display()` method returns the list of triplets `(t,i,j)` sorted by time:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(1, 1, 4), (2, 2, 3)]"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.display()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `tijtau()` ###\n",
    "The `tijtau()` class is one of the four representations for temporal networks used in this library. It simply lists contacts. It consists in a dictionary of durations `tau`, with events `(t,i,j)` used as keys. It is mainly used for data input and output. A `tijtau()` object is created empty:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "from RandTempNet.classes import tijtau\n",
    "\n",
    "a = tijtau()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A contact can be added using the `add_contact(t,i,j,tau)` method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.add_contact(4, 5, 2, 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A contact can be removed using the `del_contact(t,i,j)` method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.del_contact(4, 5, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This can be also done in bunch using lists:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.add_contacts([(2, 3, 2, 1), (1, 4, 1, 3)])\n",
    "a.del_contacts([(2, 3, 2), (1, 4, 1)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `out()` method returns the list of contacts sorted by time:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(<RandTempNet.classes.event at 0x7faba88f52b0>, 3),\n",
       " (<RandTempNet.classes.event at 0x7faba88f51f0>, 1)]"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.add_contacts([(2, 3, 2, 1), (1, 4, 1, 3)])\n",
    "a.out()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `display()` method returns the list of quadruplets `(t,i,j,tau)` sorted by time:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(1, 1, 4, 3), (2, 2, 3, 1)]"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.display()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `snapshot_sequence(t_i,t_f,dt)` ###\n",
    "The `snapshot_sequence()` class is one of the four representations for temporal networks used in this library. It consists in a dictionary of `snapshot()` objects, with time stamps as keys. A `snapshot_sequence()` object is created empty, between an initial time `t_i` and a final time `t_f`. It contains `(t_f - t_i)/dt` snapshots, where `dt` is the duration of a time step. The time stamp of the last snapshot is `t_f - dt`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "from RandTempNet.classes import snapshot_sequence\n",
    "\n",
    "a = snapshot_sequence(0, 10, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The dictionary of snapshots can assigned and accessed via the `data` attribute."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0: <RandTempNet.classes.snapshot at 0x7faba88f59a0>,\n",
       " 2: <RandTempNet.classes.snapshot at 0x7faba88f5d90>,\n",
       " 4: <RandTempNet.classes.snapshot at 0x7faba88f5400>,\n",
       " 6: <RandTempNet.classes.snapshot at 0x7faba88f5190>,\n",
       " 8: <RandTempNet.classes.snapshot at 0x7faba88f5940>}"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A snapshot can be updated using the `update_snapshot(t,list_link)` method using its time value `t` and a list of `link()` objects `list_link`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.update_snapshot(8, [link(4, 5), link(3, 6), link(1, 4)])\n",
    "a.update_snapshot(4, [link(4, 2), link(1, 2), link(1, 4)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A snapshot can be cleared using the `clear_snapshot(t)` method and its time stamp value `t`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.clear_snapshot(8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `out()` method returns a list of tuples, each tuple being constituted of a time stamp and a list of `link()` objects:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(0, []),\n",
       " (2, []),\n",
       " (4,\n",
       "  [<RandTempNet.classes.link at 0x7faba88f5490>,\n",
       "   <RandTempNet.classes.link at 0x7faba88e23d0>,\n",
       "   <RandTempNet.classes.link at 0x7faba88e2370>]),\n",
       " (6, []),\n",
       " (8, [])]"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.out()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `display()` method returns a list of tuples, each tuple being constituted of a time stamp and a list of tuples `(i,j)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(0, []), (2, []), (4, [(2, 4), (1, 2), (1, 4)]), (6, []), (8, [])]"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.display()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `link_timeline(list_lk=[],list_tl=[])` ###\n",
    "The `link_timeline()` class is one of the four representations for temporal networks used in this library. It consists in a dictionary with `link()` objects as keys and sets of `contact()` objects as values. A `link_timeline()` object can be created empty or with an initial list of `link()` objects. In the second case, the list of contact timelines can also be specified."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "from RandTempNet.classes import link_timeline\n",
    "\n",
    "lks_data = link_timeline()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "lks_data = link_timeline([(0, 1), (0, 2), (1, 3)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "lks_data = link_timeline(\n",
    "    [(0, 1), (0, 2), (1, 3)], [[(0, 1), (3, 2)], [], [(0, 3), (5, 1), (7, 3)]]\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The data contained in the `link_timeline()` object can be accessed using the `data` attribute:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{<RandTempNet.classes.link at 0x7faba88e2160>: {<RandTempNet.classes.contact at 0x7faba88e2790>,\n",
       "  <RandTempNet.classes.contact at 0x7faba88e2c70>},\n",
       " <RandTempNet.classes.link at 0x7faba88e25b0>: set(),\n",
       " <RandTempNet.classes.link at 0x7faba88e2fd0>: {<RandTempNet.classes.contact at 0x7faba88e2b20>,\n",
       "  <RandTempNet.classes.contact at 0x7faba88e2e50>,\n",
       "  <RandTempNet.classes.contact at 0x7faba88e2f70>}}"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lks_data.data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The list of links can be directly accessed using the `links()` method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<RandTempNet.classes.link at 0x7faba88e2160>,\n",
       " <RandTempNet.classes.link at 0x7faba88e25b0>,\n",
       " <RandTempNet.classes.link at 0x7faba88e2fd0>]"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lks_data.links()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It can be displayed using the `links_display()` method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(0, 1), (0, 2), (1, 3)]"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lks_data.links_display()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A link can be added to the `link_timeline()` object by using the `add_link(i,j,timeline=[])` method, where the `timeline` argument is optional:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "lks_data.add_link(0, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "lks_data.add_link(0, 3, [(1, 4), (8, 6)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A link can be removed using the `del_link(i,j)` method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "lks_data.del_link(0, 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Links can be added in bunch, with an optional list of associated timelines:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "lks_data.add_links([(0, 1), (0, 2), (1, 3)])\n",
    "lks_data.add_links(\n",
    "    [(0, 1), (0, 2), (1, 3)], [[(0, 1), (3, 2)], [], [(0, 3), (5, 1), (7, 3)]]\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Links can also be remove in bunch:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "lks_data.del_links([(0, 1), (0, 2), (1, 3)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Timeline are set using the `add_link` and `add_links` methods. For example, a timeline can be cleared using the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "lks_data.add_link(0, 2, [])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A contact can be added to a timeline using the `add_contact(i,j,t,tau)` method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "lks_data.add_contact(0, 2, 1, 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A time of activation can be removed using the `del_contact(i,j,t,tau)` method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "lks_data.del_contact(0, 2, 1, 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `out()` method returns a list of tuples where the first element is a `link()` object and the second a list of contacts ordered in time:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(<RandTempNet.classes.link at 0x7faba88c48b0>,\n",
       "  [<RandTempNet.classes.contact at 0x7faba88c4970>,\n",
       "   <RandTempNet.classes.contact at 0x7faba88c49d0>]),\n",
       " (<RandTempNet.classes.link at 0x7faba88c4940>, []),\n",
       " (<RandTempNet.classes.link at 0x7faba88c4a60>,\n",
       "  [<RandTempNet.classes.contact at 0x7faba88c4af0>,\n",
       "   <RandTempNet.classes.contact at 0x7faba88c4b50>,\n",
       "   <RandTempNet.classes.contact at 0x7faba88c4bb0>])]"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lks_data.add_links(\n",
    "    [(0, 1), (0, 2), (1, 3)], [[(0, 1), (3, 2)], [], [(0, 3), (5, 1), (7, 3)]]\n",
    ")\n",
    "lks_data.out()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `display()` method returns a list of tuples where the first element is a `(i,j)` tuple and the second a list of tuples `(t,tau)` ordered in time:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[((0, 1), [(0, 1), (3, 2)]), ((0, 2), []), ((1, 3), [(0, 3), (5, 1), (7, 3)])]"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lks_data.display()"
   ]
  }
 ],
 "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.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}