First commit of MAMMULT documentation

47 files changed, 2013 insertions, 0 deletions

diff --git a/doc/latex/latex/dynamics/Ising/multiplex_ising.tex b/doc/latex/latex/dynamics/Ising/multiplex_ising.tex
new file mode 100644
index 0000000..ec87454
--- /dev/null
+++ b/doc/latex/latex/dynamics/Ising/multiplex_ising.tex
@@ -0,0 +1,22 @@
+%%%
+%%% Layer activity
+%%%
+
+\myprogram{{multiplex\_ising}}
+          {compute the coupled ising model in a multiplex with $2$ layers.}
+          {$<$layer1$>$ $<$layer2$>$ $<$T$>$ $<$J$>$ $<\gamma>$ $<h^{[1]}>$ $<h^{[2]}>$ $<p_1>$ $<p_2>$ $<num epochs>$}
+
+\mydescription{Compute and print the output of the ising dynamics on two coupled layers of a multiplex network.
+  Files \textit{layer1}, \textit{layer2}, contain the (undirected) edge list of the two layer, and each
+  line is in the format:
+  
+  \hspace{0.5cm}\textit{src\_ID} \textit{dest\_ID}
+  
+  where \textit{src\_ID} and \textit{dest\_ID} are the IDs of the two
+  endpoints of an edge.
+
+ $T$ is the value of thermal noise in the system, $J$ the value of peer pressure, $\gamma$ the relative ratio between internal coupling and peer pressure, $h^{[1]}$ and $h^{[2]}$ the external fields acting on the two layers, $p_1$ the probability for a spin on layer $1$ at $t=0$ to be up, $p_2$ the same probability for spins on layer $2$, $num epochs$ the number of epochs for the simulation.} 
+
+\myreturn{One line, reporting all controlling parameter, the value of consensus in layer $1$ $m^{[1]}$, the value of consensus in layer $2$ $m^{[2]}$ and the coherence $C$.}
+
+\myreference{\refising}
diff --git a/doc/latex/latex/dynamics/randomwalks/entropyrate2add.tex b/doc/latex/latex/dynamics/randomwalks/entropyrate2add.tex
new file mode 100644
index 0000000..98a432b
--- /dev/null
+++ b/doc/latex/latex/dynamics/randomwalks/entropyrate2add.tex
@@ -0,0 +1,24 @@
+%%%
+%%% Layer activity
+%%%
+
+\myprogram{{entropyrate2add}}
+          {compute the entropy rate of additive biased walks in a multiplex with $2$ layers.}
+          {$<$layer1$>$ $<$layer2$>$ $<overlapping network>$ $<$N$>$ $b_1$ $b_2$}
+
+\mydescription{Compute and print the entropy rate of an additive biased walk in a multiplex with $2$ layers and bias parameters $b_1$ and $b_2$.
+  Files \textit{layer1}, \textit{layer2}, contain the (undirected) edge list of the two layer, and each
+  line is in the format:
+  
+  \hspace{0.5cm}\textit{src\_ID} \textit{dest\_ID}
+  
+  where \textit{src\_ID} and \textit{dest\_ID} are the IDs of the two
+  endpoints of an edge.
+
+  The file \textit{overlapping network} has also a third column indicating the number of times two nodes are connected across all layers.
+
+ $N$ is the number of nodes, $b_1$ is the degree-biased exponent for layer $1$, $b_2$ is the degree-biased exponent for layer $2$.} 
+
+\myreturn{One line, reporting the value of the entropy rate $h$ of an additive biased random walks with $b_1$ and $b_2$ as bias exponents, $b_1$ and $b_2$.}
+
+\myreference{\refbiased}
diff --git a/doc/latex/latex/dynamics/randomwalks/entropyrate2int.tex b/doc/latex/latex/dynamics/randomwalks/entropyrate2int.tex
new file mode 100644
index 0000000..8a337f4
--- /dev/null
+++ b/doc/latex/latex/dynamics/randomwalks/entropyrate2int.tex
@@ -0,0 +1,24 @@
+%%%
+%%% Layer activity
+%%%
+
+\myprogram{{entropyrate2int}}
+          {compute the entropy rate of intensive biased walks in a multiplex with $2$ layers.}
+          {$<$layer1$>$ $<$layer2$>$ $<overlapping network>$ $<$N$>$ $b_1$ $b_2$}
+
+\mydescription{Compute and print the entropy rate of an intensive biased walks in a multiplex with $2$ layers and bias parameters $b_p$ and $b_o$.
+  Files \textit{layer1}, \textit{layer2}, contain the (undirected) edge list of the two layer, and each
+  line is in the format:
+  
+  \hspace{0.5cm}\textit{src\_ID} \textit{dest\_ID}
+  
+  where \textit{src\_ID} and \textit{dest\_ID} are the IDs of the two
+  endpoints of an edge.
+
+  The file \textit{overlapping network} has also a third column indicating the number of times two nodes are connected across all layers.
+
+ $N$ is the number of nodes, $b_p$ is the biased exponent on the participation coefficient, $b_o$ is the biased exponent on the overlapping degree.} 
+
+\myreturn{One line, reporting the value of the entropy rate $h$ of an intensive biased random walks with $b_p$ and $b_o$ as bias exponents, $b_p$ and $b_o$.}
+
+\myreference{\refbiased}
diff --git a/doc/latex/latex/dynamics/randomwalks/entropyrate2mult.tex b/doc/latex/latex/dynamics/randomwalks/entropyrate2mult.tex
new file mode 100644
index 0000000..7abfecd
--- /dev/null
+++ b/doc/latex/latex/dynamics/randomwalks/entropyrate2mult.tex
@@ -0,0 +1,24 @@
+%%%
+%%% Layer activity
+%%%
+
+\myprogram{{entropyrate2mult}}
+          {compute the entropy rate of multiplicative biased walks in a multiplex with $2$ layers.}
+          {$<$layer1$>$ $<$layer2$>$ $<overlapping network>$ $<$N$>$ $b_1$ $b_2$}
+
+\mydescription{Compute and print the entropy rate of a multiplicative biased walk in a multiplex with $2$ layers and bias parameters $b_1$ and $b_2$.
+  Files \textit{layer1}, \textit{layer2}, contain the (undirected) edge list of the two layer, and each
+  line is in the format:
+  
+  \hspace{0.5cm}\textit{src\_ID} \textit{dest\_ID}
+  
+  where \textit{src\_ID} and \textit{dest\_ID} are the IDs of the two
+  endpoints of an edge.
+
+  The file \textit{overlapping network} has also a third column indicating the number of times two nodes are connected across all layers.
+
+ $N$ is the number of nodes, $b_1$ is the degree-biased exponent for layer $1$, $b_2$ is the degree-biased exponent for layer $2$.} 
+
+\myreturn{One line, reporting the value of the entropy rate $h$ of an multiplicative biased random walks with $b_1$ and $b_2$ as bias exponents, $b_1$ and $b_2$.}
+
+\myreference{\refbiased}
diff --git a/doc/latex/latex/dynamics/randomwalks/statdistr2.tex b/doc/latex/latex/dynamics/randomwalks/statdistr2.tex
new file mode 100644
index 0000000..09c1bc2
--- /dev/null
+++ b/doc/latex/latex/dynamics/randomwalks/statdistr2.tex
@@ -0,0 +1,24 @@
+%%%
+%%% Layer activity
+%%%
+
+\myprogram{{statdistr2}}
+          {compute the stationary distribution of additive, multiplicative and intensive biased walks in a multiplex with $2$ layers.}
+          {$<$layer1$>$ $<$layer2$>$ $<overlapping network>$ $<$N$>$ $b_1$ $b_2$}
+
+\mydescription{Compute and print the stationary distribution of additive, multiplicative and intensive biased walks in a multiplex with $2$ layers.
+  Files \textit{layer1}, \textit{layer2}, contain the (undirected) edge list of the two layer, and each
+  line is in the format:
+  
+  \hspace{0.5cm}\textit{src\_ID} \textit{dest\_ID}
+  
+  where \textit{src\_ID} and \textit{dest\_ID} are the IDs of the two
+  endpoints of an edge.
+
+  The file \textit{overlapping network} has also a third column indicating the number of times two nodes are connected across all layers.
+
+ $N$ is the number of nodes, $b_1$ is the first bias exponent (the bias exponent for layer $1$ for additive and multiplicative walks, the bias exponent on the participation coefficient for intensive walks), $b_2$ is the second bias exponent (the bias exponent for layer $1$ for additive and multiplicative walks, the bias exponent on the participation coefficient for intensive walks).} 
+
+\myreturn{N lines. In the n-th line we report the node ID, the stationary distribution of that node for additive walks with exponents $b_1$ and $b_2$, the stationary distribution for multiplicative walks with exponents $b_1$ and $b_2$, the stationary distribution for multiplicative walks with exponents $b_1$ and $b_2$, the values of the bias exponents $b_1$ and $b_2$.}
+
+\myreference{\refbiased}
diff --git a/doc/latex/latex/models/correlations/tune_qnn_adaptive.tex b/doc/latex/latex/models/correlations/tune_qnn_adaptive.tex
new file mode 100644
index 0000000..016b674
--- /dev/null
+++ b/doc/latex/latex/models/correlations/tune_qnn_adaptive.tex
@@ -0,0 +1,64 @@
+\myprogram{{tune\_qnn\_adaptive}}
+          {Construct a multiplex with prescribed inter-layer correlations.} 
+          {$<$degs1$>$  $<$degs2$>$ $<$mu$>$ $<$eps$>$ $<$beta$>$ [RND|NAT|INV]}
+
+\mydescription{This programs tunes the inter-layer degree correlation
+          exponent $\mu$. If we consider two layers of a multiplex,
+          and we denote by $k$ the degree of a node on the first layer
+          and by $q$ the degree of the same node on the second layers,
+          the inter-layer degree correlation function is defined as:
+          
+          \begin{equation*}
+            \overline{q}(k) = \sum_{q'} q' P(q'|k)
+          \end{equation*}
+
+           where $\overline{q}(k)$ is the average degree on layer $2$
+           of nodes having degree $k$ on layer $1$. 
+
+           The program assumes that we want to set the degree
+           correlation function such that:
+
+           \begin{equation*}
+           \overline{q}(k) = a k^{\mu}
+           \end{equation*}
+           
+           where the exponent of the power-law function is given by
+           the user (it is indeed the parameter \textit{mu}), and
+           successively adjusts the pairing between nodes at the two
+           layers in order to obtain a correlation function as close
+           as possible to the desired one. The files \textit{degs1}
+           and \textit{degs2} contain, respectively, the degrees of
+           the nodes on the first layer and on the second layer. 
+           
+           The parameter \textit{eps} is the accuracy of \textit{mu}.
+           For instance, if \textit{mu} is set equal to -0.25
+           and \textit{eps} is equal to 0.0001, the program stops when
+           the configuration of node pairing corresponds to a value of
+           the exponent $\mu$ which differs from -0.25 by less than
+           0.0001.
+
+          The parameter \textit{beta} is the typical inverse
+          temperature of simulated annealing.
+
+          If no other parameter is specified, or if the last parameter
+          is \texttt{RND}, the program starts from a random pairing of
+          nodes. If the last parameter is \texttt{NAT} then the
+          program assumes that the initial pairing is the natural one,
+          where the nodes have the same ID on both layers. Finally,
+          if \texttt{INV} is specified, the initial pairing is the
+          inverse pairing, i.e. the one where node 0 on layer 1 is
+          paired with node N-1 on layer 2, and so on.
+
+ }
+
+
+\myreturn{The program prints on \texttt{stdout} a pairing, i.e. a list
+of lines in the format:
+
+\hspace{0.5cm} \textit{IDL1 IDL2}
+
+where \textit{IDL1} is the ID of the node on layer 1 and \textit{IDL2}
+is the corresponding ID of the same node on layer 2.
+}
+
+\myreference{\refcorrelations}
diff --git a/doc/latex/latex/models/correlations/tune_rho.tex b/doc/latex/latex/models/correlations/tune_rho.tex
new file mode 100644
index 0000000..27b6079
--- /dev/null
+++ b/doc/latex/latex/models/correlations/tune_rho.tex
@@ -0,0 +1,45 @@
+\myprogram{{tune\_rho}}
+          {Construct a multiplex with prescribed inter-layer correlations.} 
+          {$<$rank1$>$  $<$rank2$>$ $<$rho$>$ $<$eps$>$ $<$beta$>$ [RND|NAT|INV]}
+
+\mydescription{This programs tunes the inter-layer degree correlation
+          coefficient $\rho$ (Spearman's rank correlation) of two
+          layers, by adjusting the inter-layer pairing of nodes. The
+          files \textit{rank1} and \textit{rank2} are the rankings of
+          nodes in the first and second layer, where the n-th line of
+          the file contains the rank of the n-th node (the highest
+          ranked node has rank equal to 1).
+
+          The parameter \textit{rho} is the desired value of the
+          Spearman's rank correlation coefficient, while \textit{eps}
+          is the accuracy of \textit{rho}. For instance,
+          if \textit{rho} is set equal to -0.25 and \textit{eps} is
+          equal to 0.0001, the program stops when the configuration of
+          node pairing corresponds to a value of $\rho$ which differs
+          from -0.25 by less than 0.0001.
+
+          The parameter \textit{beta} is the typical inverse
+          temperature of simulated annealing. 
+
+          If no other parameter is specified, or if the last parameter
+          is \texttt{RND}, the program starts from a random pairing of
+          nodes. If the last parameter is \texttt{NAT} then the
+          program assumes that the initial pairing is the natural one,
+          where the nodes have the same ID on both layers. Finally,
+          if \texttt{INV} is specified, the initial pairing is the
+          inverse pairing, i.e. the one where node 0 on layer 1 is
+          paired with node N-1 on layer 2, and so on.
+
+ }
+
+
+\myreturn{The program prints on \texttt{stdout} a pairing, i.e. a list
+of lines in the format:
+
+\hspace{0.5cm} \textit{IDL1 IDL2}
+
+where \textit{IDL1} is the ID of the node on layer 1 and \textit{IDL2}
+is the corresponding ID of the same node on layer 2.
+}
+
+\myreference{\refcorrelations}
diff --git a/doc/latex/latex/models/growth/nibilab_linear_delay.tex b/doc/latex/latex/models/growth/nibilab_linear_delay.tex
new file mode 100644
index 0000000..afbf083
--- /dev/null
+++ b/doc/latex/latex/models/growth/nibilab_linear_delay.tex
@@ -0,0 +1,67 @@
+\myprogram{{nibilab\_linear\_delay}}
+          {Multiplex linear preferential attachment model --
+          Asynchronous arrival.}  
+          {$<$N$>$ $<$m$>$ $<$m0$>$ $<$outfile$>$ $<$a$>$ $<$b$>$
+          $<$c$>$ $<$d$>$ $<$beta$>$}
+
+\mydescription{Grow a two-layer multiplex network using the multiplex linear
+          preferential attachment model by Nicosia, Bianconi, Latora,
+          Barthelemy (NiBiLaB).
+
+          The probability for a newly arrived node $i$ to create a
+          link to node $j$ on layer $1$ is:
+          
+          \begin{equation*}
+          \Pi_{i\to j}^{1} \propto ak\lay{1}_j + bk\lay{2}_j
+          \end{equation*}
+
+          and the dual probability for $i$ to create a link to $j$ on
+          layer $2$ is:
+
+          \begin{equation*}
+          \Pi_{i\to j}^{2} \propto ck\lay{1}_j + dk\lay{2}_j
+          \end{equation*}
+          
+          Each new node arrives first on layer $1$, and its replica on
+          the layer $2$ appears after a time delay $\tau$ sampled from
+          the power-law function:
+
+          \begin{equation*}
+            P(\tau) \sim \tau^{-\beta}
+          \end{equation*}
+
+          The (mandatory) parameters are as follows:
+
+          \begin{itemize}
+
+          \item \textbf{N} number of nodes in the final graph
+
+          \item \textbf{m} number of new edges brought by each new node
+
+          \item \textbf{m0} number of nodes in the initial seed
+                    graph. \textit{m0} must be larger than of equal
+                    to \textit{m}.
+
+          \item \textbf{outfile} the name of the file which will contain the            
+          
+          \item \textbf{a,b,c,d} the coefficients of the attaching probability
+          function
+
+          \item \textbf{beta} the exponent of the power-law delay
+          function which determines the arrival of replicas on layer $2$
+
+          \end{itemize}
+ }
+
+
+\myreturn{The program dumps on the file \texttt{outfile} the
+ (undirected) edge list of the resulting network. Each line of the
+ file is in the format:
+  
+  \hspace{0.5cm}\textit{src\_ID} \textit{dest\_ID}
+  
+  where \textit{src\_ID} and \textit{dest\_ID} are the IDs of the two
+  endpoints of an edge.
+}
+
+\myreference{\refgrowth}
diff --git a/doc/latex/latex/models/growth/nibilab_linear_delay_mix.tex b/doc/latex/latex/models/growth/nibilab_linear_delay_mix.tex
new file mode 100644
index 0000000..5863951
--- /dev/null
+++ b/doc/latex/latex/models/growth/nibilab_linear_delay_mix.tex
@@ -0,0 +1,68 @@
+\myprogram{{nibilab\_linear\_delay\_mix}}
+          {Multiplex linear preferential attachment model --
+          Asynchronous arrival and randomly selected first layer.}  
+          {$<$N$>$ $<$m$>$ $<$m0$>$ $<$outfile$>$ $<$a$>$ $<$b$>$
+          $<$c$>$ $<$d$>$ $<$beta$>$}
+
+\mydescription{Grow a two-layer multiplex network using the multiplex linear
+          preferential attachment model by Nicosia, Bianconi, Latora,
+          Barthelemy (NiBiLaB).
+
+          The probability for a newly arrived node $i$ to create a
+          link to node $j$ on layer $1$ is:
+          
+          \begin{equation*}
+          \Pi_{i\to j}^{1} \propto ak\lay{1}_j + bk\lay{2}_j
+          \end{equation*}
+
+          and the dual probability for $i$ to create a link to $j$ on
+          layer $2$ is:
+
+          \begin{equation*}
+          \Pi_{i\to j}^{2} \propto ck\lay{1}_j + dk\lay{2}_j
+          \end{equation*}
+          
+          Each new node arrives on one of the two layers, chosen
+          uniformly at random, and its replica on the other layer
+          appears after a time delay $\tau$ sampled from the power-law
+          function:
+
+          \begin{equation*}
+            P(\tau) \sim \tau^{-\beta}
+          \end{equation*}
+
+          The (mandatory) parameters are as follows:
+
+          \begin{itemize}
+
+          \item \textbf{N} number of nodes in the final graph
+
+          \item \textbf{m} number of new edges brought by each new node
+
+          \item \textbf{m0} number of nodes in the initial seed
+                    graph. \textit{m0} must be larger than of equal
+                    to \textit{m}.
+
+          \item \textbf{outfile} the name of the file which will contain the            
+          
+          \item \textbf{a,b,c,d} the coefficients of the attaching probability
+          function
+
+          \item \textbf{beta} the exponent of the power-law delay
+          function which determines the arrival of replicas on layer $2$
+
+          \end{itemize}
+ }
+
+
+\myreturn{The program dumps on the file \texttt{outfile} the
+ (undirected) edge list of the resulting network. Each line of the
+ file is in the format:
+  
+  \hspace{0.5cm}\textit{src\_ID} \textit{dest\_ID}
+  
+  where \textit{src\_ID} and \textit{dest\_ID} are the IDs of the two
+  endpoints of an edge.
+}
+
+\myreference{\refgrowth}
diff --git a/doc/latex/latex/models/growth/nibilab_linear_delta.tex b/doc/latex/latex/models/growth/nibilab_linear_delta.tex
new file mode 100644
index 0000000..27ebbd0
--- /dev/null
+++ b/doc/latex/latex/models/growth/nibilab_linear_delta.tex
@@ -0,0 +1,57 @@
+\myprogram{{nibilab\_linear\_delta}}
+          {Multiplex linear preferential attachment model --
+          Synchronous arrival.}  
+          {$<$N$>$ $<$m$>$ $<$m0$>$ $<$outfile$>$ $<$a$>$ $<$b$>$ $<$c$>$ $<$d$>$}
+
+\mydescription{Grow a two-layer multiplex network using the multiplex linear
+          preferential attachment model by Nicosia, Bianconi, Latora,
+          Barthelemy (NiBiLaB).
+
+          The probability for a newly arrived node $i$ to create a
+          link to node $j$ on layer $1$ is:
+          
+          \begin{equation*}
+          \Pi_{i\to j}^{1} \propto ak\lay{1}_j + bk\lay{2}_j
+          \end{equation*}
+
+          and the dual probability for $i$ to create a link to $j$ on
+          layer $2$ is:
+
+          \begin{equation*}
+          \Pi_{i\to j}^{2} \propto ck\lay{1}_j + dk\lay{2}_j
+          \end{equation*}
+          
+          Each new node arrives at the same time on both layers.
+
+          The (mandatory) parameters are as follows:
+
+          \begin{itemize}
+
+          \item \textbf{N} number of nodes in the final graph
+
+          \item \textbf{m} number of new edges brought by each new node
+
+          \item \textbf{m0} number of nodes in the initial seed
+                    graph. \textit{m0} must be larger than of equal
+                    to \textit{m}.
+
+          \item \textbf{outfile} the name of the file which will contain the            
+          
+          \item \textbf{a,b,c,d} the coefficients of the attaching probability
+          function
+
+          \end{itemize}
+ }
+
+
+\myreturn{The program dumps on the file \texttt{outfile} the
+ (undirected) edge list of the resulting network. Each line of the
+ file is in the format:
+  
+  \hspace{0.5cm}\textit{src\_ID} \textit{dest\_ID}
+  
+  where \textit{src\_ID} and \textit{dest\_ID} are the IDs of the two
+  endpoints of an edge.
+}
+
+\myreference{\refgrowth}
diff --git a/doc/latex/latex/models/growth/nibilab_linear_random_times.tex b/doc/latex/latex/models/growth/nibilab_linear_random_times.tex
new file mode 100644
index 0000000..5f1c0fe
--- /dev/null
+++ b/doc/latex/latex/models/growth/nibilab_linear_random_times.tex
@@ -0,0 +1,63 @@
+\myprogram{{nibilab\_linear\_random\_times}}
+          {Multiplex linear preferential attachment model --
+          Asynchronous arrival with randomly sampled arrival times on
+          layer 2.}  
+          {$<$N$>$ $<$m$>$ $<$m0$>$ $<$outfile$>$ $<$a$>$ $<$b$>$
+          $<$c$>$ $<$d$>$ }
+
+\mydescription{Grow a two-layer multiplex network using the multiplex linear
+          preferential attachment model by Nicosia, Bianconi, Latora,
+          Barthelemy (NiBiLaB).
+
+          The probability for a newly arrived node $i$ to create a
+          link to node $j$ on layer $1$ is:
+          
+          \begin{equation*}
+          \Pi_{i\to j}^{1} \propto ak\lay{1}_j + bk\lay{2}_j
+          \end{equation*}
+
+          and the dual probability for $i$ to create a link to $j$ on
+          layer $2$ is:
+
+          \begin{equation*}
+          \Pi_{i\to j}^{2} \propto ck\lay{1}_j + dk\lay{2}_j
+          \end{equation*}
+          
+          Each new node arrives on layer $1$, but its replica on the
+          other layer appears at a uniformly chosen random time in
+          $[m0+1; N]$.
+
+
+          The (mandatory) parameters are as follows:
+
+          \begin{itemize}
+
+          \item \textbf{N} number of nodes in the final graph
+
+          \item \textbf{m} number of new edges brought by each new node
+
+          \item \textbf{m0} number of nodes in the initial seed
+                    graph. \textit{m0} must be larger than of equal
+                    to \textit{m}.
+
+          \item \textbf{outfile} the name of the file which will contain the            
+          
+          \item \textbf{a,b,c,d} the coefficients of the attaching probability
+          function
+
+
+          \end{itemize}
+ }
+
+
+\myreturn{The program dumps on the file \texttt{outfile} the
+ (undirected) edge list of the resulting network. Each line of the
+ file is in the format:
+  
+  \hspace{0.5cm}\textit{src\_ID} \textit{dest\_ID}
+  
+  where \textit{src\_ID} and \textit{dest\_ID} are the IDs of the two
+  endpoints of an edge.
+}
+
+\myreference{\refgrowth}
diff --git a/doc/latex/latex/models/growth/nibilab_nonlinear.tex b/doc/latex/latex/models/growth/nibilab_nonlinear.tex
new file mode 100644
index 0000000..2e48a18
--- /dev/null
+++ b/doc/latex/latex/models/growth/nibilab_nonlinear.tex
@@ -0,0 +1,60 @@
+\myprogram{{nibilab\_nonlinear}}
+          {Multiplex non-linear preferential attachment model --
+          Synchronous arrival.}  
+          {$<$N$>$ $<$m$>$ $<$m0$>$ $<$outfile$>$ $<$alpha$>$ $<$beta$>$}
+
+\mydescription{Grow a two-layer multiplex network using the multiplex non-linear
+          preferential attachment model by Nicosia, Bianconi, Latora,
+          Barthelemy (NiBiLaB).
+
+          The probability for a newly arrived node $i$ to create a
+          link to node $j$ on layer $1$ is:
+          
+          \begin{equation*}
+          \Pi_{i\to j}^{1} \propto \frac{\left(k\lay{1}_j\right)^{\alpha}} 
+          {\left(k\lay{2}_j\right)^{\beta}}
+          \end{equation*}
+
+          and the dual probability for $i$ to create a link to $j$ on
+          layer $2$ is:
+
+          \begin{equation*}
+          \Pi_{i\to j}^{2} \propto \frac{\left(k\lay{2}_j\right)^{\alpha}} 
+          {\left(k\lay{1}_j\right)^{\beta}}
+          \end{equation*}
+
+          Each node arrives simultaneously on both layers.
+          
+
+          The (mandatory) parameters are as follows:
+
+          \begin{itemize}
+
+          \item \textbf{N} number of nodes in the final graph
+
+          \item \textbf{m} number of new edges brought by each new node
+
+          \item \textbf{m0} number of nodes in the initial seed
+                    graph. \textit{m0} must be larger than of equal
+                    to \textit{m}.
+
+          \item \textbf{outfile} the name of the file which will contain the            
+          
+          \item \textbf{alpha, beta} exponents of of the attaching probability
+          function
+
+          \end{itemize}
+ }
+
+
+\myreturn{The program dumps on the file \texttt{outfile} the
+ (undirected) edge list of the resulting network. Each line of the
+ file is in the format:
+  
+  \hspace{0.5cm}\textit{src\_ID} \textit{dest\_ID}
+  
+  where \textit{src\_ID} and \textit{dest\_ID} are the IDs of the two
+  endpoints of an edge.
+}
+
+\myreference{\refgrowth}
diff --git a/doc/latex/latex/models/growth/node_deg_over_time.tex b/doc/latex/latex/models/growth/node_deg_over_time.tex
new file mode 100644
index 0000000..351045e
--- /dev/null
+++ b/doc/latex/latex/models/growth/node_deg_over_time.tex
@@ -0,0 +1,50 @@
+\myprogram{{node\_deg\_over\_time.py}}
+          {Time evolution of the degree of a node in a growing graph.}  
+          {$<$layer$>$ $<$arrival\_times$>$ $<$node\_id$>$
+          [$<$node\_id$>$ ...]}
+
+\mydescription{Compute the degree $k_{i}(t)$ of node $i$ in a growing
+          network as a function of time. The file \textit{layer}
+          contains the edge list of the final network. Each line of
+          the file is in the format:
+  
+  \hspace{0.5cm}\textit{src\_ID} \textit{dest\_ID}
+  
+  where \textit{src\_ID} and \textit{dest\_ID} are the IDs of the two
+  endpoints of an edge.
+  
+  The file \textit{arrival\_times} is a list of node arrival times, in
+ the format:
+
+ \hspace{0.5cm} \textit{time\_i node\_i}
+ 
+ where \textit{time\_i} is the time at which \textit{node\_i} arrived
+ in the graph. Notice that \textit{time\_i} must be an integer in the
+ range [0, N-1], where N is the total number of nodes in the final
+ graph.
+
+ The third parameter \textit{node\_id} is the ID of the node whose
+ degree over time will be printed on output. If more than
+ one \textit{node\_id} is provided, the degrees over time of all the
+ corresponding nodes are printed on output.
+ }
+
+
+\myreturn{The program prints on \texttt{stdout} a list of lines in the
+ format:
+
+ \hspace{0.5cm} \textit{t kit}
+ 
+ where \textit{kit} is the degree of node \textit{i} at
+ time \textit{t}. The first line of output is in the format:
+
+ \hspace{0.5cm} \textit{\#\#\#\# node\_id}
+
+ where \textit{node\_id} is the ID of node \textit{i}.
+
+ If more than one \textit{node\_id}s is provided as input, the program
+ prints the degree over time of all of them, sequentially.
+ 
+}
+
+\myreference{\refgrowth}
diff --git a/doc/latex/latex/models/nullmodels/model_MDM.tex b/doc/latex/latex/models/nullmodels/model_MDM.tex
new file mode 100644
index 0000000..dd754b8
--- /dev/null
+++ b/doc/latex/latex/models/nullmodels/model_MDM.tex
@@ -0,0 +1,37 @@
+\myprogram{{model\_MDM.py}}
+          {Multi-activity Deterministic Model.} 
+          {$<$Bi\_file$>$ $<$M$>$}
+
+\mydescription{This is the Multi-activity Deterministic Model (MDM). 
+           In this model each node $i$ is considered active if it was
+           active in the reference multiplex, maintains the same value
+           of node activity $B_i$ (i.e., the number of layers in which
+           it was active) and is associated an activity vector sampled
+           uniformly at random from the $M\choose{B_i}$ possible
+           activity vectors with $B_i$ non-null entries.
+
+          The file \textit{Bi\_file}  is in the format:
+          
+          \hspace{0.5cm} \textit{Bi N(Bi)}
+          
+          where \textit{Bi} is a value of node activity
+          and \textit{N(Bi)} is the number of nodes which had node
+          activity equaly to \textit{Bi} in the reference multiplex.
+          
+          The parameter \textit{M} is the number of layers in the
+          multiplex.
+}         
+
+
+\myreturn{The program prints on \texttt{stdout} a distribution of
+          bit-strings, in the format:
+
+          \hspace{0.5cm} \textit{Bi bitstring count}
+
+          where \textit{bitstring} is the activity
+          bitstring, \textit{Bi} is the number of non-zero entries
+          of \textit{bitstring} and \textit{count} is the number of
+          times that \textit{bitstrings} appear in the null model.}
+
+
+\myreference{\refcorrelations}
diff --git a/doc/latex/latex/models/nullmodels/model_MSM.tex b/doc/latex/latex/models/nullmodels/model_MSM.tex
new file mode 100644
index 0000000..e3c8abf
--- /dev/null
+++ b/doc/latex/latex/models/nullmodels/model_MSM.tex
@@ -0,0 +1,38 @@
+\myprogram{{model\_MSM.py}}
+          {Multi-activity Stochastic Model.} 
+          {$<$node\_Bi\_file$>$ $<$M$>$}
+
+\mydescription{This is the Multi-activity Stochastic Model (MSM). 
+           In this model each node $i$ is considered active if it was
+           active in the reference multiplex, and is activated on
+           each layer with a probability equal to $B_i/M$ where $B_i$
+           was the activity of node $i$ in the reference multiplex.
+
+          The file \textit{node\_Bi\_file}  is in the format:
+          
+          \hspace{0.5cm} \textit{node\_i Bi)}
+          
+          where \textit{Bi} is the value of node activity
+          of \textit{node\_i} in the reference multiplex.
+          
+          
+          The parameter \textit{M} is the number of layers in the
+          multiplex.
+}         
+
+\myreturn{The program prints on \texttt{stdout} a node-layer list of lines in the
+ format:
+
+ \hspace{0.5cm} \textit{node\_i layer\_i}
+ 
+ where \textit{node\_i} is the ID of a node and \textit{layre\_i} is
+ the ID of a layer. This list indicates which nodes are active in
+ which layer. For instance, the line:
+
+ \hspace{0.5cm} \textit{24 3}
+
+ indicates that the node with ID \textit{24} is active on
+ layer \textit{3}.
+}
+
+\myreference{\refcorrelations}
diff --git a/doc/latex/latex/models/nullmodels/model_hypergeometric.tex b/doc/latex/latex/models/nullmodels/model_hypergeometric.tex
new file mode 100644
index 0000000..0315c7b
--- /dev/null
+++ b/doc/latex/latex/models/nullmodels/model_hypergeometric.tex
@@ -0,0 +1,33 @@
+\myprogram{{model\_hypergeometric.py}}
+          {Hypergeometric node activity null model.} 
+          {$<$layer\_N\_file$>$ $<$N$>$}
+
+\mydescription{This is the hypergeometric model of node activation. In
+          this model each layer has exactly the same number of active
+          node of a reference multiplex network, but nodes on each
+          layer are activated uniformly at random, thus destroying all
+          inter-layer activity correlation patterns.
+
+          The file \textit{layer\_N\_file} reports on the n-th line
+          the number of active nodes on the n-th layer (starting from
+          zero). The second parameter \textit{N} is the total number
+          of active nodes in the multiplex.
+ }
+
+
+\myreturn{The program prints on \texttt{stdout} a node-layer list of lines in the
+ format:
+
+ \hspace{0.5cm} \textit{node\_i layer\_i}
+ 
+ where \textit{node\_i} is the ID of a node and \textit{layre\_i} is
+ the ID of a layer. This list indicates which nodes are active in
+ which layer. For instance, the line:
+
+ \hspace{0.5cm} \textit{24 3}
+
+ indicates that the node with ID \textit{24} is active on
+ layer \textit{3}.
+}
+
+\myreference{\refcorrelations}
diff --git a/doc/latex/latex/models/nullmodels/model_layer_growth.tex b/doc/latex/latex/models/nullmodels/model_layer_growth.tex
new file mode 100644
index 0000000..9c0bb12
--- /dev/null
+++ b/doc/latex/latex/models/nullmodels/model_layer_growth.tex
@@ -0,0 +1,46 @@
+\myprogram{{model\_layer\_growth.py}}
+          {Layer growth with preferential activation model.} 
+          {$<$layer\_N\_file$>$ $<$N$>$ $<$M0$>$ $<$A$>$ [RND]}
+
+\mydescription{This is the model of layer growth with preferential
+          node activation. In this model an entire new layer arrives
+          at time $t$ and a number of nodes $N_t$ is activated ($N\_t$
+          is equal to the number of nodes active on that layer in the
+          reference multiplex). Then, each node $i$ of the new layer
+          is activated with a probability:
+
+          \begin{equation*}
+          P_i(t) \propto A + B_i(t)
+          \end{equation*}
+
+          where $B_i(t)$ is the activity of node $i$ at time $t$
+          (i.e., the number of layers in which node $i$ is active at
+          time $t$) while $A>0$ is an intrinsic attractiveness.
+
+          The file \textit{layer\_N\_file} reports on the n-th line
+          the number of active nodes on the n-th layer.
+          
+          The parameter \textit{N} is the number of nodes in the
+          multiplex, \textit{M0} is the number of layers in the
+          initial network, \textit{A} is the value of
+          node attractiveness.
+
+          If the user specifies \texttt{RND} as the last parameter,
+          the sequence of layers is }
+
+\myreturn{The program prints on \texttt{stdout} a node-layer list of lines in the
+ format:
+
+ \hspace{0.5cm} \textit{node\_i layer\_i}
+ 
+ where \textit{node\_i} is the ID of a node and \textit{layre\_i} is
+ the ID of a layer. This list indicates which nodes are active in
+ which layer. For instance, the line:
+
+ \hspace{0.5cm} \textit{24 3}
+
+ indicates that the node with ID \textit{24} is active on
+ layer \textit{3}.
+}
+
+\myreference{\refcorrelations}
diff --git a/doc/latex/latex/structure/activity/degs_to_activity_overlap.tex b/doc/latex/latex/structure/activity/degs_to_activity_overlap.tex
new file mode 100644
index 0000000..6e1908f
--- /dev/null
+++ b/doc/latex/latex/structure/activity/degs_to_activity_overlap.tex
@@ -0,0 +1,29 @@
+\myprogram{{degs\_to\_activity\_overlap.py}}
+          {compute the activity and the total (overlapping) degree of
+          all the nodes of a multiplex.}
+          {$<$degree\_vectors$>$}
+
+\mydescription{Take a file which contains, on the n-th line, the degrees at each
+ layer of the n-th node, (e.g., the result of the
+ script \texttt{node\_degree\_vectors.py}), in the format:
+
+ \hspace{0.5cm}\textit{noden\_deg\_lay1 noden\_deg\_lay2 ... noden\_deg\_layM}
+
+ \noindent and compute the activity (i.e., the number of layers in
+ which a node is not isolated) and the total (overlapping) degree of
+ each node.}
+
+\myreturn{The program prints on \texttt{stdout} a list of lines, where
+ the n-th line contains the activity and the total degree of the n-th
+ nodem in the format:
+
+ \hspace{0.5cm}\textit{noden\_activity noden\_tot\_deg}
+
+ \noindent As usual, the program assumes that node IDs start from zero
+  and proceed sequentially, without gaps, i.e., if a node ID is not
+  present in any of the layer files given as input, the program
+  considers it as being isolated on all the layers.
+ }
+
+\myreference{\refcorrelations}
+
diff --git a/doc/latex/latex/structure/activity/degs_to_binary.tex b/doc/latex/latex/structure/activity/degs_to_binary.tex
new file mode 100644
index 0000000..7441b2d
--- /dev/null
+++ b/doc/latex/latex/structure/activity/degs_to_binary.tex
@@ -0,0 +1,32 @@
+\myprogram{{degs\_to\_binary.py}}
+          {compute the activity vectors of all the nodes of a multiplex.}
+          {$<$degree\_vectors$>$}
+
+\mydescription{Take a file which contains, on the n-th line, the degrees at each
+ layer of the n-th node, (e.g., the result of the
+ script \texttt{node\_degree\_vectors.py}), in the format:
+
+ \hspace{0.5cm}\textit{noden\_deg\_lay1 noden\_deg\_lay2 ... noden\_deg\_layM}
+
+ \noindent and compute the corresponding node activity bit-strings,
+ where a "1" signals the presence of the node on that layer, while a
+ zero indicates its absence.
+}
+
+\myreturn{The program returns on \texttt{stdout} a list of lines,
+  where the n-th line is the activity bit-string of the n-th
+  node. Additionally, the program prints on \texttt{stderr} the
+  distribution of all activity bit-strings, in the format:
+
+  \hspace{0.5cm}\textit{Bn Bit-string count}
+
+  \noindent Where \textit{B} is the number of ones in the activity
+  bit-string (i.e., the node-activity associated to that activity
+  bit-string), \textit{Bit-string} is the activity bit-string
+  and \textit{count} is the number of times that particular activity
+  bit-string appears in the multiplex.}
+  
+
+
+\myreference{\refcorrelations}
+
diff --git a/doc/latex/latex/structure/activity/hamming_dist.tex b/doc/latex/latex/structure/activity/hamming_dist.tex
new file mode 100644
index 0000000..3af188f
--- /dev/null
+++ b/doc/latex/latex/structure/activity/hamming_dist.tex
@@ -0,0 +1,31 @@
+\myprogram{{hamming\_dist.py}}
+          {compute the normalised Hamming distance between all the pairs of
+          layers of a multiplex.}
+          {$<$layer1$>$ $<$layer2$>$ [$<$layer3$>$...]}
+
+\mydescription{Compute and print on output the normalised Hamming distance 
+ $H_{\alpha, \beta}$ (i.e., the fraction of nodes which are active on
+          either of the layers, but not on both) between all pairs of
+          layers. The layers are given as input in the
+          files \textit{layer1}, \textit{layer2}, etc.
+  
+  Each input file contains the (undirected) edge list of a layer, and
+  each line is in the format:
+  
+  \hspace{0.5cm}\textit{src\_ID} \textit{dest\_ID}
+  
+  where \textit{src\_ID} and \textit{dest\_ID} are the IDs of the two
+  endpoints of an edge.}
+
+\myreturn{The program prints on \texttt{stdout} a list of lines, in
+  the format:
+
+  \hspace{0.5cm} \textit{layer1 layer2 hamm}
+
+  \noindent where \textit{layer1} and \textit{layer2} are the IDs of
+  the layers, and \textit{hamm} is the value of the normalised Haming
+  distance $H_{layer1, layer2}$. Layers IDs start from zero, are are
+  associated to the layers in the same order in which the layer files
+  are provided on the command line.}
+
+\myreference{\refcorrelations}
diff --git a/doc/latex/latex/structure/activity/layer_activity.tex b/doc/latex/latex/structure/activity/layer_activity.tex
new file mode 100644
index 0000000..34fcdd2
--- /dev/null
+++ b/doc/latex/latex/structure/activity/layer_activity.tex
@@ -0,0 +1,25 @@
+%%%
+%%% Layer activity
+%%%
+
+\myprogram{{layer\_activity.py}}
+          {compute the activity of the layers of a multiplex, i.e. the
+          number of active nodes on each layer.}
+          {$<$layer1$>$ [$<$layer2$>$ ...]}
+
+\mydescription{Compute and print on output the activity of the layers
+  of a multiplex network, where the layers are given as input in the
+  files \textit{layer1}, \textit{layer2}, etc.
+  
+  Each file contains the (undirected) edge list of a layer, and each
+  line is in the format:
+  
+  \hspace{0.5cm}\textit{src\_ID} \textit{dest\_ID}
+  
+  where \textit{src\_ID} and \textit{dest\_ID} are the IDs of the two
+  endpoints of an edge.}
+
+\myreturn{A listof lines, where the n-th line is the value of activity
+  of the n-th layer, starting from \textbf{0}.}
+
+\myreference{\refcorrelations}
diff --git a/doc/latex/latex/structure/activity/layer_activity_vectors.tex b/doc/latex/latex/structure/activity/layer_activity_vectors.tex
new file mode 100644
index 0000000..f0c2cd6
--- /dev/null
+++ b/doc/latex/latex/structure/activity/layer_activity_vectors.tex
@@ -0,0 +1,27 @@
+\myprogram{{layer\_activity\_vectors.py}}
+          {compute the activity vectors of all the layers of a multiplex.}
+          {$<$layer1$>$ [$<$layer2$>$ ...]}
+
+\mydescription{Compute and print on output the activity vectors of the
+  layers of a multiplex network, where the layers are given as input
+  in the files \textit{layer1}, \textit{layer2}, etc.
+  
+  Each input file contains the (undirected) edge list of a layer, and
+  each line is in the format:
+  
+  \hspace{0.5cm}\textit{src\_ID} \textit{dest\_ID}
+  
+  where \textit{src\_ID} and \textit{dest\_ID} are the IDs of the two
+  endpoints of an edge.}
+
+\myreturn{The program prints on \texttt{stdout} a list of lines, where
+  the n-th line contains the activity vector of the n-th layer, i.e. a
+  bit-string where each bit is set to ``1'' if the corresponding node
+  is active on the n-th layer, and to ``0'' otherwise.
+ 
+  \noindent As usual, node IDs start from zero and proceed
+  sequentially, without gaps, i.e., if a node ID is not present in any
+  of the layer files given as input, the program considers it as being
+  isolated on all the layers.}
+
+\myreference{\refcorrelations}
diff --git a/doc/latex/latex/structure/activity/multiplexity.tex b/doc/latex/latex/structure/activity/multiplexity.tex
new file mode 100644
index 0000000..b5c5506
--- /dev/null
+++ b/doc/latex/latex/structure/activity/multiplexity.tex
@@ -0,0 +1,30 @@
+\myprogram{{multiplexity.py}}
+          {compute the pairwise multiplexity between all the pairs of
+          layers of a multiplex.}
+          {$<$layer1$>$ $<$layer2$>$ [$<$layer3$>$...]}
+
+\mydescription{Compute and print on output the pairwise multiplexity 
+ $Q_{\alpha, \beta}$ (i.e., the fraction of nodes active on both
+          layers) between all pairs of layers. The layers are given as
+          input in the files \textit{layer1}, \textit{layer2}, etc.
+  
+  Each input file contains the (undirected) edge list of a layer, and
+  each line is in the format:
+  
+  \hspace{0.5cm}\textit{src\_ID} \textit{dest\_ID}
+  
+  where \textit{src\_ID} and \textit{dest\_ID} are the IDs of the two
+  endpoints of an edge.}
+
+\myreturn{The program prints on \texttt{stdout} a list of lines, in
+  the format:
+
+  \hspace{0.5cm} \textit{layer1 layer2 mult}
+
+  \noindent where \textit{layer1} and \textit{layer2} are the IDs of
+  the layers, and \textit{mult} is the value of the multiplexity
+  $Q_{layer1, layer2}$. Layers IDs start from zero, are are associated
+  to the layers in the same order in which the layer files are
+  provided on the command line.}
+
+\myreference{\refcorrelations}
diff --git a/doc/latex/latex/structure/activity/node_activity.tex b/doc/latex/latex/structure/activity/node_activity.tex
new file mode 100644
index 0000000..882233d
--- /dev/null
+++ b/doc/latex/latex/structure/activity/node_activity.tex
@@ -0,0 +1,25 @@
+%%%
+%%% node_activity
+%%%
+\myprogram{{node\_activity.py}}
+          {compute the activity of the nodes of a multiplex, i.e. the
+            number of layers where each node is not isolated.}
+          {$<$layer1$>$ [$<$layer2$>$ ...]}
+
+\mydescription{Compute and print on output the activity of the nodes
+  of a multiplex network, whose layers are given as input in the files
+  \textit{layer1}, \textit{layer2}, etc.
+  
+  Each file contains the (undirected) edge list of a layer, and each
+  line is in the format:
+  
+  \hspace{0.5cm}\textit{src\_ID} \textit{dest\_ID}
+  
+  where \textit{src\_ID} and \textit{dest\_ID} are the IDs of the two
+  endpoints of an edge.}
+
+\myreturn{A list of lines, where the n-th line is the value of activity
+  of the n-th node, starting from \textbf{0}.}
+
+\myreference{\refcorrelations}
+
diff --git a/doc/latex/latex/structure/activity/node_activity_vectors.tex b/doc/latex/latex/structure/activity/node_activity_vectors.tex
new file mode 100644
index 0000000..ca9301d
--- /dev/null
+++ b/doc/latex/latex/structure/activity/node_activity_vectors.tex
@@ -0,0 +1,28 @@
+\myprogram{{node\_activity\_vectors.py}}
+          {compute the activity vectors of all the nodes of a multiplex.}
+          {$<$layer1$>$ [$<$layer2$>$ ...]}
+
+\mydescription{Compute and print on output the activity vectors of the
+  nodes of a multiplex network, whose layers are given as input in the
+  files \textit{layer1}, \textit{layer2}, etc.
+  
+  Each input file contains the (undirected) edge list of a layer, and
+  each line is in the format:
+  
+  \hspace{0.5cm}\textit{src\_ID} \textit{dest\_ID}
+  
+  where \textit{src\_ID} and \textit{dest\_ID} are the IDs of the two
+  endpoints of an edge.}
+
+\myreturn{The program prints on \texttt{stdout} a list of lines, where
+  the n-th line contains the activity vector of the n-th node, i.e. a
+  bit-string where each bit is set to ``1'' if the node is active on
+  the corresponding layer, and to ``0'' otherwise.
+ 
+  \noindent As usual, node IDs start from zero and proceed
+  sequentially, without gaps, i.e., if a node ID is not present in any
+  of the layer files given as input, the program considers it as being
+  isolated on all the layers, and will print on output a bit-string of
+  zeros.}
+
+\myreference{\refcorrelations}
diff --git a/doc/latex/latex/structure/activity/node_degree_vectors.tex b/doc/latex/latex/structure/activity/node_degree_vectors.tex
new file mode 100644
index 0000000..c86f083
--- /dev/null
+++ b/doc/latex/latex/structure/activity/node_degree_vectors.tex
@@ -0,0 +1,30 @@
+\myprogram{{node\_degree\_vectors.py}}
+          {compute the degree vectors of all the nodes of a multiplex network}
+          {$<$layer1$>$ [$<$layer2$>$ ...]}
+
+\mydescription{Compute and print on output the degree vectors of all
+          the nodes of a multiplex network, whose layers are given as
+  input in the files \textit{layer1}, \textit{layer2}, etc.
+  
+  Each file contains the (undirected) edge list of a layer, and each
+  line is in the format:
+  
+  \hspace{0.5cm}\textit{src\_ID} \textit{dest\_ID}
+  
+  where \textit{src\_ID} and \textit{dest\_ID} are the IDs of the two
+  endpoints of an edge.}
+
+\myreturn{A list of lines, where the n-th line is the 
+  vector of degrees of the n-th node, in the format:
+  
+  \hspace{0.5cm}\textit{noden\_deg\_lay1 noden\_deg\_lay2 ... noden\_deg\_layM}
+
+  \noindent As usual, node IDs start from zero and proceed
+  sequentially, without gaps, i.e., if a node ID is not present in any
+  of the layer files given as input, the program considers it as being
+  isolated on all the layers.
+
+}
+
+\myreference{\refgrowth\\ \\ \indent \refmetrics}
+
diff --git a/doc/latex/latex/structure/correlations/compute_pearson.tex b/doc/latex/latex/structure/correlations/compute_pearson.tex
new file mode 100644
index 0000000..8202753
--- /dev/null
+++ b/doc/latex/latex/structure/correlations/compute_pearson.tex
@@ -0,0 +1,28 @@
+\myprogram{{compute\_pearson.py}}
+          {compute the Pearson's linear correlation coefficient
+          between two node properties.}  
+          {$<$file1$>$ $<$file2$>$}
+
+\mydescription{Compute the Pearson's linear correlation coefficient
+          between two sets of (either integer- or real-valued) node
+          properties provided in the input files \textit{file1}
+          and \textit{file2}. Each input file contains a list of
+          lines, where the n-th line contains the value of a node
+          property for the n-th node.  For instance, \textit{file1}
+          and \textit{file2} might contain the degrees of nodes at two
+          distinct layers of a multiplex. However, the program is
+          pretty general and can be used to compute the Pearson's
+          correlation coeffcient between any pairs of node properties.
+          }
+
+\myreturn{The program prints on \texttt{stdout} the value of the
+          Pearson's linear correlation coefficient between the two
+          sets of node properties.
+}
+
+\myreference{\refcorrelations
+
+  \refgrowth
+
+  \refnonlinear
+}
diff --git a/doc/latex/latex/structure/correlations/compute_rho.tex b/doc/latex/latex/structure/correlations/compute_rho.tex
new file mode 100644
index 0000000..957b04c
--- /dev/null
+++ b/doc/latex/latex/structure/correlations/compute_rho.tex
@@ -0,0 +1,32 @@
+\myprogram{{compute\_rho.py}}
+          {compute the Spearman's rank correlation coefficient $\rho$
+          between two rankings.}  {$<$file1$>$ $<$file2$>$}
+
+\mydescription{Compute the Spearman's rank correlation coefficient
+           $\rho$ between two rankings provided in the input
+          files \textit{file1} and \textit{file2}. Each input file
+          contains a list of lines, where the n-th line contains the
+          value of rank of the n-th node. For instance, \textit{file1}
+          and \textit{file2} might contain the ranks of nodes induced
+          by the degree sequences of two distinct layers of a
+          multiplex. 
+
+          However, the program is pretty general and can be used to
+          compute the Spearman's rank correlation coefficient between
+          any generic pair of rankings.
+
+          N.B.: A C implementation of this program, with the same
+          interface is also available in the executable
+          file \texttt{compute\_rho}.}
+
+
+\myreturn{The program prints on \texttt{stdout} the value of the
+          Spearman's rank correlation coefficient $\rho$ between the
+          two rankings provided as input. }
+
+\myreference{\refcorrelations
+
+  \refgrowth
+
+  \refnonlinear
+  }
diff --git a/doc/latex/latex/structure/correlations/compute_tau.tex b/doc/latex/latex/structure/correlations/compute_tau.tex
new file mode 100644
index 0000000..e6e8589
--- /dev/null
+++ b/doc/latex/latex/structure/correlations/compute_tau.tex
@@ -0,0 +1,31 @@
+\myprogram{{compute\_tau.py}}
+          {compute the Kendall's rank correlation coefficient $\tau_b$
+          between two rankings.}  {$<$file1$>$ $<$file2$>$}
+
+\mydescription{Compute the Kendall's rank correlation coefficient
+           $\tau_b$ between two rankings provided in the input
+          files \textit{file1} and \textit{file2}. Each input file
+          contains a list of lines, where the n-th line contains the
+          value of rank of the n-th node. For instance, \textit{file1}
+          and \textit{file2} might contain the ranks of nodes induced
+          by the degree sequences of two distinct layers of a
+          multiplex.
+
+          However, the program is pretty general and can be used to
+          compute the Kendall's rank correlation coefficient between
+          any generic pair of rankings.
+
+          N.B.: This implementation takes properly into account rank
+          ties.}
+
+
+\myreturn{The program prints on \texttt{stdout} the value of the
+          Kendall's rank correlation coefficient $\tau_b$ between the
+          two rankings provided as input. }
+
+\myreference{\refcorrelations
+
+  \refgrowth
+
+  \refnonlinear
+}
diff --git a/doc/latex/latex/structure/correlations/dump_k_q.tex b/doc/latex/latex/structure/correlations/dump_k_q.tex
new file mode 100644
index 0000000..35aef8d
--- /dev/null
+++ b/doc/latex/latex/structure/correlations/dump_k_q.tex
@@ -0,0 +1,42 @@
+M\myprogram{{dump\_k\_q}}
+          {compute the degree sequences of two layers of a multiplex.}
+          {$<$layer1$>$ $<$layer2$>$ $<$pairing$>$}
+
+\mydescription{Compute and dump on \texttt{stdout} the degree
+          sequences of two layers of a multiplex. The input
+          files \textit{layer1} and \textit{layer2} contain the
+          (undirected) edge lists of the two layers, and each line is
+          in the format:
+  
+  \hspace{0.5cm}\textit{src\_ID} \textit{dest\_ID}
+  
+  where \textit{src\_ID} and \textit{dest\_ID} are the IDs of the two
+  endpoints of an edge.
+
+  The third file \textit{pairing} is a list of lines in the format:
+
+  \hspace{0.5cm} \textit{IDL1 IDL2} 
+
+  where \textit{IDL1} is the ID of a node on layer $1$
+  and \textit{IDL2} is the ID of the same node on layer $2$. For
+  instance, the line:
+
+  \hspace{0.5cm} \textit{5 27}
+
+  indicates that node $5$ on layer $1$ has ID $27$ on layer $2$. }
+
+
+\myreturn{The program prints on \texttt{stdout} the degree of each
+node on the two layers, in the format:
+
+\hspace{0.5cm} \textit{ki qi}
+
+where \textit{ki} is the degree of node \textit{i} on layer $1$
+and \textit{qi} is the degree of node \textit{i} on layer $2$.}
+
+\myreference{\refcorrelations
+
+  \refgrowth
+
+  \refnonlinear
+  }
diff --git a/doc/latex/latex/structure/correlations/fit_knn.tex b/doc/latex/latex/structure/correlations/fit_knn.tex
new file mode 100644
index 0000000..cb90c2b
--- /dev/null
+++ b/doc/latex/latex/structure/correlations/fit_knn.tex
@@ -0,0 +1,50 @@
+\myprogram{{fit\_knn}}
+          {power-law fit of the inter-layer degree correlation
+          function.}  
+          {$<$filein$>$ $<$alpha$>$}
+
+\mydescription{Perform a power-law fit of the inter-layer degree
+          correlation function:
+
+          \begin{equation*}
+           \overline{q}(k) = \frac{1}{N_{q}}\sum_{q'} q' P(q'|k)
+          \end{equation*}
+
+          where $k$ is the degree of a node on layer $1$, $q$ is the
+          degree on layer $2$ and $P(q|k)$ is the probability that a
+          node with degree $k$ on layer $1$ has degree $q$ on layer
+          $2$. The program assumes that $\overline{q}(k)$ can be
+          written in the form $a k^{b}$, and computes the two
+          parameters $a$ and $b$ through a linear fit of the log-log
+          plot of $\overline{q}(k)$.
+
+          The input file \textit{filein} contains a list of lines in
+          the format:
+
+          \hspace{0.5cm} \textit{ki qi}
+
+          where \textit{ki} is the degree of node $i$ at layer $1$
+          and \textit{qi} is the degree of node $i$ at layer $2$. 
+
+          The second parameter \textit{alpha} is the ratio of the
+          progression used to generate the exponentially-distributed
+          bins for the log-log plot. Typical values of \textit{alpha}
+          are between $1.1$ and $2.0$.
+          
+          
+          N.B.: The exponent $b$ computed with this method is known to
+          be inaccurate.
+}
+
+
+
+\myreturn{The program prints on \texttt{stdout} the values of the
+          parameters $a$ and $b$ of the power-law fit $\overline{q}(k)
+          = a k^{b}$.}
+
+\myreference{\refcorrelations
+
+  \refgrowth
+
+  \refnonlinear
+  }
diff --git a/doc/latex/latex/structure/correlations/knn_q_from_degrees.tex b/doc/latex/latex/structure/correlations/knn_q_from_degrees.tex
new file mode 100644
index 0000000..cab0905
--- /dev/null
+++ b/doc/latex/latex/structure/correlations/knn_q_from_degrees.tex
@@ -0,0 +1,64 @@
+\myprogram{{knn\_q\_from\_degrees.py}}
+          {compute the inter-layer degree-degree correlation function.}
+          {$<$filein$>$}
+
+\mydescription{Compute the  inter-layer degree
+          correlation functions for two layers of a multiplex, using
+          the degrees of the nodes specified in the input file. The
+          format of the input file is as follows
+
+\hspace{0.5cm} \textit{ki qi}
+
+where \textit{ki} and \textit{qi} are, respectively, the degree at
+layer 1 and the degree at layer 2 of node \textit{i}.
+
+          If we consider two layers of a multiplex, and we denote by
+          $k$ the degree of a node on the first layer and by $q$ the
+          degree of the same node on the second layers, the
+          inter-layer degree correlation function is defined as
+
+          \begin{equation*}
+            \overline{k}(q) = \frac{1}{N_{k}}\sum_{k'} k' P(k'|q)
+          \end{equation*}
+           
+           where $P(k'|q)$ is the probability that a node with degree
+           $q$ on the second layer has degree equal to $k'$ on the
+           first layer, and $N_k$ is the number of nodes with degree
+           $k$ on the first layer. The quantity $\overline{k}(q)$ is
+           the expected degree at layer $1$ of node that have degree
+           equal to $q$ on layer $2$. The dual quantity:
+
+          \begin{equation*}
+            \overline{q}(k) = \frac{1}{N_{q}}\sum_{q'} q' P(q'|k)
+          \end{equation*}
+           
+           is the average degree on layer $2$ of nodes having degree
+           $k$ on layer $1$.
+}
+
+
+\myreturn{The program prints on  \texttt{stdout} a list of lines in
+           the format:
+
+           \hspace{0.5cm} \textit{k $\overline{q}(k)$}           
+
+           where \textit{k} is the degree on layer $1$ and
+           $\overline{q}(k)$ is the average degree on layer $2$ of
+           nodes having degree equal to $k$ on layer $1$. 
+
+           The program also prints on \texttt{stderr} a list of lines in
+           the format:
+
+           \hspace{0.5cm} \textit{q $\overline{k}(q)$}           
+
+           where \textit{q} is the degree on layer $2$ and
+           $\overline{k}(q)$ is the average degree on layer $1$ of
+           nodes having degree equal to $q$ on layer $2$. 
+           }
+
+\myreference{\refcorrelations
+
+  \refgrowth
+
+  \refnonlinear
+  }
diff --git a/doc/latex/latex/structure/correlations/knn_q_from_layers.tex b/doc/latex/latex/structure/correlations/knn_q_from_layers.tex
new file mode 100644
index 0000000..f124e55
--- /dev/null
+++ b/doc/latex/latex/structure/correlations/knn_q_from_layers.tex
@@ -0,0 +1,80 @@
+\myprogram{{knn\_q\_from\_layers.py}}
+          {compute intra-layer and inter-layer degree-degree
+          correlation coefficients.}  {$<$layer1$>$ $<$layer2$>$}
+
+\mydescription{Compute the intra-layer and the inter-layer degree
+          correlation functions for two layers given as input. The
+          intra-layer degree correlation function quantifies the
+          presence of degree-degree correlations in a single layer
+          network, and is defined as:
+
+          \begin{equation*}
+            \avg{k_{nn}(k)} = \frac{1}{k N_k}\sum_{k'}k'P(k'|k)
+          \end{equation*}
+          
+          where $P(k'|k)$ is the probability that a neighbour of a
+          node with degree $k$ has degree $k'$, and $N_k$ is the
+          number of nodes with degree $k$. The quantity
+          $\avg{k_{nn}(k)}$ is the average degree of the neighbours of
+          nodes having degree equal to $k$.
+
+          If we consider two layers of a multiplex, and we denote by
+          $k$ the degree of a node on the first layer and by $q$ the
+          degree of the same node on the second layers, the
+          inter-layer degree correlation function is defined as
+
+          \begin{equation*}
+            \overline{k}(q) = \sum_{k'} k' P(k'|q)
+          \end{equation*}
+           
+           where $P(k'|q)$ is the probability that a node with degree
+           $q$ on the second layer has degree equal to $k'$ on the
+           first layer, and $N_q$ is the number of nodes with degree
+           $q$ on the second layer. The quantity $\overline{k}(q)$ is
+           the expected degree at layer $1$ of node that have degree
+           equal to $q$ on layer $2$. The dual quantity:
+
+          \begin{equation*}
+            \overline{q}(k) = \sum_{q'} q' P(q'|k)
+          \end{equation*}
+           
+           is the average degree on layer $2$ of nodes having degree
+           $k$ on layer $1$.
+}
+
+
+\myreturn{The program creates two output files, respectively called
+
+\hspace{0.5cm} \textit{file1\_file2\_k1}
+
+and
+
+\hspace{0.5cm} \textit{file1\_file2\_k2}
+
+The first file contains a list of lines in the format:
+
+\hspace{0.5cm} \textit{k $\avg{k_{nn}(k)}$ $\sigma_k$
+$\overline{q}(k)$ $\sigma_{\overline{q}}$}
+
+where $k$ is the degree at first layer, $\avg{k_{nn}(k)}$ is the
+average degree of the neighbours at layer $1$ of nodes having degree
+$k$ at layer $1$, $\sigma_k$ is the standard deviation associated to
+$\avg{k_{nn}(k)}$, $\overline{q}(k)$ is the average degree at layer
+$2$ of nodes having degree equal to $k$ at layer $1$, and
+$\sigma_{\overline{q}}$ is the standard deviation associated to
+$\overline{q}(k)$. 
+
+The second file contains a similar list of lines, in the format:
+
+\hspace{0.5cm} \textit{q $\avg{q_{nn}(q)}$ $\sigma_q$
+$\overline{k}(q)$ $\sigma_{\overline{k}}$}
+
+with obvious meaning.
+}
+
+\myreference{\refcorrelations
+
+  \refgrowth
+
+  \refnonlinear
+  }
diff --git a/doc/latex/latex/structure/correlations/rank_nodes.tex b/doc/latex/latex/structure/correlations/rank_nodes.tex
new file mode 100644
index 0000000..b1a970a
--- /dev/null
+++ b/doc/latex/latex/structure/correlations/rank_nodes.tex
@@ -0,0 +1,19 @@
+\myprogram{{rank\_nodes.py}}
+          {rank the nodes of a layer according to a given structural
+          descriptor.}  {$<$prop\_file$>$}
+
+\mydescription{Get a file as input, whose n-th line corresponds to the value of a
+ certain property of the n-th node, and rank the nodes according to
+ that property, taking into account ranking ties properly.
+ 
+ For example, if \textit{propfile} contains the degrees of the nodes
+ at a certain layer of the multiplex, the computes the ranking induced
+ by degrees, where the node with the highest degree will be assigned a
+ rank equal to \textbf{1} (one).
+}
+
+\myreturn{The program prints on \texttt{stdout} a list of lines, where
+ the n-th line contains the rank of the n-th node corresponding to the
+ values of the structural descriptor provided in the input file.}
+
+\myreference{\refcorrelations}
diff --git a/doc/latex/latex/structure/correlations/rank_nodes_thresh.tex b/doc/latex/latex/structure/correlations/rank_nodes_thresh.tex
new file mode 100644
index 0000000..3b430d1
--- /dev/null
+++ b/doc/latex/latex/structure/correlations/rank_nodes_thresh.tex
@@ -0,0 +1,18 @@
+\myprogram{{rank\_nodes\_thresh.py}}
+          {rank the nodes of a layer whose value of a given structural
+          descriptor is above a threshold.}  {$<$prop\_file$>$ $<$thresh$>$}
+
+\mydescription{Get a file as input, whose n-th line corresponds to the value of a
+ certain property of the n-th node, and rank the nodes according to
+ that property, taking into account ranking ties properly. The rank of
+ all the nodes whose value of the structural descriptor is smaller
+ than the threshold \textit{thresh} specified as second parameter is
+ set to \textbf{0} (ZERO). }
+
+\myreturn{The program prints on \texttt{stdout} a list of lines, where
+ the n-th line contains the rank of the n-th node corresponding to the
+ values of the structural descriptor provided in the input file, or
+ zero if such desxriptor is below the specified
+ threshold \textit{thresh}.}
+
+\myreference{\refcorrelations}
diff --git a/doc/latex/latex/structure/correlations/rank_occurrence.tex b/doc/latex/latex/structure/correlations/rank_occurrence.tex
new file mode 100644
index 0000000..96fb914
--- /dev/null
+++ b/doc/latex/latex/structure/correlations/rank_occurrence.tex
@@ -0,0 +1,24 @@
+\myprogram{{rank\_occurrence.py}}
+          {compute the intersection of two rankings.}  
+          {$<$rank1$>$ $<$rank2$>$ $<$increment$>$}
+
+\mydescription{Get two rankings \textit{rank1} and \textit{rank2} 
+                   and compute the size of
+the \textit{k}-intersection, i.e. the number of elements which are
+present in the first k positions of both rankings, as a function
+of \textit{k}.  The parameter \textit{increment} determines the
+distance between two subsequent values of \textit{k}.
+
+Each input file is a list of node IDs, one per line, where the first
+line contains the ID of the highest ranked node.
+}
+
+\myreturn{The program prints on \texttt{stdout} a list of lines in the
+format:
+  
+  \hspace{0.5cm} \textit{k num\_k}
+  
+  where \textit{num\_k} is the number of nodes which are present in
+  the first \textit{k} positions of both rankings.}
+
+\myreference{\refcorrelations}
diff --git a/doc/latex/latex/structure/metrics/aggregate_layers_w.tex b/doc/latex/latex/structure/metrics/aggregate_layers_w.tex
new file mode 100644
index 0000000..8917e3e
--- /dev/null
+++ b/doc/latex/latex/structure/metrics/aggregate_layers_w.tex
@@ -0,0 +1,30 @@
+\myprogram{{aggregate\_layers\_w.py}}
+          {compute the (weighted) aggregated graph associated to a
+          multiplex.}  {$<$layer1$>$ $<$layer2$>$ [$<$layer3$>$...]}
+
+\mydescription{Compute and print on output the edge list of the  
+               weighted aggregated graph associated to the multiplex
+               network given on input. An edge is present in the
+               aggregated graph if it exists in at least one of the M
+               layers of the multiplex.
+
+  Each input file contains the (undirected) edge list of a layer, and
+  each line is in the format:
+  
+  \hspace{0.5cm}\textit{src\_ID} \textit{dest\_ID}
+  
+  where \textit{src\_ID} and \textit{dest\_ID} are the IDs of the two
+  endpoints of an edge.}
+
+\myreturn{The program prints on \texttt{stdout} the edge list of the
+  aggregated graph associated to the multiplex network. The edge list
+  is a list of lines in the format:
+   
+
+  \hspace{0.5cm} \textit{ID1 ID2 weight}
+
+  \noindent where \textit{ID1} and \textit{ID2} are the IDs of the two
+  nodes and \textit{weight} is the number of layers in which an edge
+  between \textit{ID1} and \textit{ID2} exists.}
+
+\myreference{\refcorrelations}
diff --git a/doc/latex/latex/structure/metrics/avg_edge_overlap.tex b/doc/latex/latex/structure/metrics/avg_edge_overlap.tex
new file mode 100644
index 0000000..4df2d51
--- /dev/null
+++ b/doc/latex/latex/structure/metrics/avg_edge_overlap.tex
@@ -0,0 +1,42 @@
+\myprogram{{avg\_edge\_overlap.py}}
+          {compute the average edge overlap of a multiplex.}  
+          {$<$layer1$>$ [$<$layer2$>$...]}
+
+\mydescription{Compute and print on output the average edge overlap 
+
+          \begin{equation*} \omega^{*}
+          = \frac{\sum_{i}\sum_{j>i}\sum_{\alpha}a_{ij}\lay{\alpha}}{ \sum_{i}\sum_{j>i}(1
+          - \delta_{0,\sum_{\alpha}a_{ij}\lay{\alpha}})} \end{equation*}
+          
+  \noindent i.e., the expected \textit{number} of layers on which an
+   edge of the multiplex exists, and the corresponding normalised
+   quantity:
+  
+  \begin{equation*}
+      \omega = \frac{\sum_{i}\sum_{j>i}\sum_{\alpha}a_{ij}\lay{\alpha}}{M \sum_{i}\sum_{j>i}(1
+      - \delta_{0,\sum_{\alpha}a_{ij}\lay{\alpha}})}
+  \end{equation*}
+  
+  \noindent that is the expected \textit{fraction} of layers on which
+  an edge of the multiplex is present.
+  
+  Each input file contains the (undirected) edge list of a layer, and
+  each line is in the format:
+  
+  \hspace{0.5cm}\textit{src\_ID} \textit{dest\_ID}
+  
+  where \textit{src\_ID} and \textit{dest\_ID} are the IDs of the two
+  endpoints of an edge.}
+
+\myreturn{The program prints on \texttt{stdout} a single line, in the
+  format:
+  
+  \hspace{0.5cm} \textit{omega\_star omega}
+
+  \noindent where \textit{omega\_star} and \textit{omega} are,
+  respectively, the expected number and fraction of layers in which an
+  edge is present.}
+
+\myreference{\refmetrics
+
+  \vspace{0.5cm}\refvisibility}
diff --git a/doc/latex/latex/structure/metrics/cartography_from_columns.tex b/doc/latex/latex/structure/metrics/cartography_from_columns.tex
new file mode 100644
index 0000000..8e797af
--- /dev/null
+++ b/doc/latex/latex/structure/metrics/cartography_from_columns.tex
@@ -0,0 +1,35 @@
+\myprogram{{cartography\_from\_columns.py}}
+          {compute total and participation coefficient of generic
+          structural descriptors of the nodes of a multiplex.}
+          {$<$filein$>$ $<$col1$>$ $<$col2$>$ [$<$col3$>$...]}
+
+\mydescription{Compute and print on output the sum and the
+          corresponding participation coefficient of a generic
+          structural descriptor of the nodes of a multiplex.
+
+   \noindent The input file is a generic collection of
+   single-space-separated columns, where each line corresponds to a
+   node. The user must specify the IDs of the columns which contain
+   the node structural descriptors to be used in the cartography
+   diagram. Columns IDs start from ZERO. For example:
+
+   \textbf{python cartography\_from\_layers.py filein.txt 0
+   2 4 6 8}
+
+   \noindent will create a cartography diagram assuming that the
+   multiplex network has five layers, and that the node structural
+   descriptors at each layers are contained in the first (0), third
+   (2), fifth (4), seventh (6) and nineth (8) columns of each row.}
+
+
+\myreturn{The program prints on \texttt{stdout} a list of lines in the
+  format:
+  
+  \hspace{0.5cm} \textit{tot\_n P\_n}
+
+  where \textit{tot\_n} is the sum over the layers of the considered
+  structural descriptor for node $n$, and \textit{P\_n} is the
+  associated participation coefficient 
+  }
+
+\myreference{\refcorrelations}
diff --git a/doc/latex/latex/structure/metrics/cartography_from_deg_vectors.tex b/doc/latex/latex/structure/metrics/cartography_from_deg_vectors.tex
new file mode 100644
index 0000000..848ffd1
--- /dev/null
+++ b/doc/latex/latex/structure/metrics/cartography_from_deg_vectors.tex
@@ -0,0 +1,32 @@
+\myprogram{{cartography\_from\_deg\_vectors.py}}
+          {create a multiplex cartography diagram.}  
+          {$<$node\_deg\_vectors$>$}
+
+\mydescription{Compute and print on output the total degree and the
+          multiplex participation coefficient of all the nodes of a
+          multiplex network whose list of node degree vectors is
+          provided as input. The input file is in the format:
+
+  \hspace{0.5cm} \textit{IDn\_deg1 IDn\_deg\_2 ... IDn\_degM}
+
+  \noindent where \textit{IDn\_degX} is the degree of node $n$ at
+  layer $X$. The input file can be generated using the
+  script \texttt{node\_degree\_vectors.py}.}
+
+
+\myreturn{The program prints on \texttt{stdout} a list of lines in the
+  format:
+  
+  \hspace{0.5cm} \textit{tot\_deg part\_coeff}  
+
+  \noindent where \textit{tot\_deg} is the total degree of the node
+  and \textit{part\_coeff} is the corresponding participation
+  coefficient. 
+  
+  \noindent As usual, node IDs start from zero and proceed
+  sequentially, without gaps, so if one of the lines in the input
+  files contains just zeros, the program considers the corresponding
+  node as being isolated on all the layers, and both its total degree
+  and multiplex participation coefficient are set equal to zero. }
+
+\myreference{\refmetrics}
diff --git a/doc/latex/latex/structure/metrics/cartography_from_layers.tex b/doc/latex/latex/structure/metrics/cartography_from_layers.tex
new file mode 100644
index 0000000..8958cef
--- /dev/null
+++ b/doc/latex/latex/structure/metrics/cartography_from_layers.tex
@@ -0,0 +1,45 @@
+\myprogram{{cartography\_from\_layers.py}}
+          {compute the total degree and the multiplex participation
+          coefficient of all the nodes of a multiplex.}  {$<$layer1$>$
+          $<$layer2$>$ [$<$layer3$>$...]}
+
+\mydescription{Compute and print on output the total degree and the multiplex participation
+          coefficient $P_i$ for each node $i$ of a multiplex. The
+                       participation coefficient is defined as:
+
+          \begin{equation*}
+          P_i=\frac{M}{M-1}\left[1-\sum_{\alpha=1}^M\biggl(\frac{k_i^{[\alpha]}}{o_i}\biggr)^2\right] 
+          \end{equation*}
+
+  \noindent Note that $P_i$ takes values in $[0,1]$, where $P_i=0$
+  if and only if node $i$ is active on exactly one of the layers,
+  while $P_i=1$ if node $i$ has equal degree on all the $M$ layers.
+
+  Each input file contains the (undirected) edge list of a layer, and
+  each line is in the format:
+  
+  \hspace{0.5cm}\textit{src\_ID} \textit{dest\_ID}
+  
+  where \textit{src\_ID} and \textit{dest\_ID} are the IDs of the two
+  endpoints of an edge.}
+
+\myreturn{The program prints on \texttt{stdout} a list of lines in the
+  format:
+  
+  \hspace{0.5cm} \textit{deg\_n P\_n col\_n}  
+
+  where \textit{deg\_n} is the total degree of node $n$, \textit{P\_n}
+  is the participation coefficient of node $n$ and \textit{col} is the
+  integer representation of the activity bitstring of node $n$, which
+  is a number between $0$ and $2^{M}-1$. The field \textit{col} might
+  be useful for the visualisation of the multiplex cartography
+  diagram, where it would be possible to associate different colors to
+  nodes having different node activity patterns.
+  
+  \noindent As usual, node IDs start from zero and proceed
+  sequentially, without gaps, i.e., if a node ID is not present in any
+  of the layer files given as input, the program considers it as being
+  isolated on all the layers, and is set to zero.
+  }
+
+\myreference{\refmetrics}
diff --git a/doc/latex/latex/structure/metrics/edge_overlap.tex b/doc/latex/latex/structure/metrics/edge_overlap.tex
new file mode 100644
index 0000000..64d7dbf
--- /dev/null
+++ b/doc/latex/latex/structure/metrics/edge_overlap.tex
@@ -0,0 +1,36 @@
+\myprogram{{edge\_overlap.py}}
+          {compute the edge overlap of all the edges of the
+          multiplex.}  
+          {$<$layer1$>$ [$<$layer2$>$...]}
+
+\mydescription{Compute and print on output the edge overlap $o_{ij}$ of each
+          edge of the multiplex. Given a pair of nodes $(i,j)$ that
+          are directly connected on at least one of the $M$ layers,
+          the edge overlap $o_{ij}$ is defined as:
+
+          \begin{equation*}
+          o_{ij} = \sum_{\alpha}a_{ij}\lay{\alpha}
+          \end{equation*}
+          
+  \noindent i.e., the number of layers on which the edge $(i,j)$
+  exists.
+  
+  
+  Each input file contains the (undirected) edge list of a layer, and
+  each line is in the format:
+  
+  \hspace{0.5cm}\textit{src\_ID} \textit{dest\_ID}
+  
+  where \textit{src\_ID} and \textit{dest\_ID} are the IDs of the two
+  endpoints of an edge.}
+
+\myreturn{The program prints on \texttt{stdout} a list of lines in the
+  format:
+
+  \hspace{0.5cm} \textit{ID\_1 ID\_2 overlap}
+
+  \noindent where \textit{ID\_1} and \textit{ID\_2} are the IDs of the
+  end-points of the edge, and \textit{overlap} is the number of layers
+  in which the edge exists.}
+
+\myreference{\refmetrics}
diff --git a/doc/latex/latex/structure/metrics/intersect_layers.tex b/doc/latex/latex/structure/metrics/intersect_layers.tex
new file mode 100644
index 0000000..0824400
--- /dev/null
+++ b/doc/latex/latex/structure/metrics/intersect_layers.tex
@@ -0,0 +1,28 @@
+\myprogram{{intersect\_layers.py}}
+          {compute the intersection graph associated to a
+          multiplex.}  {$<$layer1$>$ $<$layer2$>$ [$<$layer3$>$...]}
+
+\mydescription{Compute and print on output the edge list of the  
+               intersection graph associated to the multiplex network
+               given on input, where an edge exists only if it is
+               present on \textbf{all} the layers of the multiplex.
+
+  Each input file contains the (undirected) edge list of a layer, and
+  each line is in the format:
+  
+  \hspace{0.5cm}\textit{src\_ID} \textit{dest\_ID}
+  
+  where \textit{src\_ID} and \textit{dest\_ID} are the IDs of the two
+  endpoints of an edge.}
+
+\myreturn{The program prints on \texttt{stdout} the edge list of the
+  intersection graph associated to the multiplex network. The edge
+  list is a list of lines in the format:
+   
+
+  \hspace{0.5cm} \textit{ID1 ID2}
+
+  \noindent where \textit{ID1} and \textit{ID2} are the IDs of the two
+  nodes.}
+
+\myreference{\refcorrelations}
diff --git a/doc/latex/latex/structure/metrics/overlap_degree.tex b/doc/latex/latex/structure/metrics/overlap_degree.tex
new file mode 100644
index 0000000..500a76a
--- /dev/null
+++ b/doc/latex/latex/structure/metrics/overlap_degree.tex
@@ -0,0 +1,45 @@
+\myprogram{{overlap\_degree.py}}
+          {compute the total (overlapping) degree of all the nodes of
+          a multiplex and the corresponding Z-score. }  {$<$layer1$>$ $<$layer2$>$ [$<$layer3$>$...]}
+
+\mydescription{Compute and print on output the total degree $o_i$ of each
+          node $i$ of a multiplex, defined as:
+
+          \begin{equation*}
+            o_{i} = \sum_{\alpha}\sum_{j}a_{ij}\lay{\alpha}
+          \end{equation*}
+
+   \noindent and the corresponding Z-score:
+
+   \begin{equation*}
+    z(o_i) = \frac{o_i - \avg{o}}{\sigma_o}
+   \end{equation*}
+
+  \noindent where $\avg{o}$ and $\sigma_o$ are, respectively, the mean
+  and the standard deviation of the total degree computed over all the
+  active nodes of the multiplex.
+
+
+  Each input file contains the (undirected) edge list of a layer, and
+  each line is in the format:
+  
+  \hspace{0.5cm}\textit{src\_ID} \textit{dest\_ID}
+  
+  where \textit{src\_ID} and \textit{dest\_ID} are the IDs of the two
+  endpoints of an edge.}
+
+\myreturn{The program prints on \texttt{stdout} a list of lines in the
+  format:
+  
+  \hspace{0.5cm} \textit{ID\_n deg\_n z\_n}
+
+  where \textit{ID\_n} is the ID of the node, \textit{deg\_n} is its
+  total degree, and \textit{z\_n} is the corresponding Z-score.
+  
+  \noindent As usual, node IDs start from zero and proceed
+  sequentially, without gaps, i.e., if a node ID is not present in any
+  of the layer files given as input, the program considers it as being
+  isolated on all the layers, and the node is omitted from the
+  output.}
+
+\myreference{\refmetrics}
diff --git a/doc/latex/latex/structure/metrics/part_coeff.tex b/doc/latex/latex/structure/metrics/part_coeff.tex
new file mode 100644
index 0000000..f3afd7d
--- /dev/null
+++ b/doc/latex/latex/structure/metrics/part_coeff.tex
@@ -0,0 +1,43 @@
+\myprogram{{part\_coeff.py}}
+          {compute the multiplex partifipation coefficient of all the nodes of
+          a multiplex.}  {$<$layer1$>$ $<$layer2$>$ [$<$layer3$>$...]}
+
+\mydescription{Compute and print on output the multiplex participation
+          coefficient $P_i$ for each node $i$ of a multiplex. The
+                       participation coefficient is defined as:
+
+          \begin{equation*}
+          P_i=\frac{M}{M-1}\left[1-\sum_{\alpha=1}^M\biggl(\frac{k_i^{[\alpha]}}{o_i}\biggr)^2\right] 
+          \end{equation*}
+
+  \noindent Note that $P_i$ takes values in $[0,1]$, where $P_i=0$
+  if and only if node $i$ is active on exactly one of the layers,
+  while $P_i=1$ if node $i$ has equal degree on all the $M$ layers.
+
+  Each input file contains the (undirected) edge list of a layer, and
+  each line is in the format:
+  
+  \hspace{0.5cm}\textit{src\_ID} \textit{dest\_ID}
+  
+  where \textit{src\_ID} and \textit{dest\_ID} are the IDs of the two
+  endpoints of an edge.}
+
+\myreturn{The program prints on \texttt{stdout} a list of lines in the
+  format:
+  
+  \hspace{0.5cm} \textit{deg\_n P\_n col\_n}  
+
+  where \textit{deg\_n} is the total degree of node $n$, \textit{P\_n}
+  is the participation coefficient of node $n$ and \textit{col} is the
+  integer representation of the activity bitstring of node $n$, which
+  is a number between $0$ and $2^{M}-1$. The field \textit{col} might
+  be useful in visualisations, where it would be possible to associate
+  different colors to nodes having diffrent node activity patterns.
+  
+  \noindent As usual, node IDs start from zero and proceed
+  sequentially, without gaps, i.e., if a node ID is not present in any
+  of the layer files given as input, the program considers it as being
+  isolated on all the layers, and is set to zero.
+  }
+
+\myreference{\refmetrics}
diff --git a/doc/latex/latex/structure/reinforcement/reinforcement.tex b/doc/latex/latex/structure/reinforcement/reinforcement.tex
new file mode 100644
index 0000000..a65b05e
--- /dev/null
+++ b/doc/latex/latex/structure/reinforcement/reinforcement.tex
@@ -0,0 +1,21 @@
+%%%
+%%% Layer activity
+%%%
+
+\myprogram{{reinforcement.py}}
+          {compute the probability to have a link between two nodes in layer $1$ given their weight in layer $2$.}
+          {$<$layer1$>$ $<$layer2$>$ $<N_{bins}>$ $<min_{value}>$ $<max_{value}>$}
+
+\mydescription{Compute and print on output the probability to have a link between two nodes in layer $1$ given their weight in layer $2$. 
+As input are given the files \textit{layer1}, \textit{layer2}, the number of bins for the link weights of the second layer, the minimum and the maximum values of the binning.
+  
+  The first file contains the binary edge list of layer $1$, the second file contains the weighted edge list of layer $2$. each
+  line is in the format:
+  
+  \hspace{0.5cm}\textit{bin\_min} \textit{bin\_max} \textit{freq}
+  
+  where \textit{bin\_min} and \textit{bin\_max} are the minimum and maximum values of the link weights of layer $2$ in that binning, and  \textit{freq} is the probability to have a link on layer $1$ given such weight in layer $2$.}
+
+\myreturn{A list of lines, where the n-th line is the minimum and maximum values of the weight of the links in layer $2$ in the n-th bin, and the frequency to have a link on layer $2$ given that weight.}
+
+\myreference{\refmetrics}
diff --git a/doc/latex/mammult_doc.tex b/doc/latex/mammult_doc.tex
new file mode 100644
index 0000000..4d93d88
--- /dev/null
+++ b/doc/latex/mammult_doc.tex
@@ -0,0 +1,265 @@
+\documentclass[a4paper,11pt]{book}
+
+\usepackage[british]{babel}
+\usepackage[latin1]{inputenc}
+\usepackage{hyperref}
+\usepackage{amsmath, amssymb}
+
+\newcommand{\lay}[1]{^{[#1]}}
+\newcommand{\avg}[1]{\langle #1 \rangle}
+
+
+\newcommand{\myprogram}[3]{\subsubsection{\texttt{#1}}
+  \textbf{NAME}
+    
+  {\textbf{#1} - #2}
+    
+  \vspace{0.5cm}
+  \noindent
+  \textbf{SYNOPSYS}
+  
+  {\textbf{#1} { }\texttt{\textit{#3} } }
+}
+
+\newcommand{\mydescription}[1]{
+  \vspace{0.5cm}
+  \noindent
+  \textbf{DESCRIPTION}
+
+  {#1}
+}
+
+\newcommand{\myreturn}[1]{
+  \vspace{0.5cm}
+  \noindent
+  \textbf{OUTPUT}
+
+  {#1}
+}
+
+
+\newcommand{\myreference}[1]{
+  \vspace{0.5cm}
+  \noindent
+  \textbf{REFERENCE}
+
+  {#1}
+}
+
+%%
+%% REFERENCES
+%%
+
+\newcommand{\refgrowth}{V. Nicosia, G. Bianconi, V. Latora,
+  M. Barthelemy, ``Growing multiplex networks'',
+  \textit{Phys. Rev. Lett.} {\bf 111}, 058701 (2013).
+  
+  Link to paper: \url{http://prl.aps.org/abstract/PRL/v111/i5/e058701}
+}
+\newcommand{\refnonlinear}{V. Nicosia, G. Bianconi, V. Latora,
+  M. Barthelemy, ``Non-linear growth and condensation in multiplex
+  networks'', \textit{Phys. Rev. E} {\bf 90}, 042807 (2014).
+  
+  Link to paper: \url{http://journals.aps.org/pre/abstract/10.1103/PhysRevE.90.042807}
+}
+\newcommand{\refmetrics}{F. Battiston, V. Nicosia, V. Latora,
+  ``Structural measures for multiplex networks'',
+  \textit{Phys. Rev. E} {\bf 89}, 032804 (2014).
+  
+  Link to paper: \url{http://journals.aps.org/pre/abstract/10.1103/PhysRevE.89.032804}
+}
+\newcommand{\refcorrelations}{V. Nicosia, V. Latora, ``Measuring and
+  modeling correlations in multiplex networks'', \textit{Phys. Rev. E}
+  {\bf 92}, 032805 (2015).
+  
+  Link to paper: \url{http://journals.aps.org/pre/abstract/10.1103/PhysRevE.92.032805}}
+
+\newcommand{\refreducibility}{M. De Domenico, V. Nicosia, A. Arenas,
+  V. Latora, \textit{``Structural reducibility of multilayer
+    networks''}, Nat. Commun. {\bf 6}, 6864 (2015).
+  
+  Link to paper: \url{http://www.nature.com/ncomms/2015/150423/ncomms7864/full/ncomms7864.html}
+}
+\newcommand{\refvisibility}{L. Lacasa, V. Nicosia, V. Latora,
+  \textit{``Network structure of multivariate time series''}, accepted
+  for publication in Scientific Reports, arxiv:1408.0925 (2015).
+  
+  Link to paper: \url{http://arxiv.org/abs/1408.0925}
+}
+
+\newcommand{\refbiased}{F. Battiston, V. Nicosia, V. Latora,
+  \textit{``Biased random walks on multiplex networks''}, arxiv:1505.01378 (2015).
+  
+  Link to paper: \url{http://arxiv.org/abs/1505.01378}
+}
+\newcommand{\refising}{F. Battiston, A. Cairoli, V. Nicosia, A. Baule, V. Latora,
+  \textit{``Interplay between consensus and coherence in a model of interacting opinions''}, accepted
+  for publication in Physica D, arxiv:1506.04544 (2015).
+  
+  Link to paper: \url{http://arxiv.org/abs/1506.04544}
+}
+\newcommand{\refcommunity}{F. Battiston, J. Iacovacci, V. Nicosia, G. Bianconi, V. Latora,
+  \textit{``Emergence of multiplex communities in collaboration networks''}, arxiv:1506.01280 (2015).
+  
+  Link to paper: \url{http://arxiv.org/abs/1506.01280}
+}
+
+\newcommand{\refaxelrod}{F. Battiston, V. Nicosia, V. Latora, M. San Miguel,
+  \textit{``Layered social influence promotes multiculturality''}, in preparation (2015).
+  
+  %Link to paper: \url{http://arxiv.org/abs/inpreparation}
+}
+\newcommand{\refmotifs}{F. Battiston, M. Chavez, V. Nicosia, V. Latora,
+  \textit{``Multilayer motifs in brain networks''}, in preparation (2015).
+  
+  %Link to paper: \url{http://arxiv.org/abs/inpreparation}
+}
+
+\title{MAMMULT: Metrics And Models for MULTilayer networks}
+
+
+\begin{document}
+
+\maketitle
+
+\chapter{Structural descriptors}
+
+\section{Basic node, edge, and layer properties}
+
+\subsection{Node and layer activity}
+
+This section includes programs related to the computation of node and
+layer activity, activity vectors, pairwise multiplexity, pairwise
+normalised Hamming distance, node degree vectors.
+
+\input{./latex/structure/activity/node_activity.tex}
+\input{./latex/structure/activity/layer_activity.tex}
+\input{./latex/structure/activity/node_activity_vectors.tex}
+\input{./latex/structure/activity/layer_activity_vectors.tex}
+\input{./latex/structure/activity/multiplexity.tex}
+\input{./latex/structure/activity/hamming_dist.tex}
+\input{./latex/structure/activity/node_degree_vectors.tex}
+\input{./latex/structure/activity/degs_to_binary.tex}
+\input{./latex/structure/activity/degs_to_activity_overlap.tex}
+
+\subsection{Layer aggregation}
+
+This section includes programs to obtain various single-layer
+aggregated graphs associated to a multiplex network. 
+
+\input{./latex/structure/metrics/aggregate_layers_w.tex}
+\input{./latex/structure/metrics/intersect_layers.tex}
+
+\subsection{Node degree, participation coefficient, cartography}
+
+This section includes programs to compute the total degree and
+participation coefficient of each node, and to draw the cartography
+diagram of a multiplex.
+
+\input{./latex/structure/metrics/overlap_degree.tex}
+\input{./latex/structure/metrics/cartography_from_layers.tex}
+\input{./latex/structure/metrics/cartography_from_deg_vectors.tex}
+\input{./latex/structure/metrics/cartography_from_columns.tex}
+
+\subsection{Edge overlap, reinforcement}
+This section includes programs to compute the egde overlap and to
+evaulate the edge reinforcement effect. 
+
+\input{./latex/structure/metrics/edge_overlap.tex}
+\input{./latex/structure/metrics/avg_edge_overlap.tex}
+\input{./latex/structure/reinforcement/reinforcement.tex}
+
+\section{Inter-layer degree correlations}
+
+\subsection{Node ranking}
+
+This section includes various utilities to compute and compare node
+rankings induced by any generic structural node property, including
+degree at different layers.
+
+\input{./latex/structure/correlations/rank_nodes.tex}
+\input{./latex/structure/correlations/rank_nodes_thresh.tex}
+\input{./latex/structure/correlations/rank_occurrence.tex}
+
+\subsection{Interlayer degree correlation coefficients}
+
+This section includes programs for the computation of various
+inter-layer degree correlation coefficients.
+
+\input{./latex/structure/correlations/compute_pearson.tex}
+\input{./latex/structure/correlations/compute_rho.tex}
+\input{./latex/structure/correlations/compute_tau.tex}
+
+
+\subsection{Interlayer degree correlation functions}
+
+This section includes programs to compute intra-layer and inter-layer
+degree correlation functions, and to fit those functions with a
+power-law.
+
+
+\input{./latex/structure/correlations/dump_k_q.tex}
+\input{./latex/structure/correlations/knn_q_from_layers.tex}
+%% \input{./latex/structure/correlations/knn_q_from_layers_log.tex}
+\input{./latex/structure/correlations/knn_q_from_degrees.tex}
+%% \input{./latex/structure/correlations/knn_q_from_degrees_log.tex}
+\input{./latex/structure/correlations/fit_knn.tex}
+
+\chapter{Models of multi-layer networks}
+
+\section{Null models}
+
+\subsection{Null-models of node and layer activity}
+
+\input{./latex/models/nullmodels/model_hypergeometric.tex}
+\input{./latex/models/nullmodels/model_MDM.tex}
+\input{./latex/models/nullmodels/model_MSM.tex}
+\input{./latex/models/nullmodels/model_layer_growth.tex}
+
+
+\section{Growing multiplex networks}
+
+\subsection{Linear preferential attachment}
+
+\input{./latex/models/growth/nibilab_linear_delta.tex}
+\input{./latex/models/growth/nibilab_linear_delay.tex}
+\input{./latex/models/growth/nibilab_linear_delay_mix.tex}
+\input{./latex/models/growth/nibilab_linear_random_times.tex}
+%%\input{./latex/models/growth/nibilab_semilinear.tex}
+
+\subsection{Non-linear preferential attachment}
+
+\input{./latex/models/growth/nibilab_nonlinear.tex}
+
+
+\subsection{Utilities}
+
+\input{./latex/models/growth/node_deg_over_time.tex}
+
+\section{Multiplex networks with inter-layer degree correlations}
+
+\subsection{Models based on simulated annealing}
+
+\input{./latex/models/correlations/tune_rho.tex}
+\input{./latex/models/correlations/tune_qnn_adaptive.tex}
+
+
+\chapter{Dynamics on multi-layer networks}
+
+\section{Interacting opinions - Multilayer ising model}
+
+\input{./latex/dynamics/Ising/multiplex_ising.tex}
+
+\section{Biased random walks}
+
+\subsection{Stationary distribution}
+
+\input{./latex/dynamics/randomwalks/statdistr2.tex}
+
+\subsection{Entropy rate}
+
+\input{./latex/dynamics/randomwalks/entropyrate2add.tex}
+\input{./latex/dynamics/randomwalks/entropyrate2mult.tex}
+\input{./latex/dynamics/randomwalks/entropyrate2int.tex}
+
+\end{document}