X1_Random_Walks.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 19 - Simulating Random Walks in Networks\n",
    "\n",
    "*September 20 2022*  \n",
    "\n",
    "In the first unit we explore random walks, a simple yet powerful stochastic model for diffusion processes in networks. Random walk processes are not only important as a model for diffusion. Their stationary distribution can also be used to define centrality measures based on the eigenvectors of the transition matrix. As we shall see in the subsequent course \"Machine Learning for Complex Networks\", random walks (and more generally Markov chains) are also a powerful and widely applied framework for statistical learning in networks, with applications in node ranking, link prediction, representation learning, and graph clustering."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "    <script charset=\"utf-8\">\n",
       "    // Load via requireJS if available (jupyter notebook environment)\n",
       "    try {\n",
       "    require.config({\n",
       "    paths: {\n",
       "    d3: \"https://d3js.org/d3.v5.min.js\".replace(\".js\", \"\")\n",
       "    }\n",
       "    });\n",
       "    console.log(\"OKAY: requireJS was detected\");\n",
       "    }\n",
       "    catch(err){\n",
       "    console.log(err);\n",
       "    console.log(\"ERROR: NO requireJS was detected\");\n",
       "    };\n",
       "    require(['d3'], function(d3){\n",
       "    console.log(\"OKAY: d3js was detected\");\n",
       "    });\n",
       "    </script>\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import pathpy as pp\n",
    "import numpy as np\n",
    "\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.style.use('default')\n",
    "sns.set_style(\"whitegrid\")\n",
    "    \n",
    "from numpy import linalg as npl\n",
    "import scipy as sp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Computing Transition matrices\n",
    "\n",
    "We first write a function that computes a (row- or right-stochastic) transition matrix of a random walk process for a given network. The method should work for weighted, unweighted, directed, and undirected networks represented by a `pathpy.Network` object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def transition_matrix(network, weight=True):\n",
    "    A = network.adjacency_matrix(weight=weight)\n",
    "    D = A.sum(axis=1)\n",
    "    T = sp.sparse.csr_matrix((network.number_of_nodes(), network.number_of_nodes()))\n",
    "    for i in range(network.number_of_nodes()):\n",
    "        T[i,:] = A[i,:]/D[i]\n",
    "    return T.todense()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>\n",
       "#pp_container {\n",
       "  padding: 5px 0 10px 0;\n",
       "  margin: auto;\n",
       "}\n",
       "\n",
       "#controls {\n",
       "  width: 100%;\n",
       "  float: right;\n",
       "  margin-bottom: 5px;\n",
       "}\n",
       "\n",
       "\n",
       ".control {\n",
       "    display:inline-block;\n",
       "  padding: 5px 6px 5px 6px;\n",
       "}\n",
       "\n",
       "/* Button  */\n",
       ".control button {\n",
       "    background-color: #6cc6d9; /* Green */\n",
       "    border: none;\n",
       "    color: white;\n",
       "    padding: 5px 10px;\n",
       "    margin: 0px 2px 0px 2px;\n",
       "    border-radius: 4px;\n",
       "    text-align: center;\n",
       "    text-decoration: none;\n",
       "    display: inline-block;\n",
       "    font-size: 16px;\n",
       "    -webkit-transition-duration: 0.4s; /* Safari */\n",
       "    transition-duration: 0.4s;\n",
       "}\n",
       "\n",
       ".control button:hover {\n",
       "    background-color: #555; /* Gray */\n",
       "  color: white;\n",
       "}\n",
       "\n",
       ".control button.active {\n",
       "  color: white;\n",
       "  background: #555;\n",
       "}\n",
       "\n",
       ".pp_vl {\n",
       "  border-left: 3px solid #808080;\n",
       "  height: 30px;\n",
       "}\n",
       "\n",
       "\n",
       "p.search_title {\n",
       "  display: inline;\n",
       "  text-align: left;\n",
       "  font-weight: normal;\n",
       "  color: #777;\n",
       "}\n",
       "\n",
       "#pp_search {\n",
       "      padding: 5px 10px;\n",
       "}\n",
       "\n",
       "#pp_search_form #search {\n",
       "    margin-left: 0px;\n",
       "}\n",
       "\n",
       "\n",
       ".arrow {\n",
       "    fill: #555;\n",
       "    stroke: #555;\n",
       "    stroke-width: 0px;\n",
       "    stroke-opacity: .3;\n",
       "}\n",
       "\n",
       ".edge {\n",
       "    fill: none;\n",
       "    stroke: #555;\n",
       "    stroke-width: 1.5px;\n",
       "    stroke-opacity: .3;\n",
       "}\n",
       "\n",
       ".nlabel{\n",
       "    pointer-events: none;\n",
       "}\n",
       "\n",
       ".node {\n",
       "    fill: #99ccff;\n",
       "    stroke: #fff;\n",
       "    stroke-width: 1.0px;\n",
       "    stroke-opacity: 1;\n",
       "}\n",
       "\n",
       ".node_highlight {\n",
       "    stroke: #555;\n",
       "    stroke-width: 4.0px;        /\n",
       "}\n",
       "\n",
       ".node_search {\n",
       "    /* fill: #F38630; Not working yet*/\n",
       "    stroke: #555;\n",
       "    stroke-width: 4.0px;\n",
       "}\n",
       "\n",
       "\n",
       ".edge_active {\n",
       "  fill:none;\n",
       "  stroke: #555;\n",
       "  stroke-width: 2px;\n",
       "  stroke-opacity: 1;\n",
       "}\n",
       "\n",
       "\n",
       ".edge_highlight {\n",
       "  stroke: #555;\n",
       "  stroke-width: 4px;\n",
       "  stroke-opacity: 1;\n",
       "}\n",
       "\n",
       "\n",
       ".tooltip {\n",
       "  position: absolute;\n",
       "  top: 100px;\n",
       "  left: 100px;\n",
       "  -moz-border-radius:5px;\n",
       "  border-radius: 5px;\n",
       "  border: 2px solid #000;\n",
       "  background: #fff;\n",
       "  opacity: .9;\n",
       "  color: black;\n",
       "  padding: 10px;\n",
       "  width: 300px;\n",
       "  font-size: 12px;\n",
       "  z-index: 10;\n",
       "}\n",
       "\n",
       ".tooltip p.main {\n",
       "  font-size: 15px;\n",
       "  text-align: center;\n",
       "  padding:0;\n",
       "  margin:0;\n",
       "}\n",
       "\n",
       "hr.tooltip-hr {\n",
       "  padding:1px 0 0 0;\n",
       "  margin:3px 0 3px 0;\n",
       "}\n",
       "\n",
       "#pp_slider_label {\n",
       "    font-size: 12px;\n",
       "}\n",
       "\n",
       ".ticks {\n",
       "    font-size: 10px;\n",
       "}\n",
       "\n",
       ".track,\n",
       ".track-inset,\n",
       ".track-overlay {\n",
       "    stroke-linecap: round;\n",
       "}\n",
       "\n",
       ".track {\n",
       "    stroke: #000;\n",
       "    stroke-opacity: 0.3;\n",
       "    stroke-width: 10px;\n",
       "}\n",
       "\n",
       ".track-past {\n",
       "    stroke: #ffa500;\n",
       "    stroke-width: 8px;\n",
       "    stroke-opacity: 0.2;\n",
       "    stroke-linecap: round;\n",
       "}\n",
       "\n",
       ".track-future {\n",
       "    stroke: #008000;\n",
       "    stroke-width: 8px;\n",
       "    stroke-opacity: 0.2;\n",
       "    stroke-linecap: round;\n",
       "\n",
       "}\n",
       "\n",
       ".track-aggregation {\n",
       "    stroke: #ff0000;\n",
       "    stroke-width: 8px;\n",
       "    stroke-opacity: 0.3;\n",
       "    stroke-linecap: round;\n",
       "\n",
       "}\n",
       "\n",
       ".track-inset {\n",
       "    stroke: #dcdcdc;\n",
       "    stroke-width: 8px;\n",
       "}\n",
       "\n",
       ".track-overlay {\n",
       "    pointer-events: stroke;\n",
       "    stroke-width: 50px;\n",
       "    stroke: transparent;\n",
       "    cursor: crosshair;\n",
       "}\n",
       "\n",
       ".handle {\n",
       "    fill: #fff;\n",
       "    stroke: #000;\n",
       "    stroke-opacity: 0.5;\n",
       "    stroke-width: 1.25px;\n",
       "}\n",
       "\n",
       "</style>\n",
       "<div id=\"x0b7f8e0c7a5e4aa8a771abcfeff275e4\"></div>\n",
       "<div id=\"x58b8b1ad05884c36b9918aa9940b7327\"></div>\n",
       "<script charset=\"utf-8\">\n",
       "\n",
       " var d3 = require(\"d3\");\n",
       "\n",
       " var config = {\"width\": 800.0, \"height\": 550.0, \"unit\": \"px\", \"dpi\": 96, \"margin\": null, \"layout\": \"force\", \"temporal\": false, \"coordinates\": false, \"euclidean\": false, \"min_max_node_size\": null, \"min_max_edge_size\": null, \"keep_aspect_ratio\": true, \"forceCharge\": -20, \"forceRepel\": -300, \"forceAlpha\": 0.1, \"restartAlpha\": 1, \"alphaMin\": 0.001, \"targetAlpha\": 0, \"chargeDistance\": 800, \"repelDistance\": 200, \"velocityDecay\": 0.4, \"lookoutStrokeWidth\": 1, \"lookoutOpacity\": 0.5, \"lookoutWeight\": 0.0, \"radiusMinSize\": 4, \"radiusMaxSize\": 16, \"nodeTransitionDuration\": 100, \"defaultEdgeWeight\": 1, \"targetAlphaDragStarted\": 0.3, \"targetAlphaDragEnd\": 0.0, \"linkStrengthMin\": 0.0, \"linkStrengthMax\": 0.45, \"template\": null, \"css\": null, \"backend\": [\"tikz\"], \"fileformat\": [\"tex\"], \"latex_class_options\": \"\", \"interactiv\": {\"backend\": [\"d3js\"], \"fileformat\": [\"html\"]}, \"animation\": {\"enabled\": false, \"start\": null, \"end\": null, \"steps\": 20, \"speed\": 100, \"unit\": \"seconds\"}, \"label\": {\"centered\": true, \"enabled\": true, \"color\": \"white\"}, \"label_centered\": true, \"label_enabled\": true, \"label_color\": \"white\", \"curved\": true, \"directed\": true, \"widgets\": {\"tooltip\": {\"enabled\": false, \"size\": \"100px\"}, \"save\": {\"title\": \"Save\", \"enabled\": true, \"tooltip\": \"Save the network as [svg] or [png].\"}, \"zoom\": {\"title\": \"Zoom\", \"enabled\": true, \"tooltip\": \"Zoom-in with [+] <br> zoom-out with [-] <br> or reset zoom with [Reset]. <br> Furthermore, with [Shift+mouse wheel] you can also zoom.\"}, \"filter\": {\"title\": \"Filter\", \"enabled\": false, \"tooltip\": \"Filter the nodes base on given groups.\", \"groups\": [\"all\"]}, \"search\": {\"title\": \"Search\", \"enabled\": true, \"tooltip\": \"Search for a node in the network.\"}, \"layout\": {\"title\": \"Layout\", \"enabled\": false, \"tooltip\": \"Change the layout of the Network. Per default a [Force] directed layout is used. If x and y coordinates are given, an [Coord] layout can be used.\"}, \"animation\": {\"title\": \"Animation\", \"enabled\": true, \"tooltip\": \"Play and pause animation of the temproal network.\"}, \"aggregation\": {\"title\": \"Aggregation\", \"enabled\": true, \"tooltip\": \"Aggregate time steps.\", \"past\": 2, \"future\": 2, \"aggregation\": 1}}, \"default_node\": {\"size\": 15.0, \"color\": \"CornflowerBlue\", \"opacity\": 0.2, \"id_as_label\": true, \"coordinates\": null}, \"default_edge\": {\"size\": 2.0, \"color\": \"black\", \"opacity\": 1, \"directed\": true, \"curved\": 0.5}}\n",
       "\n",
       " var data = {\"nodes\": [{\"uid\": \"a\", \"size\": 15.0, \"color\": \"CornflowerBlue\", \"opacity\": 0.2, \"id_as_label\": true}, {\"uid\": \"b\", \"size\": 15.0, \"color\": \"CornflowerBlue\", \"opacity\": 0.2, \"id_as_label\": true}, {\"uid\": \"c\", \"size\": 15.0, \"color\": \"CornflowerBlue\", \"opacity\": 0.2, \"id_as_label\": true}], \"links\": [{\"uid\": \"0x7ffcb8cf66d0\", \"size\": 2.0, \"color\": \"black\", \"opacity\": 1, \"source\": \"a\", \"target\": \"b\", \"directed\": true, \"curved\": 0.5}, {\"uid\": \"0x7ffc283d6340\", \"size\": 2.0, \"color\": \"black\", \"opacity\": 1, \"source\": \"a\", \"target\": \"c\", \"directed\": true, \"curved\": 0.5}, {\"uid\": \"0x7ffc283d6310\", \"size\": 2.0, \"color\": \"black\", \"opacity\": 1, \"source\": \"b\", \"target\": \"c\", \"directed\": true, \"curved\": 0.5}, {\"uid\": \"0x7ffc283d6970\", \"size\": 2.0, \"color\": \"black\", \"opacity\": 1, \"source\": \"b\", \"target\": \"a\", \"directed\": true, \"curved\": 0.5}, {\"uid\": \"0x7ffcb88c5cd0\", \"size\": 2.0, \"color\": \"black\", \"opacity\": 1, \"source\": \"c\", \"target\": \"a\", \"directed\": true, \"curved\": 0.5}]}\n",
       "\n",
       " function tooltip(tooltipId, width){\n",
       "   // Local variable to hold tooltip div for\n",
       "   // manipulation in other functions.\n",
       "   var tt = d3.select('body')\n",
       "              .append('div')\n",
       "              .attr('class', 'tooltip')\n",
       "              .attr('id', tooltipId)\n",
       "              .style('pointer-events', 'none');\n",
       "\n",
       "   // Set a width if it is provided.\n",
       "   if (width) {\n",
       "     tt.style('width', width);\n",
       "   }\n",
       "\n",
       "   // Initially it is hidden.\n",
       "   hideTooltip();\n",
       "\n",
       "   /*\n",
       "    * Display tooltip with provided content.\n",
       "    * content is expected to be HTML string.\n",
       "    * event is d3.event for positioning.\n",
       "    */\n",
       "   function showTooltip(content, event) {\n",
       "     tt.style('opacity', 1.0)\n",
       "       .html(content);\n",
       "\n",
       "     updatePosition(event);\n",
       "   }\n",
       "\n",
       "   /*\n",
       "    * Hide the tooltip div.\n",
       "    */\n",
       "   function hideTooltip() {\n",
       "     tt.style('opacity', 0.0);\n",
       "   }\n",
       "\n",
       "   /*\n",
       "    * Figure out where to place the tooltip\n",
       "    * based on d3 mouse event.\n",
       "    */\n",
       "   function updatePosition(event) {\n",
       "     var xOffset = 20;\n",
       "     var yOffset = 10;\n",
       "\n",
       "     var ttw = tt.style('width');\n",
       "     var tth = tt.style('height');\n",
       "\n",
       "     var wscrY = window.scrollY;\n",
       "     var wscrX = window.scrollX;\n",
       "\n",
       "     var curX = (document.all) ? event.clientX + wscrX : event.pageX;\n",
       "     var curY = (document.all) ? event.clientY + wscrY : event.pageY;\n",
       "     var ttleft = ((curX - wscrX + xOffset * 2 + ttw) > window.innerWidth) ?\n",
       "                  curX - ttw - xOffset * 2 : curX + xOffset;\n",
       "\n",
       "     if (ttleft < wscrX + xOffset) {\n",
       "       ttleft = wscrX + xOffset;\n",
       "     }\n",
       "\n",
       "     var tttop = ((curY - wscrY + yOffset * 2 + tth) > window.innerHeight) ?\n",
       "                 curY - tth - yOffset * 2 : curY + yOffset;\n",
       "\n",
       "     if (tttop < wscrY + yOffset) {\n",
       "       tttop = curY + yOffset;\n",
       "     }\n",
       "\n",
       "     tt\n",
       "       .style('top', tttop + 'px')\n",
       "       .style('left', ttleft + 'px');\n",
       "   }\n",
       "\n",
       "   if (config.widgets.tooltip.enabled === true){\n",
       "     return {\n",
       "       showTooltip: showTooltip,\n",
       "       hideTooltip: hideTooltip,\n",
       "       updatePosition: updatePosition\n",
       "     };\n",
       "   } else {\n",
       "     return {\n",
       "       showTooltip: hideTooltip,\n",
       "       hideTooltip: hideTooltip,\n",
       "       updatePosition: updatePosition\n",
       "     };\n",
       "   };\n",
       " };\n",
       " /*\n",
       "  * network\n",
       "  */\n",
       " function network(config){\n",
       "\n",
       "   // Constants for sizing\n",
       "   var width = config.width || 400;\n",
       "   var height = config.height || 400;\n",
       "   var temporal = config.temporal || false;\n",
       "   var tooltipSize = config.widgets.tooltip.size || '100px';\n",
       "\n",
       "   var forceCharge = config.forceCharge || -30;//-20; // -30\n",
       "   var forceRepel = config.forceRepel || -100;//-200; // -100\n",
       "   var forceAlpha = config.forceAlpha || 0.1;//0.0; // 0.1\n",
       "   var restartAlpha = config.restartAlpha || 1\n",
       "   var chargeDistance = config.chargeDistance || 200;//400; //200\n",
       "   var repelDistance = config.repelDistance || 200;//100; //200\n",
       "   var velocityDecay = config.velocityDecay || .2;\n",
       "   var alphaMin = config.alphaMin || 0.001;\n",
       "   var targetAlpha = config.targetAlpha || 0.2;\n",
       "   var targetAlphaDragStarted = config.targetAlphaDragStarted || 0.3;\n",
       "   var targetAlphaDragEnd = config.targetAlphaDragEnd || 0.0;\n",
       "\n",
       "   var linkStrengthMin = config.linkStrengthMin || 0.0;\n",
       "   var linkStrengthMax = config.linkStrengthMax || .45;\n",
       "   var defaultEdgeWeight = config.defaultEdgeWeight || 1;\n",
       "\n",
       "   var nodeTransitionDuration= config.nodeTransitionDuration || 100;\n",
       "\n",
       "   /* var labelCentered = config.label.centered || false;\n",
       "    * var labelEnabled = config.label.enabled || false;\n",
       "    * var labelColor = config.label.color || '#fff'; */\n",
       "\n",
       "   var labelCentered = config.label_centered || false;\n",
       "   var labelEnabled = config.label_enabled || false;\n",
       "   var labelColor = config.label_color || '#fff';\n",
       "\n",
       "   var curved = config.curved || false;\n",
       "   var directed = config.directed || false;\n",
       "\n",
       "   var lookoutStrokeWidth = config.lookoutStrokeWidth || 1;\n",
       "   var lookoutOpacity = config.lookoutOpacity || .5;\n",
       "   var lookoutWeight = config.lookoutWeight || 0.0;\n",
       "   var lookoutColor = config.lookoutColor || 'gray';\n",
       "\n",
       "   var radiusMinSize = config.radiusMinSize || 4;\n",
       "   var radiusMaxSize = config.radiusMaxSize || 16;\n",
       "   // variables to refect the current settings\n",
       "   // of the visualization\n",
       "   var layout = config.layout || 'force';\n",
       "   var filter = 'all';\n",
       "   var time = {past:0,time:0,aggregated:0,future:0};\n",
       "\n",
       "   // 'global' variables for the network\n",
       "   // these will be populated in the setup\n",
       "   // of the network\n",
       "   var svg = null;\n",
       "   var nodes = null;\n",
       "   var nodeLabels = null;\n",
       "   var edges = null;\n",
       "   var allData = {};\n",
       "   var linkedByIndex = {};\n",
       "   var showEdges = true;\n",
       "   var chargePower = 0.04;\n",
       "\n",
       "   var countExtent = null;\n",
       "   // colors for nodes\n",
       "   // var colorScheme = d3.scaleOrdinal(d3.schemeCategory20);\n",
       "\n",
       "   // tooltip for mouseover functionality\n",
       "   // implemented in tooltip.js\n",
       "   var myTooltip = tooltip('network-tooltip', tooltipSize);\n",
       "\n",
       "\n",
       "\n",
       "\n",
       "\n",
       "   /*\n",
       "    * Charge function used to set the strength of\n",
       "    * the many-body force.\n",
       "    * Charge is negative because we want nodes to repel\n",
       "    */\n",
       "   function charge(d) {\n",
       "     return -20;//-Math.pow(d.radius, 2.0) * chargePower;\n",
       "   }\n",
       "\n",
       "   /*\n",
       "    * Callback executed after ever tick of the simulation\n",
       "    */\n",
       "   function ticked() {\n",
       "\n",
       "     /* text.attr(\"x\", function(d) { return d.x; })\n",
       "      *     .attr(\"y\", function(d) { return d.y; }); */\n",
       "\n",
       "     nodeLabels.attr(\"transform\", function(d) {\n",
       "       return \"translate(\" + d.x + \",\" + d.y + \")\";\n",
       "     });\n",
       "     /* nodes\n",
       "      *   .attr('cx', function (d) { return d.x; })\n",
       "      *   .attr('cy', function (d) { return d.y; }); */\n",
       "\n",
       "\n",
       "     nodes.attr(\"transform\", function(d) { return \"translate(\" + d.x + \",\" + d.y + \")\"; });\n",
       "     edges.attr(\"d\", function(d) {\n",
       "       var dx = d.target.x - d.source.x,\n",
       "           dy = d.target.y - d.source.y,\n",
       "           dr = Math.sqrt(dx * dx + dy * dy);\n",
       "       if(!curved)dr=0;\n",
       "       return \"M\" +\n",
       "              d.source.x + \",\" +\n",
       "              d.source.y + \"A\" +\n",
       "              dr + \",\" + dr + \" 0 0,1 \" +\n",
       "              d.target.x + \",\" +\n",
       "              d.target.y;\n",
       "     });\n",
       "\n",
       "     // recalculate and back off the distance\n",
       "     edges.attr(\"d\", function (d, i) {\n",
       "       var pl = this.getTotalLength();\n",
       "       //this is the magic\n",
       "       var r = d.target.size; // Multiply the marker size (3) with the size of the edge (d.size) because the markers are scaling with the edge which they are attached to!!\n",
       "       var m = this.getPointAtLength(pl - r);\n",
       "       var dx = d.target.x - d.source.x,\n",
       "           dy = d.target.y - d.source.y,\n",
       "           dr = Math.sqrt(dx * dx + dy * dy);\n",
       "       if(!curved)dr=0;\n",
       "       var result = \"M\" + d.source.x + \",\" + d.source.y + \"A\" + dr + \",\" + dr + \" 0 0,1 \" + m.x + \",\" + m.y;\n",
       "       return result;\n",
       "     });\n",
       "\n",
       "\n",
       "\n",
       "\n",
       "   }\n",
       "\n",
       "   function ended() {\n",
       "     showEdges = true;\n",
       "     ticked();\n",
       "   }\n",
       "\n",
       "   // function transform(d) {\n",
       "   //   return \"translate(\" + d.x + \",\" + d.y + \")\";\n",
       "   // }\n",
       "\n",
       "   // Functions to enable draging of the nodes\n",
       "   // see https://observablehq.com/@d3/force-directed-graph\n",
       "   function dragstarted(d) {\n",
       "     if (!d3.event.active) simulation.alphaTarget(targetAlphaDragStarted).restart();\n",
       "     d.fx = d.x;\n",
       "     d.fy = d.y;\n",
       "   }\n",
       "\n",
       "   function dragged(d) {\n",
       "     d.fx = d3.event.x;\n",
       "     d.fy = d3.event.y;\n",
       "   }\n",
       "\n",
       "   function dragended(d) {\n",
       "     if (!d3.event.active) simulation.alphaTarget(targetAlphaDragEnd);\n",
       "     d.fx = null;\n",
       "     d.fy = null;\n",
       "   }\n",
       "\n",
       "   var drag = d3.drag()\n",
       "                .on(\"start\", dragstarted)\n",
       "                .on(\"drag\", dragged)\n",
       "                .on(\"end\", dragended);\n",
       "\n",
       "\n",
       "   //Zoom functions which transforms the element of the graph\n",
       "   function zoomed(){\n",
       "     svg.selectAll('g').attr(\"transform\", d3.event.transform);\n",
       "   }\n",
       "\n",
       "   //Zoom functions with key combination\n",
       "   function zoomedWithKey(){\n",
       "     // works only with pressed alt key\n",
       "     if (d3.event.sourceEvent.shiftKey == false) return;\n",
       "     svg.selectAll('g').attr(\"transform\", d3.event.transform);\n",
       "   }\n",
       "\n",
       "   // function to zoom in and out\n",
       "   function transition(zoomLevel) {\n",
       "     svg.transition()\n",
       "        .delay(10)\n",
       "        .duration(700)\n",
       "        .call(zoom.scaleBy, zoomLevel);\n",
       "   }\n",
       "\n",
       "   // Zoom options\n",
       "   var zoom = d3.zoom()\n",
       "                .scaleExtent([1/2, 4])\n",
       "                .extent([[0, 0], [width, height]])\n",
       "                .on(\"zoom\", zoomed);\n",
       "\n",
       "   // Function which returns the object color if defined\n",
       "   // otherwise a default value\n",
       "   function getColor(d){\n",
       "     if (typeof d.color === \"undefined\"){\n",
       "       return \"#99ccff\"\n",
       "     } else {\n",
       "       return d.color\n",
       "     }\n",
       "   }\n",
       "\n",
       "   // Function which returns the object text if defined\n",
       "   // otherwise a default value\n",
       "   function getText(d){\n",
       "     if (typeof d.text === \"undefined\"){\n",
       "       return \" \"\n",
       "     } else {\n",
       "       return d.text\n",
       "     }\n",
       "   }\n",
       "\n",
       "   // Function which returns the object weight if defined\n",
       "   // otherwise a default value\n",
       "   function getWeight(d){\n",
       "     if ((d.time >= time.past && d.time < time.time)||\n",
       "         (d.time > time.aggregated && d.time <= time.future)){\n",
       "       return lookoutWeight;\n",
       "     }else{\n",
       "       if (typeof d.weight === \"undefined\"){\n",
       "         return defaultEdgeWeight;\n",
       "       } else {\n",
       "         return d.weight\n",
       "       };\n",
       "     };\n",
       "   }\n",
       "\n",
       "   var linkStrengthScale = d3.scaleLinear()\n",
       "                             .range([linkStrengthMin, linkStrengthMax]);\n",
       "\n",
       "\n",
       "   // Function which returns the object weight if defined\n",
       "   // otherwise a default value\n",
       "   function getSize(d){\n",
       "     if (typeof d.size === \"undefined\"){\n",
       "       return 6\n",
       "     } else {\n",
       "       return d.size\n",
       "     }\n",
       "   }\n",
       "\n",
       "\n",
       "   // Function which returns the object weight if defined\n",
       "   // otherwise a default value\n",
       "   function getStrokeWidth(d){\n",
       "     if (typeof d.size === \"undefined\"){\n",
       "       return 1.5\n",
       "     } else {\n",
       "       return d.size\n",
       "     }\n",
       "   }\n",
       "\n",
       "   // Function which returns the object weight if defined\n",
       "   // otherwise a default value\n",
       "   function getOpacity(d){\n",
       "     if (typeof d.opacity === \"undefined\"){\n",
       "       return 1.\n",
       "     } else {\n",
       "       return d.opacity\n",
       "     }\n",
       "   }\n",
       "\n",
       "   // Function which returns the object name if defined\n",
       "   // otherwise a default value\n",
       "   function getName(d){\n",
       "     if (typeof d.label === \"undefined\"){\n",
       "       return d.uid\n",
       "     } else {\n",
       "       return d.label\n",
       "     }\n",
       "   }\n",
       "\n",
       "   /* function marker (color) {\n",
       "    *   var val;\n",
       "    *   svg.append(\"svg:defs\").selectAll(\"marker\")\n",
       "    *      .data([val])\n",
       "    *      .enter().append(\"svg:marker\")\n",
       "    *      .attr(\"id\", String)\n",
       "    *      .attr(\"viewBox\", \"0 -5 10 10\")\n",
       "    *      .attr(\"refX\", 20)\n",
       "    *      .attr(\"refY\", 0)\n",
       "    *      .attr(\"markerWidth\", 6)\n",
       "    *      .attr(\"markerHeight\", 6)\n",
       "    *      .attr(\"orient\", \"auto\")\n",
       "    *      .style(\"fill\", color)\n",
       "    *      .append(\"svg:path\")\n",
       "    *      .attr(\"d\", \"M0,-5L10,0L0,5\");\n",
       "    *   return \"url(#\" +val+ \")\";\n",
       "    * };\n",
       "\n",
       "    */\n",
       "   function marker (color) {\n",
       "     var reference;\n",
       "     svg.append(\"svg:defs\").selectAll(\"marker\")\n",
       "        .data([reference])\n",
       "        .enter().append(\"svg:marker\")\n",
       "        .attr(\"id\", String)\n",
       "        .attr(\"viewBox\", \"0 -5 10 10\")\n",
       "        .attr(\"refX\", 10)  // This sets how far back it sits, kinda\n",
       "        .attr(\"refY\", -0)\n",
       "        .attr(\"markerWidth\", 6)\n",
       "        .attr(\"markerHeight\", 6)\n",
       "        .attr(\"orient\", \"auto\")\n",
       "        .append(\"svg:path\")\n",
       "        .attr('class','arrow')\n",
       "        .attr(\"d\", \"M0,-5L10,0L0,5\")\n",
       "        .style('opacity',.7)\n",
       "        .style(\"fill\", 'gray');\n",
       "     return \"url(#\" + reference + \")\";\n",
       "   };\n",
       "\n",
       "\n",
       "\n",
       "   // Here we create a force layout\n",
       "   // It is just the 'simulation' and will have\n",
       "   // forces added to it later\n",
       "   var simulation = d3.forceSimulation()\n",
       "                      .velocityDecay(velocityDecay)\n",
       "                      .alphaMin(alphaMin)\n",
       "                      .on('tick', ticked)\n",
       "                      .on('end', ended);\n",
       "\n",
       "\n",
       "   // Simulation starts automatically,\n",
       "   // We don't want it to start until it has\n",
       "   // nodes so stop for now.\n",
       "   simulation.stop();\n",
       "\n",
       "   /*\n",
       "    * Entry point to create network.\n",
       "    * This function is returned by the\n",
       "    * enclosing function and will be what is\n",
       "    * executed when we have data to visualize.\n",
       "    */\n",
       "   var chart = function (selector, rawData) {\n",
       "     allData = setupData(rawData);\n",
       "\n",
       "     // create a SVG element inside the provided selector\n",
       "     // with desired size.\n",
       "     svg = d3.select(selector)\n",
       "             .append('svg')\n",
       "             .attr('width', width)\n",
       "             .attr('height', height)\n",
       "             .call(d3.zoom()\n",
       "                     .scaleExtent([1/2, 4])\n",
       "                     .extent([[0, 0], [width, height]])\n",
       "                     .on(\"zoom\", zoomedWithKey));\n",
       "\n",
       "     // add some groups for edges and nodes\n",
       "     svg.append('g')\n",
       "        .attr('class', 'edges');\n",
       "\n",
       "     svg.append('g')\n",
       "        .attr('class', 'nodes');\n",
       "\n",
       "     svg.append('g')\n",
       "        .attr('class', 'labels');\n",
       "\n",
       "     /* Per-type markers, as they don't inherit styles.\n",
       "      * svg.append(\"defs\").append(\"marker\")\n",
       "      *    .attr(\"id\", \"arrowhead\")\n",
       "      *    .attr(\"viewBox\", \"0 -5 10 10\")\n",
       "      *    .attr(\"refX\", 17)\n",
       "      *    .attr(\"refY\", -0)\n",
       "      *    .attr(\"markerWidth\", 6)\n",
       "      *    .attr(\"markerHeight\", 6)\n",
       "      *    .attr(\"orient\", \"auto\")\n",
       "      *    .attr('xoverflow','visible')\n",
       "      *    .append(\"path\")\n",
       "      *    .attr(\"fill\", 'blue')\n",
       "      *    .attr(\"d\", \"M0,-5L10,0L0,5\")\n",
       "      *    .attr('fill', '#999')\n",
       "      *    .style('stroke','none'); */\n",
       "\n",
       "     /* build the arrow.\n",
       "      *         svg.append(\"svg:defs\").selectAll(\"marker\")\n",
       "      *    .data([\"end\"])      // Different link/path types can be defined here\n",
       "      *    .enter().append(\"svg:marker\")    // This section adds in the arrows\n",
       "      *    .attr(\"id\", String)\n",
       "      *    .attr(\"viewBox\", \"0 -5 10 10\")\n",
       "      *    .attr(\"refX\", 10)\n",
       "      *    .attr(\"refY\", -0)\n",
       "      *    .attr(\"markerWidth\", 6)\n",
       "      *    .attr(\"markerHeight\", 6)\n",
       "      *    .attr(\"orient\", \"auto\")\n",
       "      *    .append(\"svg:path\")\n",
       "      *    .attr('class','arrow')\n",
       "      *    .attr(\"d\", \"M0,-5L10,0L0,5\"); */\n",
       "\n",
       "\n",
       "     // render the network\n",
       "     render();\n",
       "   };\n",
       "\n",
       "\n",
       "   /*\n",
       "    * This function is executed any time the\n",
       "    * network is modified. It filters the nodes\n",
       "    * and edges based on the configuration of the\n",
       "    * controls, sets up the force simulation, and\n",
       "    * then restarts it to animate.\n",
       "    */\n",
       "   function render() {\n",
       "\n",
       "     // filter data to show based on current filter settings.\n",
       "     var filteredNodes = filterNodes(allData.nodes);\n",
       "     var consideredNodes = filteredNodes;\n",
       "\n",
       "     // if temporal network check if nodes change\n",
       "     if (temporal === true){\n",
       "       consideredNodes = updateTemporalNodes(\n",
       "         filteredNodes,allData.tnodes);\n",
       "     };\n",
       "\n",
       "     // filter edges based on given nodes\n",
       "     var filteredEdges = filterEdges(\n",
       "       allData.links, consideredNodes);\n",
       "     var considerdEdges = filteredEdges;\n",
       "\n",
       "     // if temporal network check for the correct edges\n",
       "     if (temporal === true){\n",
       "       activeEdges = activateTemporalEdges(filteredEdges,allData.tedges);\n",
       "       var updatedEdges = updateTemporalEdges(activeEdges,allData.tedges);\n",
       "       considerdEdges = filterTemporalEdges(updatedEdges);\n",
       "     };\n",
       "\n",
       "     // set the nodes of the simulation\n",
       "     simulation.nodes(consideredNodes);\n",
       "\n",
       "     // adjust the simulation based on\n",
       "     // if the layout is force directed or euclidean\n",
       "     if (layout === 'force') {\n",
       "       // use a force directed layout\n",
       "       setupNetworkLayout(considerdEdges);\n",
       "     } else if(layout === 'euclidean'){\n",
       "       // use an Euclidean layout\n",
       "       setupEuclideanLayout();\n",
       "     } else{\n",
       "       // pre default use a force directed layout\n",
       "       setupNetworkLayout(considerdEdges);\n",
       "     }\n",
       "\n",
       "     // render nodes and edges\n",
       "     renderNodes(consideredNodes);\n",
       "     renderNodeLabels(consideredNodes);\n",
       "     renderEdges(considerdEdges);\n",
       "\n",
       "     // render temporal edges if given\n",
       "     /* if (temporal === true){\n",
       "      *   renderTemporalEdges();\n",
       "      * }; */\n",
       "\n",
       "     // Now we need to set the alpha\n",
       "     // of the simulation when we restart.\n",
       "     simulation.alpha(restartAlpha).restart();\n",
       "   }\n",
       "\n",
       "   /*\n",
       "    * Sets up simulation with forces needed\n",
       "    * for regular force-directed layout.\n",
       "    * Now we add separate forces to the simulation,\n",
       "    * providing a name and a force function.\n",
       "    * Reusing a force name will override any\n",
       "    * existing force attached to it.\n",
       "    */\n",
       "   function setupNetworkLayout(edgesData) {\n",
       "     // now edges and how they impact\n",
       "     // the layout of the network is all\n",
       "     // handled in a link force\n",
       "     var linkForce = d3.forceLink()\n",
       "     //.id(function(d) { return d.uid; })\n",
       "                       .distance(50)\n",
       "     //.strength(function(d){return linkStrengthScale(getWeight(d));})\n",
       "                       .strength(function(d){return getWeight(d);})\n",
       "                       .links(edgesData);\n",
       "\n",
       "     // add the link force to the simulation\n",
       "     simulation.force('links', linkForce);\n",
       "     // setup a center force to keep nodes\n",
       "     // in middle of the div\n",
       "     simulation.force('center', d3.forceCenter(width / 2, height / 2));\n",
       "\n",
       "     // setup many body force to have nodes repel one another\n",
       "     // increasing the chargePower here to make nodes stand about\n",
       "     chargePower = 1.0;\n",
       "     simulation.force('charge', d3.forceManyBody()\n",
       "                                  .strength(forceCharge)\n",
       "                                  .distanceMax(chargeDistance));\n",
       "\n",
       "     simulation.force(\"repel\", d3.forceManyBody()\n",
       "                                 .strength(forceRepel)\n",
       "                                 .distanceMax(repelDistance));\n",
       "\n",
       "     // kill x and y forces used in radial layout\n",
       "     //simulation.force('x', null);\n",
       "     //simulation.force('y', null);\n",
       "\n",
       "     // setting taken from pathpy2\n",
       "     // TODO fix theses setting\n",
       "\n",
       "     // ingos setting\n",
       "     // simulation.force(\"charge\", d3.forceManyBody().strength(-20).distanceMax(400));\n",
       "     // simulation.force(\"repelForce\", d3.forceManyBody().strength(-200).distanceMax(100));\n",
       "     simulation.alphaTarget(forceAlpha);\n",
       "\n",
       "   }\n",
       "\n",
       "   /*\n",
       "    * Sets up simulation with forces needed\n",
       "    * for euclidian layout.\n",
       "    * Now we add separate forces to the simulation,\n",
       "    * providing a name and a force function.\n",
       "    * Reusing a force name will override any\n",
       "    * existing force attached to it.\n",
       "    */\n",
       "   function setupEuclideanLayout() {\n",
       "     // we don't want the center force\n",
       "     // or links force affecting the network\n",
       "     // in radial mode - so kill them.\n",
       "     simulation.force('center', null);\n",
       "     simulation.force('links', null);\n",
       "\n",
       "     // use many-body force to reduce node overlap\n",
       "     // in node clusters.\n",
       "     chargePower = 1.00;\n",
       "     simulation.force('charge', d3.forceManyBody().strength(forceCharge));\n",
       "\n",
       "     // generate a list for all x and y coordinates\n",
       "     var xs = [];\n",
       "     var ys = [];\n",
       "\n",
       "     // get the coordinates of the nodes\n",
       "     for (var key in allData.nodes) {\n",
       "       var value = allData.nodes[key];\n",
       "       xs.push(value.coordinates[0]);\n",
       "       ys.push(value.coordinates[1]);\n",
       "     }\n",
       "\n",
       "     // find the min and the max coordinate\n",
       "     var minX = d3.min(xs);\n",
       "     var maxX = d3.max(xs);\n",
       "     var minY = d3.min(ys);\n",
       "     var maxY = d3.max(ys);\n",
       "\n",
       "     // generate a scale function which allows to scale the node coordinate\n",
       "     // to a coodinate at the html canvas, thereby 10px border are considerd\n",
       "     var xScale = d3.scaleLinear()\n",
       "                    .domain([minX, maxX])\n",
       "                    .range([10,width-10]);\n",
       "\n",
       "     var yScale = d3.scaleLinear()\n",
       "                    .domain([minY, maxY])\n",
       "                    .range([10,height-10]);\n",
       "\n",
       "     // use the node coordinates to adjust x position of\n",
       "     // nodes with an x force\n",
       "     var xForce = d3.forceX()\n",
       "                    .strength(0.1)\n",
       "                    .x(function (d) { return xScale(d.coordinates[0]); });\n",
       "\n",
       "     // use the node coordinates to adjust y position of\n",
       "     // nodes with an y force\n",
       "     var yForce = d3.forceY()\n",
       "                    .strength(0.1)\n",
       "                    .y(function (d) { return yScale(d.coordinates[1]); });\n",
       "\n",
       "\n",
       "     // add these forces to the simulation\n",
       "     simulation.force('x', xForce);\n",
       "     simulation.force('y', yForce);\n",
       "   }\n",
       "\n",
       "   /*\n",
       "    * Filter down nodes based on controls configuration\n",
       "    */\n",
       "   function filterNodes(nodesData) {\n",
       "     var newNodesData = nodesData;\n",
       "\n",
       "     // if other option than all is used filter groups accordingly\n",
       "     if (filter !== 'all') {\n",
       "       var groups = nodesData.map(function (d) { return d.group; });\n",
       "       newNodesData = nodesData.filter(function (d) {\n",
       "         if (filter === d.group){\n",
       "           return d.group}\n",
       "       });\n",
       "     }\n",
       "\n",
       "     return newNodesData;\n",
       "   }\n",
       "\n",
       "   /*\n",
       "    * Filter down edges based on what nodes are\n",
       "    * currently present in the network.\n",
       "    */\n",
       "   function filterEdges(edgesData, nodesData) {\n",
       "     var nodesMap = d3.map(nodesData, function (d) { return d.uid; });\n",
       "\n",
       "     var newEdgesData = edgesData.filter(function (d) {\n",
       "       return nodesMap.get(d.source.uid) && nodesMap.get(d.target.uid);\n",
       "     });\n",
       "\n",
       "     return newEdgesData;\n",
       "   }\n",
       "\n",
       "   /*\n",
       "    * Update attributes of the temporal Nodes\n",
       "    */\n",
       "   function updateTemporalNodes(nodesData,changesData) {\n",
       "\n",
       "     // filter changes based on the current time step\n",
       "     var newChanges = changesData.filter(function (d) {\n",
       "       return (d.startTime === time.time || d.endTime === time.time);\n",
       "     });\n",
       "\n",
       "     var newUpdatedNodes = nodesData;\n",
       "\n",
       "     // iterate through the changes\n",
       "     newChanges.forEach(function (n){\n",
       "\n",
       "       // find the index of the changed node\n",
       "       var objIndex = newUpdatedNodes\n",
       "         .findIndex((obj => obj.uid == n.uid));\n",
       "       if (objIndex >= 0){\n",
       "         // update node\n",
       "         newUpdatedNodes[objIndex] = Object.assign(\n",
       "           newUpdatedNodes[objIndex],n);};\n",
       "     });\n",
       "\n",
       "     // return the updated nodes\n",
       "     return newUpdatedNodes;\n",
       "   };\n",
       "\n",
       "   /*\n",
       "    * Update attributes of the temporal Nodes\n",
       "    */\n",
       "   function activateTemporalEdges(edgesData,changesData) {\n",
       "\n",
       "     //console.log(time.time)\n",
       "     var dt = time.aggregated - time.time\n",
       "\n",
       "     var newActiveEdges = edgesData;\n",
       "\n",
       "     // iterate through the changes\n",
       "     newActiveEdges.forEach(function (e){e.activeEdge=false});\n",
       "\n",
       "     //filter changes based on the current time step\n",
       "     var newChanges = changesData.filter(function (d) {\n",
       "       return (((d.startTime <= time.time && time.time <= d.endTime)||\n",
       "                (d.startTime <= time.aggregated && time.aggregated <= d.endTime)||\n",
       "                (time.time < d.startTime && d.endTime <= time.aggregated))&&\n",
       "               d.active === true);\n",
       "     });\n",
       "\n",
       "\n",
       "     /* if ((d.time >= time.past && d.time < time.time)||\n",
       "      *     (d.time > time.aggregated && d.time <= time.future)){ */\n",
       "\n",
       "     // iterate through the changes\n",
       "     newChanges.forEach(function (e){\n",
       "\n",
       "       // find the index of the changed node\n",
       "       var objIndex = newActiveEdges\n",
       "         .findIndex((obj => obj.uid == e.uid));\n",
       "       if (objIndex >= 0){\n",
       "         newActiveEdges[objIndex].activeEdge=true;\n",
       "       };\n",
       "     });\n",
       "\n",
       "     //console.log(newChanges)\n",
       "     return newActiveEdges\n",
       "   };\n",
       "\n",
       "   /*\n",
       "    * Update attributes of the temporal Nodes\n",
       "    */\n",
       "   function updateTemporalEdges(edgesData,changesData) {\n",
       "\n",
       "     var newUpdatedEdges = edgesData;\n",
       "\n",
       "     //console.log(time.time)\n",
       "\n",
       "     //filter changes based on the current time step\n",
       "     var newChanges = changesData.filter(function (d) {\n",
       "       return (d.endTime === time.time || d.startTime === time.time);\n",
       "     });\n",
       "\n",
       "     // iterate through the changes\n",
       "     newChanges.forEach(function (e){\n",
       "\n",
       "       // find the index of the changed node\n",
       "       var objIndex = newUpdatedEdges\n",
       "         .findIndex((obj => obj.uid == e.uid));\n",
       "       if (objIndex >= 0){\n",
       "         // update node\n",
       "         newUpdatedEdges[objIndex] = Object.assign(\n",
       "           newUpdatedEdges[objIndex],e);\n",
       "       };\n",
       "     });\n",
       "\n",
       "\n",
       "     /* console.log('aggregated',time.aggregated)\n",
       "      * console.log('past',time.past) */\n",
       "     // iterate through the changes\n",
       "     /* newChanges.forEach(function (e){\n",
       "\n",
       "      *   // find the index of the changed node\n",
       "      *   var objIndex = newUpdatedEdges\n",
       "      *     .findIndex((obj => obj.uid == e.uid));\n",
       "      *   if (objIndex >= 0){\n",
       "      *     // update node\n",
       "      *     newUpdatedEdges[objIndex] = Object.assign(\n",
       "      *       newUpdatedEdges[objIndex],e);};\n",
       "      * });\n",
       "      */\n",
       "     //console.log(newUpdatedEdges)\n",
       "     // return the updated nodes\n",
       "     return newUpdatedEdges;\n",
       "   };\n",
       "\n",
       "   /*\n",
       "    * Filter down edges based on the time frame\n",
       "    */\n",
       "   function filterTemporalEdges(edgesData) {\n",
       "\n",
       "     /* var newTemporalEdgesData = edgesData.filter(function (d) {\n",
       "      *   return (d.time >= time.past && d.time <= time.future);\n",
       "      * }); */\n",
       "\n",
       "     var newTemporalEdgesData = edgesData.filter(function (d) {\n",
       "       return (d.activeEdge === true);\n",
       "     });\n",
       "\n",
       "     return newTemporalEdgesData;\n",
       "   };\n",
       "\n",
       "   /*\n",
       "    * This performs the enter / exit / merge\n",
       "    * d3 functionality for node data.\n",
       "    */\n",
       "   function renderNodes(nodesData) {\n",
       "     nodes = svg.select('.nodes').selectAll('.node')\n",
       "                .data(nodesData);\n",
       "\n",
       "     var nodesE = nodes.enter().append('circle')\n",
       "                       .attr(\"r\", 0)\n",
       "                       .classed('node', true)\n",
       "                       .classed('node_highlight',false)\n",
       "     //.classed('node_search',false)\n",
       "                       .attr('x', function (d) { return d.x; })\n",
       "                       .attr('y', function (d) { return d.y; })\n",
       "                       .on('mouseover', highlightNode)\n",
       "                       .on('mouseout', unhighlightNode)\n",
       "                       .call(drag);\n",
       "\n",
       "\n",
       "     nodeLabels = svg.select('.labels').selectAll('.label')\n",
       " \t             .data(nodesData);\n",
       "\n",
       "     var labelsE = nodeLabels.enter().append(\"text\")\n",
       "                             .classed('nlabel', true)\n",
       "                             .attr(\"dy\", \".35em\")\n",
       "                             .style(\"fill\",labelColor);\n",
       "\n",
       "     labelsE.attr(\"dx\", function(d) {return getSize(d);})\n",
       "            .text(function(d) { return '\\u2002'+getName(d); });\n",
       "\n",
       "     /*\n",
       "      * if(labelCentered)\n",
       "      *   labelsE.text(function(d) { return getName(d); })\n",
       " \t.style(\"text-anchor\", \"middle\");\n",
       "      * else\n",
       "      *   labelsE.attr(\"dx\", function(d) {return getSize(d);})\n",
       "      *          .text(function(d) { return '\\u2002'+getName(d); });\n",
       "\n",
       "      * if(!labelEnabled){\n",
       "      *   labelsE.style(\"opacity\", 0);\n",
       "      * }; */\n",
       "\n",
       "     nodeLabels.exit().remove();\n",
       "     nodes.exit()\n",
       "          .transition() // transition to shrink node\n",
       "          .attr(\"r\", 0)\n",
       "          .remove();\n",
       "\n",
       "     nodeLabels = nodeLabels.merge(labelsE);\n",
       "     nodes = nodes.merge(nodesE);\n",
       "     //nodes = nodes.merge(myText);\n",
       "     nodes.transition() // transition to change size and color\n",
       "          .duration(nodeTransitionDuration)\n",
       "          .attr('r', function (d) { return scaleRadius(d); })\n",
       "          .style('fill', function (d) { return getColor(d); })\n",
       "          .style(\"opacity\", 1);\n",
       "   }\n",
       "\n",
       "\n",
       "   function renderNodeLabels(nodesData) {\n",
       "\n",
       "     nodeLabels = svg.select('.nodes').selectAll('.nlabel')\n",
       " \t             .data(nodesData);\n",
       "\n",
       "     var labelsE = nodeLabels.enter().append(\"text\")\n",
       "                             .classed('nlabel', true)\n",
       "                             .attr(\"dy\", \".35em\")\n",
       "                             .style(\"fill\",labelColor);\n",
       "\n",
       "     if(labelCentered)\n",
       "       labelsE.text(function(d) { return getName(d); })\n",
       " \t      .style(\"text-anchor\", \"middle\");\n",
       "     else\n",
       "       labelsE.attr(\"dx\", function(d) {return getSize(d);})\n",
       "              .text(function(d) { return '\\u2002'+getName(d); });\n",
       "\n",
       "     if(!labelEnabled){\n",
       "       labelsE.style(\"opacity\", 0);\n",
       "     };\n",
       "\n",
       "     nodeLabels.exit().remove();\n",
       "\n",
       "     nodeLabels = nodeLabels.merge(labelsE);\n",
       "   }\n",
       "\n",
       "   /*\n",
       "    * This performs the enter / exit / merge\n",
       "    * d3 functionality for edge data.\n",
       "    */\n",
       "   function renderEdges(edgesData) {\n",
       "     edges = svg.select('.edges').selectAll('.edge')\n",
       "                .data(edgesData, function (d) { return d.uid; });\n",
       "\n",
       "\n",
       "     var edgesE = edges.enter().append('path')\n",
       "                       .classed('edge', true)\n",
       "                       .classed('edge_active', true)\n",
       "                       .classed('edge_highlight', false)\n",
       "                       .style('opacity', function (d) { return getOpacity(d); })\n",
       "                       .style('stroke-width', function (d) { return getStrokeWidth(d); })\n",
       "                       .style('stroke', function (d) { return getColor(d); })\n",
       "     if (directed){\n",
       "       edgesE.attr(\"marker-end\", function (d) { return marker(getColor(d)); });\n",
       "     };\n",
       "\n",
       "     edges.exit().remove();\n",
       "\n",
       "     edges = edges.merge(edgesE);\n",
       "\n",
       "     edges.transition() // transition to change size and color\n",
       "          .style('opacity', function (d) { return getOpacity(d); })\n",
       "          .style('stroke-width', function (d) { return getStrokeWidth(d); })\n",
       "          .style('stroke', function (d) { return getColor(d); });\n",
       "   }\n",
       "\n",
       "   /*\n",
       "    * Disable observed but not active edges\n",
       "    */\n",
       "   function renderTemporalEdges() {\n",
       "     edges.classed('edge_active',function(d){\n",
       "       if ((d.time >= time.past && d.time < time.time)||\n",
       "           (d.time > time.aggregated && d.time <= time.future)){\n",
       "         d3.select(this)\n",
       "           .style('stroke-width',lookoutStrokeWidth)\n",
       "         //.style('stroke',lookoutColor)\n",
       "           .style('opacity',lookoutOpacity);\n",
       "         return false;\n",
       "       }else{\n",
       "         d3.select(this)\n",
       "           .style('opacity', function (d) { return getOpacity(d); })\n",
       "           .style('stroke-width', function (d) { return getStrokeWidth(d); })\n",
       "           .style('stroke', function (d) { return getColor(d); });\n",
       "         return true;\n",
       "       }\n",
       "     });\n",
       "   };\n",
       "\n",
       "   function scaleRadius(n){\n",
       "     var radiusScale = d3.scaleLinear()\n",
       "                         .range([radiusMinSize, radiusMaxSize])\n",
       "                         .domain(countExtent);\n",
       "     /*      return radiusScale(getSize(n)); */\n",
       "     return getSize(n);\n",
       "   };\n",
       "\n",
       "   /*\n",
       "    * Called when data is updated,\n",
       "    * sets up scales to be appropriate for the\n",
       "    * currently selected data.\n",
       "    * Transforms node Id's to node objects for\n",
       "    * edge data.\n",
       "    */\n",
       "   function setupData(data) {\n",
       "\n",
       "     // get config values\n",
       "     // width = data.config.width\n",
       "     // height = data.config.height\n",
       "\n",
       "     // initialize circle radius scale\n",
       "     countExtent = d3.extent(data.nodes, function (d) { return getSize(d); });\n",
       "     // var radiusScale = d3.scalePow()\n",
       "     //     .exponent(0.5)\n",
       "     //     .range([3, 12])\n",
       "     //     .domain(countExtent);\n",
       "\n",
       "\n",
       "     data.nodes.forEach(function (n) {\n",
       "       // add radius to the node so we can use it later\n",
       "       n.radius = scaleRadius(n);\n",
       "     });\n",
       "\n",
       "     var nodesMap = d3.map(data.nodes, function (d) { return d.uid; });\n",
       "\n",
       "     // switch links to point to node objects instead of id's\n",
       "     data.links.forEach(function (l) {\n",
       "       l.source = nodesMap.get(l.source);\n",
       "       l.target = nodesMap.get(l.target);\n",
       "       //l.uid = l.source.uid + '_' + l.target.uid;\n",
       "\n",
       "       // linkedByIndex is used for link sorting\n",
       "       linkedByIndex[l.uid] = 1;\n",
       "     });\n",
       "\n",
       "     // get map for the edges\n",
       "     var linksMap = d3.map(data.links, function (d) {return d.uid;});\n",
       "\n",
       "     return data;\n",
       "   }\n",
       "\n",
       "   /*\n",
       "    * Public function to reset the zoom.\n",
       "    * Most of the work happens in render()\n",
       "    */\n",
       "   chart.updateZoom = function (newZoom){\n",
       "     if (newZoom === 'zoom_in'){\n",
       "       transition(1.2); // increase on 0.2 each time\n",
       "     }\n",
       "     if (newZoom === 'zoom_out'){\n",
       "       transition(0.8); // deacrease on 0.2 each time\n",
       "     }\n",
       "     if (newZoom === 'zoom_init'){\n",
       "       svg.transition()\n",
       "          .delay(100)\n",
       "          .duration(700)\n",
       "          .call(zoom.transform, d3.zoomIdentity); // return to initial state\n",
       "     }\n",
       "   }\n",
       "\n",
       "   /*\n",
       "    * Public function to update the layout.\n",
       "    * Most of the work happens in render()\n",
       "    */\n",
       "   chart.updateLayout = function (newLayout) {\n",
       "     layout = newLayout;\n",
       "     showEdges = true;//layout === 'force';\n",
       "     render();\n",
       "     return this;\n",
       "   };\n",
       "\n",
       "\n",
       "   /*\n",
       "    * Public function to update node filters.\n",
       "    * Most of the work happens in render()\n",
       "    */\n",
       "   chart.updateFilter = function (newFilter) {\n",
       "     filter = newFilter;\n",
       "     render();\n",
       "     return this;\n",
       "   };\n",
       "\n",
       "   /*\n",
       "    * Public function to update the temporal network.\n",
       "    * Most of the work happens in render()\n",
       "    */\n",
       "   chart.updateTime = function (newTime) {\n",
       "     //console.log('new time',newTime);\n",
       "     time = newTime;\n",
       "     render();\n",
       "     return this;\n",
       "   };\n",
       "\n",
       "\n",
       "   /*\n",
       "    * Public function to update input data\n",
       "    * Most of the work happens in render()\n",
       "    */\n",
       "   chart.updateData = function (newData) {\n",
       "     allData = setupData(newData);\n",
       "     render();\n",
       "   };\n",
       "\n",
       "\n",
       "   /*\n",
       "    * Public function to handle search.\n",
       "    * Updates nodes if a match is found.\n",
       "    */\n",
       "   chart.updateSearch = function (searchTerm) {\n",
       "     var searchRegEx = new RegExp(searchTerm.toLowerCase());\n",
       "     nodes.each(function (d) {\n",
       "       var element = d3.select(this)\n",
       "                       .classed('node_search',false);\n",
       "       var match = getName(d).toLowerCase().search(searchRegEx);\n",
       "       if (searchTerm.length > 0 && match >= 0) {\n",
       "         element.classed('node_search',true)\n",
       "                .style('fill', '#F38630');\n",
       "         d.searched = true;\n",
       "       } else {\n",
       "         d.searched = false;\n",
       "         element.classed('node_search',false);\n",
       "         element.style('fill', function (e) { return getColor(e); });\n",
       "       }\n",
       "     });\n",
       "   };\n",
       "\n",
       "   /*\n",
       "    * Public function to return the svg canvas\n",
       "    */\n",
       "   chart.getSVG = function () {\n",
       "     return svg;\n",
       "   };\n",
       "\n",
       "   /*\n",
       "    * Callback for mouseover event.\n",
       "    * Highlights a node and connected edges.\n",
       "    */\n",
       "   function highlightNode(d) {\n",
       "     var content = '<p class=\"main\">' + getName(d) + '</span></p>';\n",
       "     content += '<hr class=\"tooltip-hr\">';\n",
       "     content += '<p class=\"main\">' + getText(d) + '</span></p>';\n",
       "     myTooltip.showTooltip(content, d3.event);\n",
       "\n",
       "     if (showEdges) {\n",
       "       edges\n",
       "         .classed('edge_highlight', function (l) {\n",
       "           if (l.source.uid === d.uid || l.target.uid === d.uid) {\n",
       "             return true;\n",
       "           }\n",
       "           return false;\n",
       "         });\n",
       "\n",
       "       // higlight connected nodes\n",
       "       nodes\n",
       "         .classed('node_highlight', function (n) {\n",
       "           if (d.uid === n.uid || n.searched || neighboring(d, n)) {\n",
       "             return true;\n",
       "           }\n",
       "           return false;\n",
       "         });\n",
       "     }\n",
       "   }\n",
       "\n",
       "   /*\n",
       "    * Helper function returns not-false\n",
       "    * if a and b are connected by an edge.\n",
       "    * Uses linkedByIndex object.\n",
       "    */\n",
       "   function neighboring(a, b) {\n",
       "     return linkedByIndex[a.uid + '_' + b.uid] ||\n",
       "            linkedByIndex[b.uid + '_' + a.uid];\n",
       "   }\n",
       "\n",
       "   /*\n",
       "    * Callback for mouseout event.\n",
       "    * Unhighlights node.\n",
       "    */\n",
       "   function unhighlightNode() {\n",
       "     myTooltip.hideTooltip();\n",
       "\n",
       "     // reset edges\n",
       "     edges\n",
       "       .classed('edge_highlight',false);\n",
       "\n",
       "     // reset nodes\n",
       "     nodes\n",
       "       .classed('node_highlight',false);\n",
       "   }\n",
       "\n",
       "   return chart;\n",
       " };\n",
       "\n",
       "\n",
       " var myNetwork = network(config);\n",
       " myNetwork(\"#x58b8b1ad05884c36b9918aa9940b7327\", data);\n",
       "\n",
       " /* function widgets(container,config,network){ */\n",
       "\n",
       " // Activate selector button\n",
       " function activate(group, link) {\n",
       "   d3.selectAll('#' + group + ' button')\n",
       "     .classed('active', false);\n",
       "   d3.select('#' + group + ' #' + link)\n",
       "     .classed('active', true);\n",
       " }\n",
       "\n",
       " function getTooltip(config,control){\n",
       "   var title = config.widgets[control].title;\n",
       "   var text = config.widgets[control].tooltip;\n",
       "   var content = '<p class=\"main\">' + title + '</span></p>';\n",
       "   content += '<hr class=\"tooltip-hr\">';\n",
       "   content += '<p class=\"main\">' + text + '</span></p>';\n",
       "   return content\n",
       " };\n",
       "\n",
       " function setupMenu(container,config,network){\n",
       "\n",
       "   // tooltip for mouseover functionality\n",
       "   // implemented in tooltip.js\n",
       "   var myTooltip = tooltip('menu-tooltip');\n",
       "\n",
       "   // create menu bar which contains the control widgets\n",
       "   var menuBar = d3.select(container)\n",
       "                   .append('div')\n",
       "                   .attr('class','pp_container')\n",
       "                   .attr('id','#pp_container');\n",
       "   //.text(\"Second paragraph.\");\n",
       "\n",
       "   // container for the buttons\n",
       "   var controlBar = menuBar\n",
       "     .append('div')\n",
       "     .attr('class','controls')\n",
       "     .attr('id','#controls');\n",
       "\n",
       "   // container of the save buttons\n",
       "   var saveControl = d3.create('div')\n",
       "                       .attr('class','control')\n",
       "                       .attr('id','save')\n",
       "                       .on('mouseover', function () {\n",
       "                         myTooltip.showTooltip(getTooltip(config,'save'), d3.event);})\n",
       "                       .on(\"mouseout\",function () {\n",
       "                         myTooltip.hideTooltip();});\n",
       "\n",
       "   // save svg button\n",
       "   var svgBtn = d3.create('button')\n",
       "                  .text('svg')\n",
       "                  .on('click', function () {\n",
       "\n",
       "                    // get the network svg\n",
       "                    var SVGElem = network.getSVG().node();\n",
       "                    var oDOM = SVGElem.cloneNode(true)\n",
       "                    // convert svg in order to include css styles\n",
       "                    convertSVG(oDOM, SVGElem)\n",
       "                    // serialize our SVG XML to a string.\n",
       "                    var data = new XMLSerializer().serializeToString(oDOM);\n",
       "                    // create a blob object\n",
       "                    var svg = new Blob([data], { type: \"image/svg+xml;charset=utf-8\" });\n",
       "                    // create data url\n",
       "                    var url = URL.createObjectURL(svg);\n",
       "\n",
       "                    // construct the 'a' element\n",
       "                    var link = window.document.createElement('a');\n",
       "                    link.download = 'network.svg'\n",
       "                    // construct the URI\n",
       "                    link.href = url;\n",
       "                    document.body.appendChild(link);\n",
       "                    link.click();\n",
       "                    // clean-up the DOM\n",
       "                    document.body.removeChild(link);\n",
       "                  });\n",
       "\n",
       "\n",
       "\n",
       "   // save png button\n",
       "   var pngBtn = d3.create('button')\n",
       "                  .text('png')\n",
       "                  .on('click', function () {\n",
       "\n",
       "                    // get the network svg\n",
       "                    var SVGElem = network.getSVG().node();\n",
       "                    var oDOM = SVGElem.cloneNode(true)\n",
       "                    // convert svg in order to include css styles\n",
       "                    convertSVG(oDOM, SVGElem)\n",
       "                    // serialize our SVG XML to a string.\n",
       "                    var data = new XMLSerializer().serializeToString(oDOM);\n",
       "                    // create a blob object\n",
       "                    var svg = new Blob([data], { type: \"image/svg+xml;charset=utf-8\" });\n",
       "                    // create data url\n",
       "                    var url = URL.createObjectURL(svg);\n",
       "\n",
       "                    // create image\n",
       "                    var img = d3.select('body')\n",
       "                                .append('img')\n",
       "                                .classed('exportImg', true).node();\n",
       "                    img.onload = function () {\n",
       "                      var canvas = document.createElement('canvas'),\n",
       "                          ctx = canvas.getContext('2d');\n",
       "                      canvas.width = config.width || 400;\n",
       "                      canvas.height = config.height || 400;\n",
       "                      ctx.clearRect(0, 0, canvas.width, canvas.height);\n",
       "                      ctx.drawImage(img, 0, 0, canvas.width, canvas.height);\n",
       "                      d3.select('img.exportImg').remove();\n",
       "\n",
       "                      // construct the 'a' element\n",
       "                      var link = window.document.createElement('a');\n",
       "                      link.download = 'network.png'\n",
       "                      // construct the URI\n",
       "                      link.href = canvas.toDataURL();\n",
       "                      document.body.appendChild(link);\n",
       "                      link.click();\n",
       "                      // clean-up the DOM\n",
       "                      document.body.removeChild(link);\n",
       "\n",
       "                    };\n",
       "                    img.src = url;\n",
       "\n",
       "                    console.log('Save png')\n",
       "                    //network.getCanvas();\n",
       "                  });\n",
       "\n",
       "   // assign button to the save\n",
       "   saveControl.append(function(){ return svgBtn.node(); });\n",
       "   saveControl.append(function(){ return pngBtn.node(); });\n",
       "\n",
       "\n",
       "   // container of the zoom buttons\n",
       "   var zoomControl = d3.create('div')\n",
       "                       .attr('class','control pp_vl')\n",
       "                       .attr('id','zoom')\n",
       "                       .on('mouseover', function () {\n",
       "                         myTooltip.showTooltip(getTooltip(config,'zoom'), d3.event);})\n",
       "                       .on(\"mouseout\",function () {\n",
       "                         myTooltip.hideTooltip();});\n",
       "\n",
       "\n",
       "   // zoom out button\n",
       "   var zoomOutBtn = d3.create('button')\n",
       "                      .text('-')\n",
       "                      .on('click', function () {\n",
       "                        network.updateZoom('zoom_out');\n",
       "                      });\n",
       "\n",
       "   // zoom reset button\n",
       "   var zoomInitBtn = d3.create('button')\n",
       "                       .text('Reset')\n",
       "                       .on('click', function () {\n",
       "                         network.updateZoom('zoom_init');\n",
       "                       });\n",
       "\n",
       "   // zoom in button\n",
       "   var zoomInBtn = d3.create('button')\n",
       "                     .text('+')\n",
       "                     .on('click', function () {\n",
       "                       network.updateZoom('zoom_in');\n",
       "                     });\n",
       "\n",
       "   // assign button to the zoom\n",
       "   zoomControl.append(function(){ return zoomOutBtn.node(); });\n",
       "   zoomControl.append(function(){ return zoomInitBtn.node(); });\n",
       "   zoomControl.append(function(){ return zoomInBtn.node(); });\n",
       "\n",
       "   // container of the layout buttons\n",
       "   var layoutControl = d3.create('div')\n",
       "                         .attr('class','control pp_vl')\n",
       "                         .attr('id','layout')\n",
       "                         .on('mouseover', function () {\n",
       "                           myTooltip.showTooltip(getTooltip(config,'layout'), d3.event);})\n",
       "                         .on(\"mouseout\",function () {\n",
       "                           myTooltip.hideTooltip();});\n",
       "\n",
       "   // force directed layout button\n",
       "   var forceBtn = d3.create('button')\n",
       "                    .attr('class','active')\n",
       "                    .attr('id','force')\n",
       "                    .text('Force')\n",
       "                    .on('click', function () {\n",
       "                      activate('layout', 'force');\n",
       "                      network.updateLayout('force');\n",
       "                    });\n",
       "\n",
       "   // euclidean layout button\n",
       "   var euclideanBtn = d3.create('button')\n",
       "                        .attr('id','euclidean')\n",
       "                        .text('Coord')\n",
       "                        .on('click', function () {\n",
       "                          activate('layout', 'euclidean');\n",
       "                          network.updateLayout('euclidean');\n",
       "                        });\n",
       "\n",
       "   // assign button to the layout\n",
       "   layoutControl.append(function(){ return forceBtn.node(); });\n",
       "   if (config.coordinates === true){\n",
       "     layoutControl.append(function(){ return euclideanBtn.node(); });};\n",
       "\n",
       "\n",
       "   // container of the group drop down menu\n",
       "   var filterControle = d3.create('div')\n",
       "                          .attr('class','control pp_vl')\n",
       "                          .attr('id','filter')\n",
       "                          .on('mouseover', function () {\n",
       "                            myTooltip.showTooltip(getTooltip(config,'filter'), d3.event);})\n",
       "                          .on(\"mouseout\",function () {\n",
       "                            myTooltip.hideTooltip();});\n",
       "\n",
       "\n",
       "   // initialize the drop down menu\n",
       "   var groupDropDown = filterControle\n",
       "     .append('select');\n",
       "\n",
       "   // Create data = list of groups\n",
       "   var allGroups = config.widgets.filter.groups\n",
       "\n",
       "   // add the options to the button\n",
       "   groupDropDown // Add a button\n",
       "                         .selectAll('myOptions') // Next 4 lines add 6 options = 6 colors\n",
       "                         .data(allGroups)\n",
       "                         .enter()\n",
       "                         .append('option')\n",
       "                         .text(function (d) { return d; }) // text showed in the menu\n",
       "                         .attr(\"value\", function (d) { return d; }); // corresponding value returned by the button\n",
       "\n",
       "   // add function by change\n",
       "   groupDropDown\n",
       "                           .on('change', function () {\n",
       "                             var newFilter = d3.select(this).property('value');\n",
       "                             network.updateFilter(newFilter);\n",
       "                           });\n",
       "\n",
       "   // container of the search buttons\n",
       "   var searchControl = d3.create('div')\n",
       "                         .attr('class','control pp_vl')\n",
       "                         .attr('id','pp_search')\n",
       "                         .on('mouseover', function () {\n",
       "                           myTooltip.showTooltip(getTooltip(config,'search'), d3.event);})\n",
       "                         .on(\"mouseout\",function () {\n",
       "                           myTooltip.hideTooltip();});\n",
       "\n",
       "\n",
       "   searchControl\n",
       "     .append('from')\n",
       "     .attr('id','pp_search_from')\n",
       "     .attr('action','')\n",
       "     .attr('method','post')\n",
       "   searchControl\n",
       "     .append('input')\n",
       "     .attr('type','text')\n",
       "     .attr('class','text-input')\n",
       "     .attr('id','search')\n",
       "     .attr('value','')\n",
       "     .attr('placeholder','Search ...')\n",
       "     .on('keyup', function () {\n",
       "       var searchTerm = d3.select(this).property('value');\n",
       "       network.updateSearch(searchTerm);\n",
       "     });\n",
       "\n",
       "\n",
       "   // assign controls to widget if enabled\n",
       "   if (config.widgets.save.enabled === true){\n",
       "     controlBar.append(function(){ return saveControl.node(); });};\n",
       "   if (config.widgets.zoom.enabled === true){\n",
       "     controlBar.append(function(){ return zoomControl.node(); });};\n",
       "   if (config.widgets.layout.enabled === true){\n",
       "     controlBar.append(function(){ return layoutControl.node(); });};\n",
       "   if (config.widgets.filter.enabled === true){\n",
       "     controlBar.append(function(){ return filterControle.node(); });};\n",
       "   if (config.widgets.search.enabled === true){\n",
       "     controlBar.append(function(){ return searchControl.node(); });};\n",
       "\n",
       "   function convertSVG(ParentNode, OrigData){\n",
       "     var ContainerElements = [\"svg\",\"g\"];\n",
       "     var RelevantStyles = {\"rect\":[\"fill\",\"stroke\",\"stroke-width\"],\"path\":[\"fill\",\"stroke\",\"stroke-width\"],\"circle\":[\"fill\",\"stroke\",\"stroke-width\"],\"line\":[\"stroke\",\"stroke-width\"],\"text\":[\"fill\",\"font-size\",\"text-anchor\"],\"polygon\":[\"stroke\",\"fill\"]};\n",
       "\n",
       "     var Children = ParentNode.childNodes;\n",
       "     var OrigChildDat = OrigData.childNodes;\n",
       "\n",
       "     for (var cd = 0; cd < Children.length; cd++){\n",
       "       var Child = Children[cd];\n",
       "\n",
       "       var TagName = Child.tagName;\n",
       "       if (ContainerElements.indexOf(TagName) != -1){\n",
       "         convertSVG(Child, OrigChildDat[cd])\n",
       "       } else if (TagName in RelevantStyles){\n",
       "         var StyleDef = window.getComputedStyle(OrigChildDat[cd]);\n",
       "\n",
       "         var StyleString = \"\";\n",
       "         for (var st = 0; st < RelevantStyles[TagName].length; st++){\n",
       "           StyleString += RelevantStyles[TagName][st] + \":\" + StyleDef.getPropertyValue(RelevantStyles[TagName][st]) + \"; \";\n",
       "         }\n",
       "\n",
       "         Child.setAttribute(\"style\",StyleString);\n",
       "       }\n",
       "     }\n",
       "   };\n",
       "\n",
       "\n",
       " };\n",
       "\n",
       " /* return setupMenu;\n",
       "    }; */\n",
       "\n",
       "\n",
       " setupMenu(\"#x0b7f8e0c7a5e4aa8a771abcfeff275e4\",config,myNetwork);\n",
       "\n",
       "\n",
       " function sliderMenu(container,config,network){\n",
       "\n",
       "   // get config values\n",
       "   var pastDelta = 0;\n",
       "   var futureDelta = 0;\n",
       "   var aggregationDelta = 0;\n",
       "\n",
       "   // dont show aggrigation and lookout\n",
       "   var aggregationShow = false;\n",
       "   var lookoutShow = false;\n",
       "\n",
       "   // initialize timer\n",
       "   var timer = null;\n",
       "\n",
       "   // tooltip for mouseover functionality\n",
       "   // implemented in tooltip.js\n",
       "   var myTooltip = tooltip('menu-tooltip');\n",
       "\n",
       "   // create menu bar which contains the control widgets\n",
       "   var menuBar = d3.select(container)\n",
       "                   .append('div')\n",
       "                   .attr('class','pp_container')\n",
       "                   .attr('id','#pp_slider');\n",
       "\n",
       "   // container for the buttons\n",
       "   var controlBar = menuBar\n",
       "     .append('div')\n",
       "     .attr('class','controls')\n",
       "     .attr('id','#controls');\n",
       "\n",
       "   // container of the animation buttons\n",
       "   var animationControl = d3.create('div')\n",
       "                            .attr('class','control')\n",
       "                            .attr('id','animation')\n",
       "                            .on('mouseover', function () {\n",
       "                              myTooltip.showTooltip(getTooltip(config,'animation'), d3.event);})\n",
       "                            .on(\"mouseout\",function () {\n",
       "                              myTooltip.hideTooltip();});\n",
       "\n",
       "   // save svg button\n",
       "   var playBtn = d3.create('button')\n",
       "                   .text('Play');\n",
       "\n",
       "   // assign button to the animation cotrole\n",
       "   animationControl.append(function(){ return playBtn.node(); });\n",
       "\n",
       "   // container of the aggregation buttons\n",
       "   var aggregationControl = d3.create('div')\n",
       "                              .attr('class','control pp_vl')\n",
       "                              .attr('id','aggregation')\n",
       "                              .on('mouseover', function () {\n",
       "                                myTooltip.showTooltip(getTooltip(config,'aggregation'), d3.event);})\n",
       "                              .on(\"mouseout\",function () {\n",
       "                                myTooltip.hideTooltip();});\n",
       "\n",
       "   // make button to enable aggregation of time steps\n",
       "   var aggregationBtn = d3.create('button')\n",
       "                          .text('Aggregate')\n",
       "                          .classed('active', false);\n",
       "\n",
       "   // make button to enable lookouts\n",
       "   var lookoutBtn = d3.create('button')\n",
       "                      .text('Lookout')\n",
       "                      .classed('active', false);\n",
       "\n",
       "   // assign button to the aggregation cotrole\n",
       "   aggregationControl.append(function(){ return aggregationBtn.node(); });\n",
       "\n",
       "   // assign button to the aggregation cotrole\n",
       "   aggregationControl.append(function(){ return lookoutBtn.node(); });\n",
       "\n",
       "   // assign controls to widget if enabled\n",
       "   if (config.widgets.animation.enabled === true){\n",
       "     controlBar.append(function(){ return animationControl.node(); });};\n",
       "\n",
       "   // assign controls to widget if enabled\n",
       "   if (config.widgets.aggregation.enabled === true){\n",
       "     controlBar.append(function(){ return aggregationControl.node(); });};\n",
       "\n",
       "   ///////////////// generate slider /////////////////////\n",
       "\n",
       "   var formatInt = d3.format(\",.0f\");\n",
       "   var unit = config.animation.unit || \"seconds\";\n",
       "   var formatDateIntoMillisecond = d3.timeFormat(\".%L\"),\n",
       "       formatDateIntoSecond = d3.timeFormat(\"%M:%S\"),\n",
       "       formatDateIntoMinute = d3.timeFormat(\"%I:%M\"),\n",
       "       formatDateIntoHour = d3.timeFormat(\"%I %p\"),\n",
       "       formatDateIntoDay = d3.timeFormat(\"%a %d\"),\n",
       "       formatDateIntoWeek = d3.timeFormat(\"%b %d\"),\n",
       "       formatDateIntoMonth = d3.timeFormat(\"%B\"),\n",
       "       formatDateIntoMonthYear = d3.timeFormat(\"%b %Y\"),\n",
       "       formatDateIntoYear = d3.timeFormat(\"%Y\");\n",
       "\n",
       "   var formatTickDate = formatDateIntoSecond;\n",
       "   var formatDate = formatDateIntoSecond;\n",
       "\n",
       "   if (unit === \"seconds\"){\n",
       "     formatTickDate = formatDateIntoSecond;\n",
       "     formatDate = formatDateIntoSecond;\n",
       "   } else if (unit === \"minutes\"){\n",
       "     formatTickDate = formatDateIntoMinute;\n",
       "     formatDate = formatDateIntoMinute;\n",
       "   }else if (unit === \"days\"){\n",
       "     formatTickDate = formatDateIntoDay;\n",
       "     formatDate = formatDateIntoDay;\n",
       "   }else if (unit === \"weeks\"){\n",
       "     formatTickDate = formatDateIntoWeek;\n",
       "     formatDate = formatDateIntoWeek;\n",
       "   }else if (unit === \"months\"){\n",
       "     formatTickDate = formatDateIntoMonth;\n",
       "     formatDate = formatDateIntoMonth;\n",
       "   }else if (unit === \"years\"){\n",
       "     formatTickDate = formatDateIntoMonthYear;\n",
       "     formatDate = formatDateIntoYear;\n",
       "   }\n",
       "\n",
       "   var startDate = new Date(config.animation.start),\n",
       "       endDate = new Date(config.animation.end);\n",
       "\n",
       "   // devine margin and width of the slider\n",
       "   var margin = {top:0, right:50, bottom:0, left:50},\n",
       "       width = 600 - margin.left - margin.right,\n",
       "       height = 80 - margin.top - margin.bottom;\n",
       "\n",
       "   // add svg to the menu bar\n",
       "   var svg = menuBar\n",
       "     .append(\"svg\")\n",
       "     .attr(\"width\", width + margin.left + margin.right)\n",
       "     .attr(\"height\", height + margin.top + margin.bottom);\n",
       "   //.style(\"background-color\",\"#f6f7ba\");\n",
       "\n",
       "   var moving = false;\n",
       "   var currentValue = 0;\n",
       "   var targetValue = width;\n",
       "   var timeSteps = config.animation.steps || 10;\n",
       "\n",
       "   // convert time steps (e.g. 0,1,2,...) into date values\n",
       "   var t = d3.scaleTime()\n",
       "             .domain([startDate, endDate])\n",
       "             .range([0, targetValue])\n",
       "             .clamp(true);\n",
       "\n",
       "   // convert time steps (e.g. 0,1,2,...) into px values\n",
       "   var x = d3.scaleLinear()\n",
       "             .domain([0, timeSteps])\n",
       "             .range([0,targetValue])\n",
       "             .clamp(true);\n",
       "\n",
       "   // create slider object\n",
       "   var slider = svg.append(\"g\")\n",
       "                   .attr(\"class\", \"slider\")\n",
       "                   .attr(\"transform\", \"translate(\" + margin.left + \",\" + height/2 + \")\");\n",
       "\n",
       "   // make track of the slider\n",
       "   slider.append(\"line\")\n",
       "         .attr(\"class\", \"track\")\n",
       "         .attr(\"x1\", x.range()[0])\n",
       "         .attr(\"x2\", x.range()[1])\n",
       "         .select(function() {\n",
       "           return this.parentNode.appendChild(this.cloneNode(true)); })\n",
       "         .attr(\"class\", \"track-inset\");\n",
       "\n",
       "   // make a line for the past records\n",
       "   var pastLine = d3.create(\"svg\").append('line')\n",
       "                    .attr(\"class\", \"track-past\")\n",
       "                    .attr(\"x1\", 0)\n",
       "                    .attr(\"x2\", 0);\n",
       "\n",
       "   // make a line for the future records\n",
       "   var futureLine = d3.create(\"svg\").append(\"line\")\n",
       "                      .attr(\"class\", \"track-future\")\n",
       "                      .attr(\"x1\", x(aggregationDelta))\n",
       "                      .attr(\"x2\", x(aggregationDelta)+x(futureDelta));\n",
       "\n",
       "   // make a line for the aggregated time steps\n",
       "   var aggregationLine = d3.create(\"svg\").append(\"line\")\n",
       "                           .attr(\"class\", \"track-aggregation\")\n",
       "                           .attr(\"x1\", 0)\n",
       "                           .attr(\"x2\", x(aggregationDelta));\n",
       "\n",
       "\n",
       "   // append lines to the slider\n",
       "   slider.append(function(){ return pastLine.node(); });\n",
       "   slider.append(function(){ return futureLine.node(); });//};\n",
       "   slider.append(function(){ return aggregationLine.node(); });//};\n",
       "\n",
       "\n",
       "   // add ticks to the slider\n",
       "   slider.insert(\"g\", \".track-overlay\")\n",
       "         .attr(\"class\", \"ticks\")\n",
       "         .attr(\"transform\", \"translate(0,\" + 18 + \")\")\n",
       "         .selectAll(\"text\")\n",
       "         .data(x.ticks(10))\n",
       "         .enter()\n",
       "         .append(\"text\")\n",
       "         .attr(\"x\", x)\n",
       "         .attr(\"y\", 10)\n",
       "         .attr(\"text-anchor\", \"middle\")\n",
       "         .text(function(d) { return formatTickDate(t.invert(x(d))); });\n",
       "\n",
       "   // add handler to the slider\n",
       "   var handle = slider.insert(\"circle\", \".track-overlay\")\n",
       "                      .attr(\"class\", \"handle\")\n",
       "                      .attr(\"cx\",0)\n",
       "                      .attr(\"r\", 9)\n",
       "                      .call(d3.drag()\n",
       "                              .on(\"start.interrupt\", function() { slider.interrupt(); })\n",
       "                              .on(\"start drag\", function() {\n",
       "                                currentValue = d3.event.x;\n",
       "                                update(x.invert(currentValue));\n",
       "                              })\n",
       "                      );\n",
       "\n",
       "\n",
       "   // add handler to the slider\n",
       "   var pastHandle = d3.create(\"svg\").append(\"circle\")\n",
       "                      .attr(\"class\", \"handle\")\n",
       "                      .attr('id','pastHandle')\n",
       "                      .attr(\"r\", 6)\n",
       "                      .attr(\"transform\", \"translate(-8,8)\")\n",
       "                      .call(d3.drag()\n",
       "                              .on(\"drag\", function() {\n",
       "                                pastUpdate(x.invert(d3.event.x));\n",
       "                              })\n",
       "                      );\n",
       "\n",
       "\n",
       "   // add handler to the slider\n",
       "   var futureHandle = d3.create(\"svg\").append(\"circle\")\n",
       "                        .attr(\"class\", \"handle\")\n",
       "                        .attr('id','futureHandle')\n",
       "                        .attr(\"r\", 6)\n",
       "                        .attr(\"cx\",x(aggregationDelta)+x(futureDelta))\n",
       "                        .attr(\"transform\", \"translate(8,8)\")\n",
       "                        .call(d3.drag()\n",
       "                                .on(\"drag\", function() {\n",
       "                                  futureUpdate(x.invert(d3.event.x));\n",
       "                                })\n",
       "                        );\n",
       "\n",
       "\n",
       "   // add handler to the slider\n",
       "   var aggregationHandle = d3.create(\"svg\").append(\"circle\")\n",
       "                             .attr(\"class\", \"handle\")\n",
       "                             .attr('id','aggregationHandle')\n",
       "                             .attr(\"r\", 6)\n",
       "                             .attr(\"cx\",x(aggregationDelta))\n",
       "                             .attr(\"transform\", \"translate(8,-8)\")\n",
       "                             .call(d3.drag()\n",
       "                                     .on(\"drag\", function() {\n",
       "                                       aggregationUpdate(x.invert(d3.event.x));\n",
       "                                     })\n",
       "                             );\n",
       "\n",
       "   // show data if enabled\n",
       "   if (lookoutShow === true){\n",
       "     slider.append(function(){ return pastHandle.node(); });\n",
       "     slider.append(function(){ return futureHandle.node(); });};\n",
       "\n",
       "   if (aggregationShow === true){\n",
       "     slider.append(function(){ return aggregationHandle.node(); });};\n",
       "\n",
       "\n",
       "   // add lable showing current time stamp\n",
       "   var label = slider.append(\"text\")\n",
       "                     .attr(\"id\", \"pp_slider_label\")\n",
       "                     .attr(\"text-anchor\", \"middle\")\n",
       "                     .text(formatDate(startDate))\n",
       "                     .attr(\"transform\", \"translate(0,\" + (-20) + \")\");\n",
       "\n",
       "   ///////////////// generate button actions /////////////////////\n",
       "\n",
       "   playBtn\n",
       "     .on(\"click\", function() {\n",
       "       var button = d3.select(this);\n",
       "       if (button.text() == \"Pause\") {\n",
       "         moving = false;\n",
       "         //clearInterval(timer);\n",
       "         timer.stop()\n",
       "         // timer = 0;\n",
       "         button.text(\"Play\");\n",
       "       } else {\n",
       "         moving = true;\n",
       "         // wait some time e.g. 1000 = 1000 ms = 1 sec\n",
       "         timer = d3.interval(function(){step()},\n",
       "                             config.animation.speed || 100);\n",
       "         button.text(\"Pause\");\n",
       "       }\n",
       "       //console.log(\"Slider moving: \" + moving);\n",
       "     });\n",
       "\n",
       "   aggregationBtn\n",
       "     .on('click', function () {\n",
       "       var button = d3.select(this);\n",
       "\n",
       "       if (aggregationShow === false){\n",
       "         button.classed('active', true);\n",
       "         aggregationShow = true;\n",
       "         aggregationDelta = config.widgets.aggregation.aggregation || 0;\n",
       "         slider.append(function(){ return aggregationHandle.node(); });\n",
       "\n",
       "       } else {\n",
       "         button.classed('active', false);\n",
       "         aggregationShow = false;\n",
       "         aggregationDelta = 0;\n",
       "         d3.select('#aggregationHandle').remove();\n",
       "       };\n",
       "       update(x.invert(currentValue));\n",
       "     });\n",
       "\n",
       "   lookoutBtn\n",
       "     .on('click', function () {\n",
       "       var button = d3.select(this);\n",
       "\n",
       "       if (lookoutShow === false){\n",
       "         button.classed('active', true);\n",
       "         lookoutShow = true;\n",
       "         pastDelta = config.widgets.aggregation.past || 0;\n",
       "         futureDelta = config.widgets.aggregation.future || 0;\n",
       "         slider.append(function(){ return pastHandle.node(); });\n",
       "         slider.append(function(){ return futureHandle.node(); });\n",
       "\n",
       "       } else {\n",
       "         button.classed('active', false);\n",
       "         lookoutShow = false;\n",
       "         pastDelta = 0;\n",
       "         futureDelta = 0;\n",
       "         d3.select('#pastHandle').remove();\n",
       "         d3.select('#futureHandle').remove();\n",
       "       };\n",
       "       update(x.invert(currentValue));\n",
       "     });\n",
       "\n",
       "\n",
       "   ///////////////// generate iterative functions /////////////////////\n",
       "\n",
       "   function step() {\n",
       "     update(x.invert(currentValue));\n",
       "     currentValue = currentValue + (targetValue/timeSteps);\n",
       "\n",
       "     if (currentValue+x(aggregationDelta) > targetValue) {\n",
       "       moving = false;\n",
       "       currentValue = 0;\n",
       "       // stop after time is max\n",
       "       timer.stop()\n",
       "       // clearInterval(timer);\n",
       "       // timer = 0;\n",
       "       playBtn.text(\"Play\");\n",
       "     }\n",
       "   };\n",
       "\n",
       "\n",
       "   function update(value) {\n",
       "     // update position and text of label according to slider scale\n",
       "     handle.attr(\"cx\", x(value));\n",
       "\n",
       "     if (x(value)>x(pastDelta)){\n",
       "       pastHandle.attr(\"cx\", x(value)-x(pastDelta));\n",
       "       pastLine.attr('x1',x(value)-x(pastDelta));\n",
       "     } else{\n",
       "       pastHandle.attr(\"cx\", 0);\n",
       "       pastLine.attr('x1',0);\n",
       "     };\n",
       "\n",
       "     if ((x(value)+x(aggregationDelta))<width){\n",
       "       aggregationHandle.attr(\"cx\", x(value)+x(aggregationDelta));\n",
       "       aggregationLine.attr('x2',x(value)+x(aggregationDelta));\n",
       "     } else{\n",
       "       aggregationHandle.attr(\"cx\", width);\n",
       "       aggregationLine.attr('x2',width);\n",
       "       futureLine.attr('x2',width);\n",
       "     };\n",
       "\n",
       "\n",
       "     if ((x(value)+x(aggregationDelta)+x(futureDelta))<width){\n",
       "       futureHandle.attr(\"cx\", x(value)+x(aggregationDelta)+x(futureDelta));\n",
       "       futureLine.attr('x2',x(value)+x(aggregationDelta)+x(futureDelta));\n",
       "     } else{\n",
       "       futureHandle.attr(\"cx\", width);\n",
       "       futureLine.attr('x2',width);\n",
       "     };\n",
       "\n",
       "     label\n",
       "       .attr(\"x\", x(value))\n",
       "       .text(formatDate(t.invert(x(value))));\n",
       "\n",
       "     pastLine.attr('x2',x(value));\n",
       "     if ((x(value)+x(aggregationDelta))<width){\n",
       "       futureLine.attr('x1',x(value)+x(aggregationDelta));\n",
       "     }else{\n",
       "       futureLine.attr('x1',width);\n",
       "     };\n",
       "     aggregationLine.attr('x1',x(value));\n",
       "\n",
       "     var newTime = {\n",
       "       past : parseInt(formatInt(x.invert(pastHandle.attr(\"cx\")))),\n",
       "       time : parseInt(formatInt(value)),\n",
       "       aggregated : parseInt(formatInt(value+aggregationDelta)),\n",
       "       future : parseInt(formatInt(x.invert(futureHandle.attr(\"cx\"))))\n",
       "     };\n",
       "\n",
       "     // update the network\n",
       "     network.updateTime(newTime);\n",
       "   }\n",
       "\n",
       "   function pastUpdate(value) {\n",
       "     var delta = parseInt(formatInt(value))\n",
       "               - parseInt(formatInt(x.invert(handle.attr('cx'))));\n",
       "     if (delta <= 0 && x(value) < handle.attr('cx')){\n",
       "       pastDelta = Math.abs(delta);\n",
       "       pastHandle.attr(\"cx\", x(value));\n",
       "       pastLine.attr('x1',x(value));\n",
       "       update(x.invert(currentValue));\n",
       "     };\n",
       "   };\n",
       "\n",
       "   function futureUpdate(value) {\n",
       "     var delta = parseInt(formatInt(value))\n",
       "               - parseInt(formatInt(x.invert(aggregationHandle.attr('cx'))));\n",
       "     if (delta >= 0 && x(value) > handle.attr('cx')){\n",
       "       futureDelta = Math.abs(delta);\n",
       "       futureHandle.attr(\"cx\", x(value));\n",
       "       futureLine.attr('x2',x(value));\n",
       "       update(x.invert(currentValue));\n",
       "     };\n",
       "   };\n",
       "\n",
       "\n",
       "   function aggregationUpdate(value) {\n",
       "     var delta = parseInt(formatInt(value))\n",
       "               - parseInt(formatInt(x.invert(handle.attr('cx'))));\n",
       "     if (delta >= 0 && x(value) > handle.attr('cx')){\n",
       "       aggregationDelta = Math.abs(delta);\n",
       "       aggregationHandle.attr(\"cx\", x(value));\n",
       "       aggregationLine.attr('x2',x(value));\n",
       "\n",
       "       if ((x(value)+x(futureDelta))<width){\n",
       "         futureHandle.attr(\"cx\", x(value)+x(futureDelta));\n",
       "         futureLine.attr('x2',x(value)+x(futureDelta));\n",
       "       } else{\n",
       "         futureHandle.attr(\"cx\", width);\n",
       "         futureLine.attr('x2',width);\n",
       "       };\n",
       "\n",
       "       futureLine.attr('x1',x(value));\n",
       "\n",
       "       update(x.invert(currentValue));\n",
       "     };\n",
       "   };\n",
       "\n",
       " }; // End of sliderMenu\n",
       "\n",
       " if (config.temporal === true){\n",
       "   sliderMenu(\"#x0b7f8e0c7a5e4aa8a771abcfeff275e4\",config,myNetwork);};\n",
       "\n",
       "</script>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/ingo/opt/anaconda3/lib/python3.8/site-packages/scipy/sparse/_index.py:124: SparseEfficiencyWarning: Changing the sparsity structure of a csr_matrix is expensive. lil_matrix is more efficient.\n",
      "  self._set_arrayXarray(i, j, x)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "matrix([[0.        , 0.66666667, 0.33333333],\n",
       "        [0.66666667, 0.        , 0.33333333],\n",
       "        [1.        , 0.        , 0.        ]])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n = pp.Network(directed=True)\n",
    "n.add_edge('a', 'b', weight=2)\n",
    "n.add_edge('a', 'c', weight=1)\n",
    "n.add_edge('b', 'c', weight=1)\n",
    "n.add_edge('b', 'a', weight=2)\n",
    "n.add_edge('c', 'a', weight=5)\n",
    "n.plot()\n",
    "transition_matrix(n, weight=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now write a function that computes the visitation probability $\\pi^{(t)}$ of a random walk after $t$ steps, based on a given initial distribution $\\pi^{(0)}$ and a given network topology. You can use built-in `numpy` functions for matrix powers and matrix multiplication. For matrix multiplication, you should have a look at the `dot` function in `numpy`. For the calculation of matrix powers, you should look into the package `numpy.linalg`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "def visitation_probabilities(network, initial_dist, t):\n",
    "    T = transition_matrix(network)\n",
    "    p_t = np.dot(initial_dist, npl.matrix_power(T,t))\n",
    "    return np.squeeze(np.asarray(p_t))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 0., 0.])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "visitation_probabilities(n, np.array([1, 0, 0]), 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.        , 0.66666667, 0.33333333])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "visitation_probabilities(n, np.array([1, 0, 0]), 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.45, 0.3 , 0.25])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "visitation_probabilities(n, np.array([1, 0, 0]), 500)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We find that after a sufficiently long time, the visitation probabilities cease to change:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.45, 0.3 , 0.25])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "visitation_probabilities(n, np.array([1, 0, 0]), 501)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This implies that - in this case - we reach a stationary state that is invariant with respect to a multiplication with the transition matrix. Let us try this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[0.45, 0.3 , 0.25]])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "T = transition_matrix(n)\n",
    "np.dot(np.array([0.45, 0.3 , 0.25]), T)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Total Variation Distance\n",
    "\n",
    "We can use the total variation distance measure to quantify the distance between two stochastic vectors."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "def tvd(p1, p2):\n",
    "    assert len(p1) == len(p2)\n",
    "    tvd = 0\n",
    "    for i in range(len(p1)):\n",
    "        tvd +=abs(p1[i] - p2[i])\n",
    "    return tvd/2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the following example, the total variation distance between the initial distribution and the visitation probabilities after one step reaches its maximum value of one (up to numerical precision). Here the difference between the node visitation probabilities is maximal, which confirms that our measure is properly normalized."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9999999999999999\n"
     ]
    }
   ],
   "source": [
    "pi_0 = np.array([1, 0, 0])\n",
    "x = visitation_probabilities(n, pi_0, 1)\n",
    "print(tvd(pi_0, x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As the random walk evolves, visitation probabilities change less and less:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.17421124828532225\n"
     ]
    }
   ],
   "source": [
    "pi_0 = np.array([1, 0, 0])\n",
    "x = visitation_probabilities(n, pi_0, 5)\n",
    "y = visitation_probabilities(n, pi_0, 6)\n",
    "print(tvd(x, y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Visitation probabilities do not change at all if we have reached a stationary state:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0\n"
     ]
    }
   ],
   "source": [
    "pi_0 = np.array([1, 0, 0])\n",
    "x = visitation_probabilities(n, pi_0, 500)\n",
    "y = visitation_probabilities(n, pi_0, 501)\n",
    "print(tvd(x, y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Stationary Distribution of Random Walks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We find that the equation $\\pi = \\pi \\cdot T$ must hold if the stochastic vector $\\pi$ is a stationary state of the random walk represented by the transition matrix $T$. We can thus simply calculate the stationary distribution of a given random walk by calculating the left eigenvector of the associated transition matrix. In `python` we can do this as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "def stationary_distribution(network):\n",
    "    T =  transition_matrix(network)\n",
    "    eigenvalues, eigenvectors = sp.linalg.eig(T, left=True, right=False)\n",
    "    # Here we take the **leading eigenvector**, i.e. the eigenvector\n",
    "    # corresponding to the **largest eigenvalue** of one\n",
    "    # numpy.argsort returns an array of indices that would sort an array\n",
    "    # note the multi-dimensional slicing :,x, which returns all entries \n",
    "    # in column x\n",
    "    pi = eigenvectors[:,np.argsort(-eigenvalues)][:,0]\n",
    "\n",
    "    # We make sure that the eigenvector is normalised\n",
    "    pi = pi/sum(pi)\n",
    "    return pi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.45, 0.3 , 0.25])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stationary_distribution(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1.        +0.j -0.66666667+0.j -0.33333333+0.j]\n",
      "[[ 7.55263222e-01  7.07106781e-01  4.08248290e-01]\n",
      " [ 5.03508815e-01 -7.07106781e-01 -8.16496581e-01]\n",
      " [ 4.19590679e-01  6.60999370e-17  4.08248290e-01]]\n"
     ]
    }
   ],
   "source": [
    "T = transition_matrix(n)\n",
    "eigenvalues, eigenvectors = sp.linalg.eig(T, left=True, right=False)\n",
    "print(eigenvalues)\n",
    "print(eigenvectors)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An important question is whether a stationary distribution always exists for a random walk in a network. It is probably easy to think of an example where this is not the case? Who has an idea?"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "179f2c9954461ddf657daf1ee3f9df7374d575c8403facec5648a064395b52ac"
  },
  "kernelspec": {
   "display_name": "Python 3.8.5 64-bit ('base': conda)",
   "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}