Introduction to Social Network Analysis using igraph.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> # Introduction to Social Network Analysis in R using igraph"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction to igraph in R"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Igraph is a software package for generating, analyzing and plotting networks.\n",
    "It supports multiple programming languages like Python and R and is one of the most\n",
    "frequently used tools for network analysis.\n",
    "\n",
    "For more info about igraph, documentation and help, you can always check their website:\n",
    "\n",
    "http://igraph.org/r/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# First of all, we need to import the igraph library\n",
    "library(igraph)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating and exploring graph objects"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use the igraph package to easily build graph objects in R. We can just specify relationships and igraph\n",
    "will automatically build the necessary objects - very convenient!\n",
    "\n",
    "For example, lets create a relationship between Bob and Anne. We can do this by creating a vector of relationships between nodes by listing their names in the right order.\n",
    "\n",
    "Lets say, Bob likes Anne, therefore there is a connection between them:\n",
    "\n",
    "Bob -> Anne\n",
    "\n",
    "We can now put these names into a vector in the right order using the c() function, convert them into a graph object using the graph() function, and assign the object a name using the <- operator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creating a graph object by specfifying a relationship between Bob and Anne\n",
    "g <- graph(c(\"Bob\",\"Anne\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "we can also form a graph object from an existing dataframe if we want to import datasets into R.\n",
    "For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creating a column for sender and one for Nominees with one element each\n",
    "Sender <- \"Bob\"\n",
    "Nominee <- \"Anne\"\n",
    "\n",
    "# binding the vectors together to a dataframe object\n",
    "df <- cbind.data.frame(Sender,Nominee)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# displaying the test dataframe\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use the graph.data.frame()command to build graph objects from dataframes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# overwriting the graph object with the graph object created from a dataframe\n",
    "g <- graph.data.frame(df, directed=T)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lets have a look at how the object is represented internally"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Graph Object\n",
    "g"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see that the graph has two elements and one connection between the elements in the first line.\n",
    "In the second line, we see that the elements have 1 attribute (their name) and that this attribute is stored\n",
    "in  a character vector. In the third and following lines, we see a list of all relationships in the graph."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Adjacency Matrix \n",
    "g[]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One possible representation of a graph object is the so-called adjacency matrix. It specifies who is connected to whom\n",
    "in the graph (1) and which elements in the graph do not have a connection (.). In the graph above, we can see that there is only one connection from Bob to Anne."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the language of igraph, there are two kinds ob objects: Vertices and Edges\n",
    "\n",
    "A Vertex is an entity in the graph. That can be a node in a computer network or some other abstract concept. In our case it´s a human being. An Edge is some form of relationship between two entities. This can be a network connection or a common feature. In our case, it´s Bob liking Anne.\n",
    "\n",
    "NOTE: A Vertex can also be referred to as a node."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can check all the Vertices in our network using the V() command."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Displaying all vertices in the graph\n",
    "V(g)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, we only have two Vertices and could´ve counted them by ourselves. For larger graphs, this might\n",
    "not be feasible. We can use the vcount() command to count all Vertices in a graph object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Counting all vertices in the graph\n",
    "vcount(g)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similarly, we can also check all the edges in our graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Displaying all edges in the graph\n",
    "E(g)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Counting all edges in the graph\n",
    "ecount(g)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Simple Plotting of graph objects"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can easily visualize our graph with the plot() command. for help, see ?plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Plotting the graph object\n",
    "plot(g)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Try to run the cell with the plotting command multiple times. You will notice that hte graph looks different each time.\n",
    "This is because there is some randomness deliberately introduced in the plotting. Lets have a look at four different plots."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# setting the R studio display to 2 x 2 graphic objects\n",
    "par(mfrow=c(2,2))\n",
    "\n",
    "# plotting the same network 4 different times\n",
    "plot(g)\n",
    "plot(g)\n",
    "plot(g)\n",
    "plot(g)\n",
    "\n",
    "# setting the display options back to their default\n",
    "par(mfrow=c(1,1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "During this tutorial, we will plot a lot of different graphs and bigger graphs might look quite different each time even though\n",
    "they are exaclty the same. To facilitate communication and to prevent misunderstanding we would like everyone to produce\n",
    "the same plots for the same graphs. Luckily, this is quite easy in R by setting a seed, which controls the\n",
    "pseudo-random processes in R."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Without a seed we are always getting three different \"random\" numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# picking 3 random numbers between 0 and 10 from a uniform disitribution 3 times\n",
    "runif(3,0,10)\n",
    "runif(3,0,10)\n",
    "runif(3,0,10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, if we set a seed first, we always get the same result:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set.seed(123)\n",
    "runif(3,0,10)\n",
    "\n",
    "set.seed(123)\n",
    "runif(3,0,10)\n",
    "\n",
    "set.seed(123)\n",
    "runif(3,0,10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The same works also for plots of graphs. We will thus always specify a seed first before we plot graphs in this tutorial.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# setting the R studio display to 2 x 2 graphic objects\n",
    "par(mfrow=c(2,2))\n",
    "\n",
    "# plotting the same network 4 different times with the same seed will result in 4 identical networks\n",
    "set.seed(1234)\n",
    "plot(g)\n",
    "\n",
    "set.seed(1234)\n",
    "plot(g)\n",
    "\n",
    "set.seed(1234)\n",
    "plot(g)\n",
    "\n",
    "set.seed(1234)\n",
    "plot(g)\n",
    "\n",
    "# setting the R studio display to 1 x 1 graphic objects\n",
    "par(mfrow=c(1,1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plotting the graph with a specified seed\n",
    "set.seed(123)\n",
    "plot(g)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the plot, we can see an arrow from Bob to Anne, indicating their friendship.\n",
    "The arrow means that the graph is DIRECTED, so in our example, Bob likes Anne but Anne does not like Bob back.\n",
    "Note that this is also visible in the Edge attributes through the directed arrow (->)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "E(g)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lets build a slightly bigger network to get a better grasp on igraph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# In the graph object below, we have quite a few repeating names.\n",
    "# This is because we need to specify each relationship in one vector.\n",
    "# Every pair of names represents one relationship.\n",
    "\n",
    "# Also, we specify that the graph is directed by setting the\n",
    "# directe parameter in the graph function to TRUE.\n",
    "\n",
    "g2 <- graph(c(\"Amy\", \"Ram\",\n",
    "              \"Ram\", \"Li\",\n",
    "              \"Li\", \"Amy\",\n",
    "              \"Amy\", \"Li\",\n",
    "              \"Kate\", \"Li\"), directed=TRUE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# lets have a look at the graph\n",
    "set.seed(123)\n",
    "plot(g2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Network Measures"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Egocentric Indices"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Egocentric indices are measures that describe properties of vertices with respect to their position in the network. In the context of social networks, they describe properties of people within the network."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Degree"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The degree of a node is simply the number of edges that it is connected to. If the graph is directed, we can differentiate\n",
    "between indegree (the number of incoming edges) and outdegree (the number of outgoing edges)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# computing the overall degree of the nodes (incoming & outcoming edges)\n",
    "degree(g2, mode = \"all\")\n",
    "\n",
    "# computing indegree for the nodes (only incoming edges)\n",
    "degree(g2, mode = \"in\")\n",
    "\n",
    "# computing outdegree for the nodes (only outgoing edges)\n",
    "degree(g2, mode = \"out\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see that while Li has a total degree of 4. She is liked by 3 people (incoming edges) but only likes\n",
    "one other person (Amy) back (outgoing edges)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Closeness centrality"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Closeness Centrality is a measure that indicates how well a given node is connected to the rest of the network.\n",
    "\n",
    "For every node, we can look at how well they connect to the rest of the network by calculating the shortest possible paths between a given node and every other node in the graph. Importantly, we can differentiate whether we want to hop along all edges for finding the shortest path, or only along edges that point into the right direction for directed graphs. We can do this by specifying the mode parameter to either \"all\" or \"out\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set.seed(123)\n",
    "plot(g2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because we have a directed graph, we specify that we only want to hop along outgoing edges to find the shortest path\n",
    "between a given set of nodes. For example, to get from Li to Ram, we have to go via Amy, because Ram likes Li, but Li doesn´t like Ram."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# computing a distance matrix for the distances between all nodes\n",
    "Dist <- distances(g2, mode= \"out\")\n",
    "Dist"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because nobody likes Kate in our graph, we are getting values of positive Infinity for the distance between Amy, Ram\n",
    "and Li to Kate. To compute Closeness Centrality, we need a definite value. For this reason, we replace the positive infinity distance\n",
    "in the matrix with the number of total nodes in the network, which is still large in comparison to the other distances,\n",
    "but allows us to compute a value for everyone."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# replacing positive Infinity distances with the number of total vertices in the network\n",
    "Dist[Dist == Inf] <- vcount(g2)\n",
    "Dist"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ww can now compute the closeness centrality of all nodes by taking the reciprocal of the sum of the lengths of all\n",
    "shortest paths from the node to each other node in the graph."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(1)/ rowSums(Dist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Luckily, igraph also has a built-in function that automatically computes the closeness centrality of each node in the network. (The warning occurs because nobody is connected to Kate and we have to use the approximation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ClosenessCentrality <- closeness(g2, mode = \"out\")\n",
    "ClosenessCentrality"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Betweenness centrality"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Betweenness Centrality is a measure indicating how well a vertex connects other vertices with each other.\n",
    "It is quantified as the number of shortest paths between all given nodes in the whole network that pass through the specified node.\n",
    "\n",
    "Lets have a look at an example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# all shortest paths conneting Amy to the Rest of the network\n",
    "shortest_paths(g2,\"Amy\",V(g2), mode = \"out\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# all shortest paths conneting Ram to the Rest of the network\n",
    "shortest_paths(g2,\"Ram\",V(g2), mode = \"out\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# all shortest paths conneting Li to the Rest of the network\n",
    "shortest_paths(g2,\"Li\",V(g2), mode = \"out\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# all shortest paths conneting Kate to the Rest of the network\n",
    "shortest_paths(g2,\"Kate\",V(g2), mode = \"out\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we count the number of shortests paths going through each node:\n",
    "\n",
    "Amy: 2 ;Kate -> Li -> Amy; Kate -> Li -> Amy -> Ram\n",
    "\n",
    "Ram: -\n",
    "\n",
    "Li: 3 ; Kate -> Li -> Amy; Kate -> Li -> Amy -> Ram; Ram -> Li -> Amy\n",
    "\n",
    "Kate: -"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see that two shortest paths of all possible shortest paths go through Amy and 3 shortest paths of all possible\n",
    "shortest paths go through Li. No shortest paths go through Ram or Kate.\n",
    "\n",
    "igraph has a built-in function to compute the betweenness centrality of all nodes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# for the directed graph\n",
    "betweenness(g2, directed = TRUE)\n",
    "\n",
    "# for the undirected graph\n",
    "betweenness(g2, directed = FALSE)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Pagerank"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "another measure for indidividual nodes in a network is the Pagerank. Originally, this measure\n",
    "was designed to describe networks of interlinked websites. Formally, it is the probability that one is\n",
    "on any given node at any time x if one would randomly start on some node and then just navigate the network\n",
    "by its edges."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lets see how the pagerank is calculated by calculating the pagerank for Li"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set.seed(123)\n",
    "plot(g2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We start by assigning the same probability to every node in the network as a starting value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Starting Value\n",
    "1/vcount(g2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We initialize a new attribute for the nodes to specify their pagerank\n",
    "V(g2)$Pagerank <- 1/vcount(g2)\n",
    "V(g2)$Pagerank"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We then need to update the pagerank for each node in the following way:\n",
    "\n",
    "For every node, we look at all other nodes that point to this node.\n",
    "For every node pointing to the specified node, we take their pagerank and\n",
    "devide it by the number of outgoing edges that it has.\n",
    "\n",
    "The new pagerank of the node in question is the sum of all of these values.\n",
    "For example:\n",
    "\n",
    "Li has three neighboring nodes that point to her: Amy, Ram & Kate\n",
    "\n",
    "Amy has a pagerank of 0.25 and two outgoing edges: 0.25/2\n",
    "\n",
    "Ram has a pagerank of 0.25 and one outgoing node: 0.25/1\n",
    "\n",
    "Kate has a pagerank of 0.25 and one outgoing node: 0.25/1\n",
    "\n",
    "\n",
    "The update pagerank for Li is thus: (0.25/2) + (0.25/1) + (0.25/1) = 0.625"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We can compute an updated pagerank for every node by summing the pageranks of all nodes that point\n",
    "# to the node in question, and deviding them by the number of their outgoing edges:\n",
    "\n",
    "# Amy\n",
    "PointersAmy <- neighbors(g2,\"Amy\",\"in\")\n",
    "PointersOutDegreeAmy <- degree(g2, v = PointersAmy, mode = \"out\")\n",
    "UpdatePRAmy <- sum(PointersAmy$Pagerank/PointersOutDegreeAmy)\n",
    "\n",
    "# Ram\n",
    "PointersRam <- neighbors(g2,\"Ram\",\"in\")\n",
    "PointersOutDegreeRam <- degree(g2, v = PointersRam, mode = \"out\")\n",
    "UpdatePRRam <- sum(PointersRam$Pagerank/PointersOutDegreeRam)\n",
    "\n",
    "# Li\n",
    "PointersLi <- neighbors(g2,\"Li\",\"in\")\n",
    "PointersOutDegreeLi <- degree(g2, v = PointersLi, mode = \"out\")\n",
    "UpdatePRLi <- sum(PointersLi$Pagerank/PointersOutDegreeLi)\n",
    "\n",
    "# Kate\n",
    "PointersKate <- neighbors(g2,\"Kate\",\"in\")\n",
    "PointersOutDegreeKate <- degree(g2, v = PointersKate, mode = \"out\")\n",
    "UpdatePRKate <- sum(PointersKate$Pagerank/PointersOutDegreeKate)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# NOTE: It is important that we only update the pageranks after we have calculated every Pagerank with the values from\n",
    "# the initial/previous iteration. Otherwise we would mix values from different iterations and the algorithm would not converge.\n",
    "V(g2)[\"Amy\"]$Pagerank <- UpdatePRAmy\n",
    "V(g2)[\"Ram\"]$Pagerank <- UpdatePRRam\n",
    "V(g2)[\"Li\"]$Pagerank <- UpdatePRLi\n",
    "V(g2)[\"Kate\"]$Pagerank <- UpdatePRKate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "V(g2)[\"Amy\"]$Pagerank \n",
    "V(g2)[\"Ram\"]$Pagerank\n",
    "V(g2)[\"Li\"]$Pagerank\n",
    "V(g2)[\"Kate\"]$Pagerank"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The Pagerank algorithm needs multiple iterations to converge on the correct values. Lets iterate 100 times through it in\n",
    "a loop and plot the convergence for a better overview:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# we create an empty dataframe to store the results of every iteration of the pagerank algorithm\n",
    "df <- data.frame(A=numeric(),\n",
    "                 B=numeric(), \n",
    "                 C=numeric(),\n",
    "                 D=numeric(),\n",
    "                 stringsAsFactors=FALSE) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Number of iterations:\n",
    "x <- 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Iterating through the algorithm x times\n",
    "for (i in 1:x){\n",
    "        \n",
    "        # initialize pagerank on first iteration\n",
    "        if(i == 1){\n",
    "                \n",
    "                V(g2)$Pagerank <- 1/length(V(g2))\n",
    "                df[1,] <- V(g2)$Pagerank\n",
    "        \n",
    "        # update pagerank on all other iterations\n",
    "        } else if (i > 1) {\n",
    "                \n",
    "                # Amy\n",
    "                PointersAmy <- neighbors(g2,\"Amy\",\"in\")\n",
    "                PointersOutDegreeAmy <- degree(g2, v = PointersAmy, mode = \"out\")\n",
    "                UpdatePRAmy <- sum(PointersAmy$Pagerank/PointersOutDegreeAmy)\n",
    "                \n",
    "                # Ram\n",
    "                PointersRam <- neighbors(g2,\"Ram\",\"in\")\n",
    "                PointersOutDegreeRam <- degree(g2, v = PointersRam, mode = \"out\")\n",
    "                UpdatePRRam <- sum(PointersRam$Pagerank/PointersOutDegreeRam)\n",
    "                \n",
    "                # Li\n",
    "                PointersLi <- neighbors(g2,\"Li\",\"in\")\n",
    "                PointersOutDegreeLi <- degree(g2, v = PointersLi, mode = \"out\")\n",
    "                UpdatePRLi <- sum(PointersLi$Pagerank/PointersOutDegreeLi)\n",
    "                \n",
    "                # Kate\n",
    "                PointersKate <- neighbors(g2,\"Kate\",\"in\")\n",
    "                PointersOutDegreeKate <- degree(g2, v = PointersKate, mode = \"out\")\n",
    "                UpdatePRKate <- sum(PointersKate$Pagerank/PointersOutDegreeKate)\n",
    "                \n",
    "                # NOTE: It is important that we only update the pageranks after we have calculated every Pagerank with the values from\n",
    "                # the initial/previous iteration. Otherwise we would mix values from different iterations and the algorithm would not converge.\n",
    "                V(g2)[\"Amy\"]$Pagerank <- UpdatePRAmy\n",
    "                V(g2)[\"Ram\"]$Pagerank <- UpdatePRRam\n",
    "                V(g2)[\"Li\"]$Pagerank <- UpdatePRLi\n",
    "                V(g2)[\"Kate\"]$Pagerank <- UpdatePRKate\n",
    "                \n",
    "                # Printing result\n",
    "                print(V(g2)$Pagerank)\n",
    "                \n",
    "                # saving output in a dataframe for visulaization\n",
    "                df[i,] <- V(g2)$Pagerank\n",
    "                \n",
    "        }\n",
    "        \n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Lets visualize the iterations:\n",
    "matplot(as.matrix(df),\n",
    "        type = \"l\",\n",
    "        pch=3,\n",
    "        col = 1:4,\n",
    "        xlab = \"Iteration\",\n",
    "        ylab = \"Pagerank Score\",\n",
    "        main = \"Iterations of Pagerank Score Algorithm\") \n",
    "\n",
    "# adding a legend\n",
    "legend(\"topright\",\n",
    "       legend=c(\"Amy\",\"Ram\",\"Li\",\"Kate\"),\n",
    "       col=c(\"green\",\"red\",\"black\",\"blue\"),\n",
    "       pch = \"-\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Luckily, igraph has a built-in function that does all of this automatically:\n",
    "Pagerank <- page.rank(g2)$vector\n",
    "Pagerank\n",
    "        \n",
    "# Note that the values from the built-in function are slightly different from the ones we obtained.\n",
    "# This is because the implementation of the algorithm in igraph is more elaborate to account for edges with no indegree\n",
    "# (like Kate) or outdegree. If you want to use pageranks for your analyses, you should rely on the function provided\n",
    "# by igraph."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Sociocentric Indices"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sociocentric Indexes are measures that describe the network as a whole and make different networks comparable with each other"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Diameter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The diameter is the longest possible path between any two nodes in the graph. A high diameter usually means that there are at least\n",
    "some nodes in the graph that are not connected well with each other. It could for example be an indication of multiple clusters\n",
    "of people in a social network graph."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In our example, the longest possible paths for the UNDIRECTED graph are:\n",
    "\n",
    "A) Ram being connected to Kate VIA Li\n",
    "\n",
    "B) Amy being connected to Kate VIA Li"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set.seed(123)\n",
    "plot(as.undirected(g2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the DIRECTED graph, the longest possible path would be \n",
    "\n",
    "A) Kate being connected to Ram VIA Li VIA Amy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set.seed(123)\n",
    "plot(g2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "igraph has a built-in function to automatically find the diameter of directed and undirected graphs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# diameter of the network when treating it as undirected\n",
    "diameter(g2, directed=FALSE)\n",
    "\n",
    "# diameter of the network when treating it as directed\n",
    "diameter(g2, directed=TRUE)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Edge Density"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also calculate the density of the graph. This is a metric that allows us to evaluate how\n",
    "connected the vertices are. It can for example be used to compare different groups of friends. To compute it, we devide\n",
    "the number of all edges in the graph by the number of all POSSIBLE edges that could theoretically exist:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The number of all possile edges in a network is defined by the number of vertices times the number of vertices minus 1.\n",
    "# So for our example:\n",
    "(vcount(g2)*(vcount(g2)-1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We compute edge density as the numer of existing edges in the graph devided by all theoretically possible edges\n",
    "ecount(g2)/((vcount(g2)*(vcount(g2)-1)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Our graph has an edge densitiy of 0.4166, that means that 41.66% of all possible edges are contained in our graph."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# igraph also has a built-in function for this:\n",
    "edge_density(g2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Reciprocity"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also compute the reciprocity of the graph.\n",
    "Reciprocity is a measure of the likelihood of vertices to be mutually linked.\n",
    "As such, it only makes sense in directed graphs. It is computed as the ratio\n",
    "of reciprocated relationships devided by all relationships"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In total, we have 5 relationships:\n",
    "\n",
    "Amy -> Li\n",
    "\n",
    "Li -> Amy\n",
    "\n",
    "Amy -> Ram\n",
    "\n",
    "Ram -> Li\n",
    "\n",
    "Kate -> Li\n",
    "\n",
    "In our example, we have two reciprocated relationships:\n",
    "\n",
    "Amy -> Li\n",
    "\n",
    "Li -> Amy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We can thus calculate reciprocity of the network as:\n",
    "reciprocity <- 2/5;reciprocity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# igraph also has a built-in function for this:\n",
    "reciprocity(g2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Vertex and Edge attributes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Vertex Attributes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So far, we have created vertices and edges and computed metrics for individual vertices or for the whole network.\n",
    "Importantly, we treated every vertex and every edge equally so far.\n",
    "Of course, this is not realistic because people (vertices) are different from each other and have different\n",
    "relationships with each other"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "in igraph, we can assign vertices and edges attributes to attach more information to our graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# consider our plot so far:\n",
    "plot(g2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "we could for example assign gender, age and occupation to the nodes in our network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# assigning properties\n",
    "V(g2)$gender <- c(\"female\",\"male\",\"female\",\"female\")\n",
    "V(g2)$age <- c(32,26,43,29)\n",
    "V(g2)$occupation <- c(\"PhD\",\"PhD\",\"Prof\",\"PhD\")\n",
    "\n",
    "# inspecting properties\n",
    "V(g2)\n",
    "V(g2)$gender \n",
    "V(g2)$age \n",
    "V(g2)$occupation "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Edge Atrtibutes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "similarly, we can add attributes to edges, for example to specify different kinds of social\n",
    "interactions or different frequencies of face-to-face contact"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Adding Attributes \n",
    "E(g2)$relationships <- c(\"likes\",\"supervised by\",\"mentoring\",\"supervised by\",\"supervised by\")\n",
    "E(g2)$contactFreq <- c(5,1,2,2,1)\n",
    "\n",
    "#inspecting attributes\n",
    "E(g2)\n",
    "E(g2)$relationships \n",
    "E(g2)$contactFreq\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plotting graphs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have already plotted a very basic graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set.seed(123)\n",
    "plot(g2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This graph does not look particularly nice and does not display all the information that we might like to be displayed.\n",
    "Lets try to change some graphic parameters to make it more visually appealing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Lets try to change some visual characteristics:\n",
    "set.seed(123)\n",
    "plot(g2,\n",
    "     vertex.color = \"lightblue\", # changing vertex color\n",
    "     vertex.size = 20,           # changing vertex size\n",
    "     edge.color = 'black',       # changing edge color\n",
    "     edge.arrow.size = 0.6,      # changing size of edge arrow\n",
    "     main = \"Example Plot\")      # adding headline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The graph does look a bit better but is not really much more informative. Lets also add the extra information that we have about the different nodes to the graphical display of our graph.\n",
    "\n",
    "Lets say we want to use different colours for different genders, different shapes for different occupations\n",
    " and different node sizes for different ages\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Plotting Vertex attributes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### gender & colour"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can assign different vertex colours in plot() with the vertex.color command"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# setting display to three graphics next to each other\n",
    "par(mfrow = c(1,3))\n",
    "\n",
    "# plotting basic graph\n",
    "set.seed(123)\n",
    "plot(g2)\n",
    "\n",
    "# plotting graph with all vertices having the same other color\n",
    "set.seed(123)\n",
    "plot(g2,vertex.color = \"grey\")\n",
    "\n",
    "# plotting graph with all vertices having a different color\n",
    "set.seed(123)\n",
    "plot(g2,vertex.color = c(\"red\",\"blue\",\"green\",\"yellow\"))\n",
    "\n",
    "# setting display option back to one plot at a time\n",
    "par(mfrow = c(1,1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We need a way to translate the vector of gender attributes into a usefull colour vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We create a new vertex attribute for color and set it to blue for all vertices whose gender attribute is male\n",
    "# and to red for all vertices whose gender attribute is female\n",
    "\n",
    "# creating new vector\n",
    "vex.color <- seq_along(V(g2)$gender)\n",
    "\n",
    "# \"translating attributes to colors\"\n",
    "vex.color[V(g2)$gender == \"male\"] <- \"lightblue\"\n",
    "vex.color[V(g2)$gender == \"female\"] <- \"lightcoral\"\n",
    "\n",
    "vex.color"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now use the new vector as input for the color parameter in the plotting function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plotting the graph with vertex colour based on gender\n",
    "plot(g2, vertex.color = vex.color)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Occupation & Shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can change the shape of nodes with the vertex.shapes parameter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# setting display to three graphics next to each other\n",
    "par(mfrow = c(1,3))\n",
    "\n",
    "# plotting basic graph\n",
    "set.seed(123)\n",
    "plot(g2,vertex.color = vex.color)\n",
    "\n",
    "# plotting graph with all vertices having the same other color\n",
    "set.seed(123)\n",
    "plot(g2, vertex.color = vex.color,vertex.shape = \"square\")\n",
    "\n",
    "# plotting graph with all vertices having a different color\n",
    "set.seed(123)\n",
    "plot(g2, vertex.color = vex.color,vertex.shape = c(\"square\",\"circle\",\"sphere\",\"none\"))\n",
    "\n",
    "# setting display option back to one plot at a time\n",
    "par(mfrow = c(1,1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We need to transform the vector of occupations into a valid vector of shapes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# initilalizing new vector\n",
    "vex.shapes <- seq_along(V(g2)$occupation)\n",
    "\n",
    "# \"translating\" occupations into shape atrtibutes\n",
    "vex.shapes[V(g2)$occupation == \"PhD\"] <- \"circle\"\n",
    "vex.shapes[V(g2)$occupation == \"Prof\"] <- \"square\"\n",
    "\n",
    "# plotting the graph with different shapes for different occupations\n",
    "set.seed(123)\n",
    "plot(g2, vertex.color = vex.color,vertex.shape = vex.shapes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Age & Vertex size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "we can change the size of the vertices through the vertex.size command (default is 15)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# setting display to three graphics next to each other\n",
    "par(mfrow = c(1,3))\n",
    "\n",
    "# plotting basic graph\n",
    "set.seed(123)\n",
    "plot(g2, vertex.color = vex.color,vertex.shape = vex.shapes)\n",
    "\n",
    "# plotting graph with all vertices having the same other size\n",
    "set.seed(123)\n",
    "plot(g2, vertex.color = vex.color,vertex.shape = vex.shapes, vertex.size = 50)\n",
    "\n",
    "# plotting graph with all vertices having a different size\n",
    "set.seed(123)\n",
    "plot(g2, vertex.color = vex.color,vertex.shape = vex.shapes, vertex.size = c(10,60,20,40))\n",
    "\n",
    "# setting display option back to one plot at a time\n",
    "par(mfrow = c(1,1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We need to transform the age vector into a vector for vertex size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# initilalizing new vector\n",
    "vex.size <- V(g2)$age*1.5 # We have to play around with the multiplicator to find a good value for grapical representation\n",
    "\n",
    "# plotting the graph with different node sizes representing age\n",
    "set.seed(123)\n",
    "plot(g2, vertex.color = vex.color,vertex.shape = vex.shapes, vertex.size = vex.size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Plotting edge attributes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have incorporated information about node attributes into our graph, but we can also incorporate information\n",
    "about the edges that connect them.\n",
    "\n",
    "For example, we can change the type of the line to represent the nature of their relationship and the\n",
    "thickness of the line to represent the frequency of interaction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "E(g2)\n",
    "E(g2)$relationships\n",
    "E(g2)$contactFreq"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Relationship Type & Edge Type"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can change the line type of the edges using the edge.lty command"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# changing the linetype for all edges\n",
    "set.seed(123)\n",
    "plot(g2,\n",
    "     vertex.color = vex.color,\n",
    "     vertex.shape = vex.shapes,\n",
    "     vertex.size = vex.size,\n",
    "     edge.lty = 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# giving each edge a different type of line\n",
    "set.seed(123)\n",
    "plot(g2,\n",
    "     vertex.color = vex.color,\n",
    "     vertex.shape = vex.shapes,\n",
    "     vertex.size = vex.size,\n",
    "     edge.lty = c(1,2,3,4,5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We need to transform the vector of relationship types into a vector of valid edge line parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# initilaizing new vector\n",
    "edge.Type <- seq_along(E(g2)$relationships)\n",
    "\n",
    "# translating relationship types into valid edge line attributes\n",
    "edge.Type[E(g2)$relationships == \"supervised by\"] <- 3\n",
    "edge.Type[E(g2)$relationships == \"likes\"] <- 5\n",
    "edge.Type[E(g2)$relationships == \"mentoring\"] <- 7"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now plot the graph with different edges based on different relationships"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plotting the graph\n",
    "set.seed(123)\n",
    "plot(g2,\n",
    "     vertex.color = vex.color,\n",
    "     vertex.shape = vex.shapes,\n",
    "     vertex.size = vex.size,\n",
    "     edge.lty = edge.Type)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Interaction Frequency & Edge Width"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can incorporate the information about how frequently people interact in the plot as the width of the edges\n",
    "that are connecting the vertices"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can change the width of the edges using the edge.width command (default is 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# changing the width of all edges\n",
    "set.seed(123)\n",
    "plot(g2,\n",
    "     vertex.color = vex.color,\n",
    "     vertex.shape = vex.shapes,\n",
    "     vertex.size = vex.size,\n",
    "     edge.lty = edge.Type,\n",
    "     edge.width = 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# giving each edge a different width\n",
    "set.seed(123)\n",
    "plot(g2,\n",
    "     vertex.color = vex.color,\n",
    "     vertex.shape = vex.shapes,\n",
    "     vertex.size = vex.size,\n",
    "     edge.lty = edge.Type,\n",
    "     edge.width = c(1,2,3,4,5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We can use the interaction frequency as a direct input for the edge width\n",
    "set.seed(123)\n",
    "plot(g2,\n",
    "     vertex.color = vex.color,\n",
    "     vertex.shape = vex.shapes,\n",
    "     vertex.size = vex.size,\n",
    "     edge.lty = edge.Type,\n",
    "     edge.width = E(g2)$contactFreq)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are a lot of different styling options for plotting graph objects, you can see an overview here:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plot(\"Some Network\",\n",
    "     vertex.size = 25, # Size of the Vertices, default is 15\n",
    "     vertex.size2 = 15, # second size parameter, only needed for some shapes (e.g. rectangles); default is 15\n",
    "     vertex.color = \"SkyBlue2\", # Vertex colour; default is \"SkyBlue2\", if numeric then the current palette is used; also takes named colours or RGB values starting with # and having 3-4 bytes, no colour -> supply NA\n",
    "     vertex.frame.color = \"black\", # colour of vertex frame, default is \"black\", same formats as for colour are allowed, no frame -> supply NA\n",
    "     vertex.shape = \"circle\", # shape of the vertices, supports “circle”, “square”, “csquare”, “rectangle”, “crectangle”, “vrectangle”, “pie”, ‘sphere’, and “none”\n",
    "     vertex.label = c(), # labels for vertices, default are vertexs Ids, supply NA if you dont want to display any labels\n",
    "     vertex.label.family = \"\", # the font family to use for the labels\n",
    "     vertex.label.font=\"\", # the font within the font family to use for labels\n",
    "     vertex.label.cex = 1, # font size for vertex labels, default is 1\n",
    "     vertex.label.dist= 0, # distance of the label from the center of the vertex, default is 0\n",
    "     vertex.label.degree= -pi/4, #  It defines the position of the vertex labels, relative to the center of the vertices. It is interpreted as an angle in radian, zero means ‘to the right’, and ‘pi’ means to the left, up is -pi/2 and down is pi/2.The default value is -pi/4.\n",
    "     vertex.label.color = \"black\", # colour of the vertex labels, default is \"black\", takes some input is vertex.color\n",
    "     edge.color = \"\", # color of the edges, default is \"darkgrey\", takes some input is vertex.color\n",
    "     edge.width = \"\", # the width of the edges, deafult value is 1\n",
    "     edge.arrow.size = 0.5, # size of the arrows for directed edges, default is 1\n",
    "     edge.arrow.width = 0.5, # width of the arrows for directed edges, default is 1\n",
    "     edge.lty = 1, # The line type for the edges. Almost the same format is accepted as for the standard graphics par, 0 and “blank” mean no edges, 1 and “solid” are for solid lines, the other possible values are: 2 (“dashed”), 3 (“dotted”), 4 (“dotdash”), 5 (“longdash”), 6 (“twodash”). \n",
    "     edge.label = NA, #     The edge labels. They will be converted to character. Specify NA to omit edge labels. Edge labels are omitted by default.\n",
    "     edge.label.family = , # Font family of the edge labels. See the vertex parameter with the same name for the details.\n",
    "     edge.label.font = , # The font for the edge labels. See the corresponding vertex parameter discussed earlier for details\n",
    "     edge.label.cex = 1, # The font size for the edge labels, see the corresponding vertex parameter for details.\n",
    "     edge.label.color = c(\"green\",\"blue\"), # The color of the edge labels, see the color vertex parameters on how to specify colors.\n",
    "     edge.label.x = NA, # horizontal coordinates for edge labels\n",
    "     edge.label.y = NA, # vertical coordinates for edge labels\n",
    "     edge.curved = 0, # default is 0, meaning straight edges, can be a positive (blockwise) or negative (counter-clockwise) bent\n",
    "     edge.arrow.mode = , # This parameter can be used to specify for which edges should arrows be drawn. If it is integer then 0 means no arrows, 1 means backward arrows, 2 is for forward arrows and 3 for both. If it is a character vector then “<” and “<-” specify backward, “>” and “->” forward arrows and “<>” and “<->” stands for both arrows. All other values mean no arrows, perhaps you should use “-” or “–” to specify no arrows. \n",
    "     edge.loop.angle = 0, # Gives the angle in radian for plotting loop edges. See the label.dist vertex parameter to see how this is interpreted. The default value is 0.\n",
    "     edge.loop.angle2 = 0, # Default is 0. Gives the second angle in radian for plotting loop edges. This is only used in 3D, loop.angle is enough in 2D. \n",
    "     layout = layout_nicely(), # takes either a function or a matrix with coordinstes for each vertex as Input. Default is the function layout_nicely. See http://igraph.org/r/doc/layout_nicely.html for a list of build-in layout function\n",
    "     margin = c(0,0,0,0), # The amount of empty space below, over, at the left and right of the plot, it is a numeric vector of length four. Default is c(0,0,0,0)\n",
    "     palette = \"categorical_pal\", # The color palette to use for vertex color. The default is categorical_pal, which is a color-blind friendly categorical palette. See its manual page for details and other palettes.\n",
    "     rescale = TRUE, # Logical constant, whether to rescale the coordinates to the [-1,1]x[-1,1](x[-1,1]) interval. Default is TRUE\n",
    "     asp = 1, # Defaults to 1. A numeric constant, it gives the aspect ratio. Supply 0 here if you don't want to give an aspect ratio.\n",
    "     main = \"\", # heading for the graph\n",
    "     frame = FALSE, # Boolean, whether to plot a frame around the graph.  Defaults to FALSE\n",
    "     sub = \"\", # Subtitle of the main plot, the default is empty.\n",
    "     xlab = \"\", # Title for the x axis, the default is empty \n",
    "     ylab = \"\"  # Title for the y axis, the default is empty \n",
    ")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "R",
   "language": "R",
   "name": "ir"
  },
  "language_info": {
   "codemirror_mode": "r",
   "file_extension": ".r",
   "mimetype": "text/x-r-source",
   "name": "R",
   "pygments_lexer": "r",
   "version": "3.4.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}