For using the igraph C library
"Games" are random graph generators, i.e. they generate a different graph every time they are called. igraph includes many such generators. Some implement stochastic graph construction processes inspired by real-world mechanics, such as preferential attachment, while others are designed to produce graphs with certain used properties (e.g. fixed number of edges, fixed degrees, etc.)
igraph_erdos_renyi_game_gnm
— Generates a random (Erdős-Rényi) graph with a fixed number of edges.igraph_erdos_renyi_game_gnp
— Generates a random (Erdős-Rényi) graph with fixed edge probabilities.igraph_iea_game
— Generates a random multigraph through independent edge assignment.igraph_sbm_game
— Sample from a stochastic block model.igraph_hsbm_game
— Hierarchical stochastic block model.igraph_hsbm_list_game
— Hierarchical stochastic block model, more general version.igraph_preference_game
— Generates a graph with vertex types and connection preferences.igraph_asymmetric_preference_game
— Generates a graph with asymmetric vertex types and connection preferences.igraph_correlated_game
— Generates a random graph correlated to an existing graph.igraph_correlated_pair_game
— Generates pairs of correlated random graphs.
igraph_error_t igraph_erdos_renyi_game_gnm( igraph_t *graph, igraph_int_t n, igraph_int_t m, igraph_bool_t directed, igraph_bool_t loops, igraph_bool_t multiple );
In the G(n, m)
Erdős-Rényi model, a graph with n
vertices
and m
edges is generated uniformly at random.
Arguments:
|
Pointer to an uninitialized graph object. |
|
The number of vertices in the graph. |
|
The number of edges in the graph. |
|
Whether to generate a directed graph. |
|
Whether to generate self-loops. |
|
Whether it is allowed to generate more than one edge between the same pair of vertices. |
Returns:
Error code:
|
Time complexity: O(|V|+|E|), the number of vertices plus the number of edges in the graph.
See also:
|
Example 12.1. File examples/simple/igraph_erdos_renyi_game_gnm.c
#include <igraph.h> int main(void) { igraph_t graph; igraph_vector_int_t component_sizes; /* Initialize the library. */ igraph_setup(); igraph_rng_seed(igraph_rng_default(), 42); /* make program deterministic */ /* Sample a graph from the Erdős-Rényi G(n,m) model */ igraph_erdos_renyi_game_gnm( &graph, /* n= */ 100, /* m= */ 100, IGRAPH_UNDIRECTED, IGRAPH_NO_LOOPS, IGRAPH_NO_MULTIPLE ); /* Compute the fraction of vertices contained within the largest connected component */ igraph_vector_int_init(&component_sizes, 0); igraph_connected_components(&graph, NULL, &component_sizes, NULL, IGRAPH_STRONG); printf( "Fraction of vertices in giant component: %g\n", ((double) igraph_vector_int_max(&component_sizes)) / igraph_vcount(&graph) ); /* Clean up data structures when no longer needed */ igraph_vector_int_destroy(&component_sizes); igraph_destroy(&graph); return 0; }
igraph_error_t igraph_erdos_renyi_game_gnp( igraph_t *graph, igraph_int_t n, igraph_real_t p, igraph_bool_t directed, igraph_bool_t loops );
In the G(n, p)
Erdős-Rényi model, also known as the Gilbert model,
or Bernoulli random graph, a graph with n
vertices is generated such that
every possible edge is included in the graph independently with probability
p
. This is equivalent to a maximum entropy random graph model model with
a constraint on the expected edge count. Setting p = 1/2
generates all graphs on n
vertices with the same probability.
The expected mean degree of the graph is approximately p n
;
set p = k/n
when a mean degree of approximately k
is
desired. More precisely, the expected mean degree is p(n-1)
in (undirected or directed) graphs without self-loops,
p(n+1)
in undirected graphs with self-loops, and
p n
in directed graphs with self-loops.
Arguments:
|
Pointer to an uninitialized graph object. |
|
The number of vertices in the graph. |
|
The probability of the existence of an edge in the graph. |
|
Whether to generate a directed graph. |
|
Whether to generate self-loops. |
Returns:
Error code:
|
Time complexity: O(|V|+|E|), the number of vertices plus the number of edges in the graph.
See also:
|
Example 12.2. File examples/simple/igraph_erdos_renyi_game_gnp.c
#include <igraph.h> int main(void) { igraph_t graph; igraph_vector_int_t component_sizes; /* Initialize the library. */ igraph_setup(); igraph_rng_seed(igraph_rng_default(), 42); /* make program deterministic */ /* Sample a graph from the Erdős-Rényi G(n,p) model */ igraph_erdos_renyi_game_gnp( &graph, /* n= */ 100, /* p= */ 0.01, IGRAPH_UNDIRECTED, IGRAPH_NO_LOOPS ); /* Compute the fraction of vertices contained within the largest connected component */ igraph_vector_int_init(&component_sizes, 0); igraph_connected_components(&graph, NULL, &component_sizes, NULL, IGRAPH_STRONG); printf( "Fraction of vertices in giant component: %g\n", ((double) igraph_vector_int_max(&component_sizes)) / igraph_vcount(&graph) ); /* Clean up data structures when no longer needed */ igraph_vector_int_destroy(&component_sizes); igraph_destroy(&graph); return 0; }
igraph_error_t igraph_iea_game( igraph_t *graph, igraph_int_t n, igraph_int_t m, igraph_bool_t directed, igraph_bool_t loops);
This function is experimental and its signature is not considered final yet. We reserve the right to change the function signature without changing the major version of igraph. Use it at your own risk.
This model generates random multigraphs on n
vertices with m
edges
through independent edge assignment (IEA). Each of the m
edges is assigned
uniformly at random to an ordered vertex pair, independently of each
other.
This model does not sample multigraphs uniformly. Undirected graphs are generated with probability proportional to
(prod_(i<j) A_ij ! prod_i A_ii !!)^(-1)
,
where A
denotes the adjacency matrix and !!
denotes
the double factorial. Here A
is assumed to have twice the number of
self-loops on its diagonal. The corresponding expression for directed
graphs is
(prod_(i,j) A_ij !)^(-1)
.
Thus the probability of all simple graphs (which only have 0s and 1s in the adjacency matrix) is the same, while that of non-simple ones depends on their edge and self-loop multiplicities.
An alternative way to think of this model is that it performs uniform sampling of edge-labeled graphs, i.e. graphs in which not only vertices, but also edges carry unique identities and are distinguishable.
Arguments:
|
Pointer to an uninitialized graph object. |
|
The number of vertices in the graph. |
|
The number of edges in the graph. |
|
Whether to generate a directed graph. |
|
Whether to generate self-loops. |
Returns:
Error code:
|
Time complexity: O(|V|+|E|), the number of vertices plus the number of edges in the graph.
See also:
|
igraph_error_t igraph_sbm_game( igraph_t *graph, const igraph_matrix_t *pref_matrix, const igraph_vector_int_t *block_sizes, igraph_bool_t directed, igraph_edge_type_sw_t allowed_edge_types);
This function samples graphs from a stochastic block model, a generalization of the G(n,p) model where the connection probability p (or expected number of edges for multigraphs) is specified separately between and within a given group of vertices.
The order of the vertex IDs in the generated graph corresponds to
the block_sizes
argument.
Reference:
Faust, K., & Wasserman, S. (1992a). Blockmodels: Interpretation and evaluation. Social Networks, 14, 5-–61. https://doi.org/10.1016/0378-8733(92)90013-W
Arguments:
|
The output graph. This should be a pointer to an uninitialized graph. |
|
The matrix giving the connection probabilities (or expected edge multiplicities for multigraphs) between groups. This is a k-by-k matrix, where k is the number of groups. The probability of creating an edge between vertices from groups i and j is given by element (i,j). |
|
An integer vector giving the number of vertices in each group. |
|
Boolean, whether to create a directed graph. If
this argument is |
|
Controls whether multi-edges and self-loops
are generated. See |
Returns:
Error code. |
Time complexity: O(|V|+|E|+k^2), where |V| is the number of vertices, |E| is the number of edges, and k is the number of groups.
See also:
|
igraph_error_t igraph_hsbm_game(igraph_t *graph, igraph_int_t n, igraph_int_t m, const igraph_vector_t *rho, const igraph_matrix_t *C, igraph_real_t p);
The function generates a random graph according to the hierarchical stochastic block model.
Arguments:
|
The generated graph is stored here. |
|
The number of vertices in the graph. |
|
The number of vertices per block. n/m must be integer. |
|
The fraction of vertices per cluster, within a block. Must sum up to 1, and rho * m must be integer for all elements of rho. |
|
A square, symmetric numeric matrix, the Bernoulli rates for
the clusters within a block. Its size must mach the size of the
|
|
The Bernoulli rate of connections between vertices in different blocks. |
Returns:
Error code. |
See also:
|
igraph_error_t igraph_hsbm_list_game(igraph_t *graph, igraph_int_t n, const igraph_vector_int_t *mlist, const igraph_vector_list_t *rholist, const igraph_matrix_list_t *Clist, igraph_real_t p);
The function generates a random graph according to the hierarchical stochastic block model.
Arguments:
|
The generated graph is stored here. |
|
The number of vertices in the graph. |
|
An integer vector of block sizes. |
|
A list of rho vectors ( |
|
A list of square matrices ( |
|
The Bernoulli rate of connections between vertices in different blocks. |
Returns:
Error code. |
See also:
|
igraph_error_t igraph_preference_game(igraph_t *graph, igraph_int_t nodes, igraph_int_t types, const igraph_vector_t *type_dist, igraph_bool_t fixed_sizes, const igraph_matrix_t *pref_matrix, igraph_vector_int_t *node_type_vec, igraph_bool_t directed, igraph_bool_t loops);
This is practically the nongrowing variant of
igraph_establishment_game()
. A given number of vertices are
generated. Every vertex is assigned to a vertex type according to
the given type probabilities. Finally, every
vertex pair is evaluated and an edge is created between them with a
probability depending on the types of the vertices involved.
In other words, this function generates a graph according to a block-model. Vertices are divided into groups (or blocks), and the probability the two vertices are connected depends on their groups only.
Arguments:
|
Pointer to an uninitialized graph. |
|
The number of vertices in the graph. |
|
The number of vertex types. |
|
Vector giving the distribution of vertex types. If
|
|
Boolean. If true, then the number of vertices with a
given vertex type is fixed and the |
|
Matrix giving the connection probabilities for different vertex types. This should be symmetric if the requested graph is undirected. |
|
A vector where the individual generated vertex types
will be stored. If |
|
Whether to generate a directed graph. If undirected graphs are requested, only the lower left triangle of the preference matrix is considered. |
|
Whether loop edges are allowed. |
Returns:
Error code. |
Added in version 0.3.
Time complexity: O(|V|+|E|), the number of vertices plus the number of edges in the graph.
See also:
igraph_error_t igraph_asymmetric_preference_game(igraph_t *graph, igraph_int_t nodes, igraph_int_t no_out_types, igraph_int_t no_in_types, const igraph_matrix_t *type_dist_matrix, const igraph_matrix_t *pref_matrix, igraph_vector_int_t *node_type_out_vec, igraph_vector_int_t *node_type_in_vec, igraph_bool_t loops);
This is the asymmetric variant of igraph_preference_game()
.
A given number of vertices are generated. Every vertex is assigned to an
"outgoing" and an "incoming " vertex type according to the given joint
type probabilities. Finally, every vertex pair is evaluated and a
directed edge is created between them with a probability depending on the
"outgoing" type of the source vertex and the "incoming" type of the target
vertex.
Arguments:
|
Pointer to an uninitialized graph. |
|
The number of vertices in the graph. |
|
The number of vertex out-types. |
|
The number of vertex in-types. |
|
Matrix of size |
|
Matrix of size |
|
A vector where the individual generated "outgoing"
vertex types will be stored. If |
|
A vector where the individual generated "incoming"
vertex types will be stored. If |
|
Whether loop edges are allowed. |
Returns:
Error code. |
Added in version 0.3.
Time complexity: O(|V|+|E|), the number of vertices plus the number of edges in the graph.
See also:
igraph_error_t igraph_correlated_game(const igraph_t *old_graph, igraph_t *new_graph, igraph_real_t corr, igraph_real_t p, const igraph_vector_int_t *permutation);
Sample a new graph by perturbing the adjacency matrix of a given simple graph and shuffling its vertices.
Arguments:
|
The original graph, it must be simple. |
|
The new graph will be stored here. |
|
A value in the unit interval [0,1], the target Pearson correlation between the adjacency matrices of the original and the generated graph (the adjacency matrix being used as a vector). |
|
The probability of an edge between two vertices. It must in the
open (0,1) interval. Typically, the density of |
|
A permutation to apply to the vertices of the generated graph. It can also be a null pointer, in which case the vertices will not be permuted. |
Returns:
Error code |
See also:
|
igraph_error_t igraph_correlated_pair_game(igraph_t *graph1, igraph_t *graph2, igraph_int_t n, igraph_real_t corr, igraph_real_t p, igraph_bool_t directed, const igraph_vector_int_t *permutation);
Sample two random graphs, with given correlation.
Arguments:
|
The first graph will be stored here. |
|
The second graph will be stored here. |
|
The number of vertices in both graphs. |
|
A scalar in the unit interval, the target Pearson correlation between the adjacency matrices of the original the generated graph (the adjacency matrix being used as a vector). |
|
A numeric scalar, the probability of an edge between two vertices, it must in the open (0,1) interval. |
|
Whether to generate directed graphs. |
|
A permutation to apply to the vertices of the second graph. It can also be a null pointer, in which case the vertices will not be permuted. |
Returns:
Error code |
See also:
|
igraph_barabasi_game
— Generates a graph based on the Barabási-Albert model.igraph_barabasi_aging_game
— Preferential attachment with aging of vertices.igraph_recent_degree_game
— Stochastic graph generator based on the number of incident edges a node has gained recently.igraph_recent_degree_aging_game
— Preferential attachment based on the number of edges gained recently, with aging of vertices.igraph_lastcit_game
— Simulates a citation network, based on time passed since the last citation.Preferential attachment models are growing random graphs where vertices are added iteratively, and connected to previously added vertices based on dynamically changing vertex properties, such as degree or time since the vertex was added.
igraph_error_t igraph_barabasi_game(igraph_t *graph, igraph_int_t n, igraph_real_t power, igraph_int_t m, const igraph_vector_int_t *outseq, igraph_bool_t outpref, igraph_real_t A, igraph_bool_t directed, igraph_barabasi_algorithm_t algo, const igraph_t *start_from);
This function implements several variants of the preferential attachment
process, including linear and non-linear varieties of the Barabási-Albert
and Price models. The graph construction starts with a single vertex,
or an existing graph given by the start_from
parameter. Then new vertices
are added one at a time. Each new vertex connects to m
existing vertices,
choosing them with probabilities proportional to
d^power + A
,
where d
is the in- or total degree of the existing vertex (controlled
by the outpref
argument), while power
and A
are given by
parameters. The constant attractiveness A
is used to ensure that vertices with zero in-degree can also be
connected to with non-zero probability.
Barabási, A.-L. and Albert R. 1999. Emergence of scaling in random networks, Science, 286 509--512. https://doi.org/10.1126/science.286.5439.509
de Solla Price, D. J. 1965. Networks of Scientific Papers, Science, 149 510--515. https://doi.org/10.1126/science.149.3683.510
Arguments:
|
An uninitialized graph object. |
||||||
|
The number of vertices in the graph. |
||||||
|
Power of the preferential attachment. In the classic preferential
attachment model |
||||||
|
The number of outgoing edges generated for each
vertex. Only used when |
||||||
|
Gives the (out-)degrees of the vertices. If this is
constant, this can be a |
||||||
|
Boolean, if true not only the in- but also the out-degree of a vertex increases its citation probability. I.e., the citation probability is determined by the total degree of the vertices. Ignored and assumed to be true if the graph being generated is undirected. |
||||||
|
The constant attractiveness of vertices. When |
||||||
|
Boolean, whether to generate a directed graph.
When set to |
||||||
|
The algorithm to use to generate the network. Possible values:
|
||||||
|
Either a |
Returns:
Error code:
|
Time complexity: O(|V|+|E|), the number of vertices plus the number of edges.
Example 12.3. File examples/simple/igraph_barabasi_game.c
#include <igraph.h> int main(void) { igraph_t g; igraph_vector_int_t v; igraph_vector_int_t v2, v3; /* Initialize the library. */ igraph_setup(); igraph_barabasi_game(&g, 10, /*power=*/ 1, 2, 0, 0, /*A=*/ 1, 1, IGRAPH_BARABASI_BAG, /*start_from=*/ 0); if (igraph_ecount(&g) != 18) { return 1; } if (igraph_vcount(&g) != 10) { return 2; } if (!igraph_is_directed(&g)) { return 3; } igraph_vector_int_init(&v, 0); igraph_get_edgelist(&g, &v, 0); for (igraph_int_t i = 0; i < igraph_ecount(&g); i++) { if (VECTOR(v)[2 * i] <= VECTOR(v)[2 * i + 1]) { return 4; } } igraph_vector_int_destroy(&v); igraph_destroy(&g); /* out-degree sequence */ igraph_vector_int_init_int(&v3, 10, 0, 1, 3, 3, 4, 5, 6, 7, 8, 9); igraph_barabasi_game(&g, 10, /*power=*/ 1, 0, &v3, 0, /*A=*/ 1, 1, IGRAPH_BARABASI_BAG, /*start_from=*/ 0); if (igraph_ecount(&g) != igraph_vector_int_sum(&v3)) { return 5; } igraph_vector_int_init(&v2, 0); igraph_degree(&g, &v2, igraph_vss_all(), IGRAPH_OUT, IGRAPH_LOOPS); for (igraph_int_t i = 0; i < igraph_vcount(&g); i++) { if (VECTOR(v3)[i] != VECTOR(v2)[i]) { igraph_vector_int_print(&v3); printf("\n"); igraph_vector_int_print(&v2); return 6; } } igraph_vector_int_destroy(&v3); igraph_vector_int_destroy(&v2); igraph_destroy(&g); /* outpref, we cannot really test this quantitatively, would need to set random seed */ igraph_barabasi_game(&g, 10, /*power=*/ 1, 2, 0, 1, /*A=*/ 1, 1, IGRAPH_BARABASI_BAG, /*start_from=*/ 0); igraph_vector_int_init(&v, 0); igraph_get_edgelist(&g, &v, 0); for (igraph_int_t i = 0; i < igraph_ecount(&g); i++) { if (VECTOR(v)[2 * i] <= VECTOR(v)[2 * i + 1]) { return 7; } } if (!igraph_is_directed(&g)) { return 8; } igraph_vector_int_destroy(&v); igraph_destroy(&g); return 0; }
Example 12.4. File examples/simple/igraph_barabasi_game2.c
#include <igraph.h> #include <stdio.h> int main(void) { igraph_t g; igraph_bool_t simple; /* Initialize the library. */ igraph_setup(); igraph_barabasi_game(/* graph= */ &g, /* n= */ 100, /* power= */ 1.0, /* m= */ 2, /* outseq= */ 0, /* outpref= */ 0, /* A= */ 1.0, /* directed= */ IGRAPH_DIRECTED, /* algo= */ IGRAPH_BARABASI_PSUMTREE, /* start_from= */ 0); if (igraph_ecount(&g) != 197) { return 1; } if (igraph_vcount(&g) != 100) { return 2; } igraph_is_simple(&g, &simple, IGRAPH_DIRECTED); if (!simple) { return 3; } igraph_destroy(&g); /* ============================== */ igraph_barabasi_game(/* graph= */ &g, /* n= */ 100, /* power= */ 1.0, /* m= */ 2, /* outseq= */ 0, /* outpref= */ 0, /* A= */ 1.0, /* directed= */ IGRAPH_DIRECTED, /* algo= */ IGRAPH_BARABASI_PSUMTREE_MULTIPLE, /* start_from= */ 0); if (igraph_ecount(&g) != 198) { return 4; } if (igraph_vcount(&g) != 100) { return 5; } igraph_is_simple(&g, &simple, IGRAPH_DIRECTED); if (simple) { return 6; } igraph_destroy(&g); /* ============================== */ igraph_barabasi_game(/* graph= */ &g, /* n= */ 100, /* power= */ 1.0, /* m= */ 2, /* outseq= */ 0, /* outpref= */ 0, /* A= */ 1.0, /* directed= */ IGRAPH_DIRECTED, /* algo= */ IGRAPH_BARABASI_BAG, /* start_from= */ 0); if (igraph_ecount(&g) != 198) { return 7; } if (igraph_vcount(&g) != 100) { return 8; } igraph_is_simple(&g, &simple, IGRAPH_DIRECTED); if (simple) { return 9; } igraph_destroy(&g); return 0; }
igraph_error_t igraph_barabasi_aging_game(igraph_t *graph, igraph_int_t nodes, igraph_int_t m, const igraph_vector_int_t *outseq, igraph_bool_t outpref, igraph_real_t pa_exp, igraph_real_t aging_exp, igraph_int_t aging_bins, igraph_real_t zero_deg_appeal, igraph_real_t zero_age_appeal, igraph_real_t deg_coef, igraph_real_t age_coef, igraph_bool_t directed);
This game starts with one vertex (if nodes
> 0). In each step
a new node is added, and it is connected to m
existing nodes.
Existing nodes to connect to are chosen with probability dependent
on their (in-)degree (k
) and age (l
).
The degree-dependent part is
deg_coef * k^pa_exp + zero_deg_appeal
,
while the age-dependent part is
age_coef * l^aging_exp + zero_age_appeal
,
which are multiplied to obtain the final weight.
The age l
is based on the number of vertices in the
network and the aging_bins
argument: the age of a node
is incremented by 1 after each
floor(nodes / aging_bins) + 1
time steps.
Arguments:
|
Pointer to an uninitialized graph object. |
|
The number of vertices in the graph. |
|
The number of edges to add in each time step.
Ignored if |
|
The number of edges to add in each time step. If it
is |
|
Boolean constant, whether the edges initiated by a vertex contribute to the probability to gain a new edge. |
|
The exponent of the preferential attachment, a small positive number usually, the value 1 yields the classic linear preferential attachment. |
|
The exponent of the aging, this is a negative number usually. |
|
Integer constant, the number of age bins to use. |
|
The degree dependent part of the attractiveness of the zero degree vertices. |
|
The age dependent part of the attractiveness of the vertices of age zero. This parameter is usually zero. |
|
The coefficient for the degree. |
|
The coefficient for the age. |
|
Boolean constant, whether to generate a directed graph. |
Returns:
Error code. |
Time complexity: O((|V|+|V|/aging_bins)*log(|V|)+|E|). |V| is the number of vertices, |E| the number of edges.
igraph_error_t igraph_recent_degree_game(igraph_t *graph, igraph_int_t nodes, igraph_real_t power, igraph_int_t time_window, igraph_int_t m, const igraph_vector_int_t *outseq, igraph_bool_t outpref, igraph_real_t zero_appeal, igraph_bool_t directed);
Arguments:
|
Pointer to an uninitialized graph object. |
|
The number of vertices in the graph, this is the same as the number of time steps. |
|
The exponent, the probability that a node gains a
new edge is proportional to the number of edges it has
gained recently (in the last |
|
Integer constant, the size of the time window to use to count the number of recent edges. |
|
Integer constant, the number of edges to add per time
step if the |
|
The number of edges to add in each time step. This
argument is ignored if it is a null pointer or a zero length
vector. In this case the constant |
|
Boolean constant, if true the edges originated by a vertex also count as recent incident edges. For most applications it is reasonable to set it to false. |
|
Constant giving the attractiveness of the vertices which haven't gained any edge recently. |
|
Boolean constant, whether to generate a directed graph. |
Returns:
Error code. |
Time complexity: O(|V|*log(|V|)+|E|), |V| is the number of vertices, |E| is the number of edges in the graph.
igraph_error_t igraph_recent_degree_aging_game(igraph_t *graph, igraph_int_t nodes, igraph_int_t m, const igraph_vector_int_t *outseq, igraph_bool_t outpref, igraph_real_t pa_exp, igraph_real_t aging_exp, igraph_int_t aging_bins, igraph_int_t time_window, igraph_real_t zero_appeal, igraph_bool_t directed);
This game is very similar to igraph_barabasi_aging_game()
,
except that instead of the total number of incident edges the
number of edges gained in the last time_window
time steps are
counted.
The degree dependent part of the attractiveness is
given by k to the power of pa_exp
plus zero_appeal
; the age
dependent part is l to the power to aging_exp
.
k is the number of edges gained in the last time_window
time
steps, l is the age of the vertex.
Arguments:
|
Pointer to an uninitialized graph object. |
|
The number of vertices in the graph. |
|
The number of edges to add in each time step. If the |
|
Vector giving the number of edges to add in each time
step. If it is a null pointer or a zero-length vector then
it is ignored and the |
|
Boolean constant, if true the edges initiated by a vertex are also counted. Normally it is false. |
|
The exponent for the preferential attachment. |
|
The exponent for the aging, normally it is negative: old vertices gain edges with less probability. |
|
Integer constant, the number of age bins to use. |
|
The time window to use to count the number of incident edges for the vertices. |
|
The degree dependent part of the attractiveness for zero degree vertices. |
|
Boolean constant, whether to create a directed graph. |
Returns:
Error code. |
Time complexity: O((|V|+|V|/aging_bins)*log(|V|)+|E|). |V| is the number of vertices, |E| the number of edges.
igraph_error_t igraph_lastcit_game(igraph_t *graph, igraph_int_t nodes, igraph_int_t edges_per_node, igraph_int_t agebins, const igraph_vector_t *preference, igraph_bool_t directed);
This is a quite special stochastic graph generator, it models an
evolving graph. In each time step a single vertex is added to the
network and it cites a number of other vertices (as specified by
the edges_per_step
argument). The cited vertices are selected
based on the last time they were cited. Time is measured by the
addition of vertices and it is binned into agebins
bins.
So if the current time step is t
and the last citation to a
given i
vertex was made in time step t0
, then
(t-t0) / binwidth
is calculated where binwidth is
nodes/agebins + 1
,
in the last expression '/' denotes integer division, so the
fraction part is omitted.
The preference
argument specifies the preferences for the
citation lags, i.e. its first elements contains the attractivity
of the very recently cited vertices, etc. The last element is
special, it contains the attractivity of the vertices which were
never cited. This element should be bigger than zero.
Note that this function generates networks with multiple edges if
edges_per_step
is bigger than one, call igraph_simplify()
on the result to get rid of these edges.
Arguments:
|
Pointer to an uninitialized graph object, the result will be stored here. |
|
The number of vertices in the network. |
|
The number of edges to add in each time step. |
|
The number of age bins to use. |
|
Pointer to an initialized vector of length
|
|
Boolean constant, whether to create directed networks. |
Returns:
Error code. |
See also:
Time complexity: O(|V|*a+|E|*log|V|), |V| is the number of vertices,
|E| is the total number of edges, a is the agebins
parameter.
igraph_growing_random_game
— Generates a growing random graph.igraph_callaway_traits_game
— Simulates a growing network with vertex types.igraph_establishment_game
— Generates a graph with a simple growing model with vertex types.igraph_cited_type_game
— Simulates a citation based on vertex types.igraph_citing_cited_type_game
— Simulates a citation network based on vertex types.igraph_forest_fire_game
— Generates a network according to the “forest fire game”.In growing random graphs, vertices are added iteratively, and connected based on various rules. Preferential attachment models are documented in their own section.
igraph_error_t igraph_growing_random_game(igraph_t *graph, igraph_int_t n, igraph_int_t m, igraph_bool_t directed, igraph_bool_t citation);
This function simulates a growing random graph. We start out with one vertex. In each step a new vertex is added and a number of new edges are also added. These graphs are known to be different from standard (not growing) random graphs.
Arguments:
|
Uninitialized graph object. |
|
The number of vertices in the graph. |
|
The number of edges to add in a time step (i.e. after adding a vertex). |
|
Boolean, whether to generate a directed graph. |
|
Boolean, if |
Returns:
Error code:
|
Time complexity: O(|V|+|E|), the number of vertices plus the number of edges.
igraph_error_t igraph_callaway_traits_game(igraph_t *graph, igraph_int_t nodes, igraph_int_t types, igraph_int_t edges_per_step, const igraph_vector_t *type_dist, const igraph_matrix_t *pref_matrix, igraph_bool_t directed, igraph_vector_int_t *node_type_vec);
The different types of vertices prefer to connect other types of vertices with a given probability.
The simulation goes like this: in each discrete time step a new
vertex is added to the graph. The type of this vertex is generated
based on type_dist
. Then two vertices are selected uniformly
randomly from the graph. The probability that they will be
connected depends on the types of these vertices and is taken from
pref_matrix
. Then another two vertices are selected and this is
repeated edges_per_step
times in each time step.
References:
D. S. Callaway, J. E. Hopcroft, J. M. Kleinberg, M. E. J. Newman, and S. H. Strogatz, Are randomly grown graphs really random? Phys. Rev. E 64, 041902 (2001). https://doi.org/10.1103/PhysRevE.64.041902
Arguments:
|
Pointer to an uninitialized graph. |
|
The number of nodes in the graph. |
|
Number of node types. |
|
The number of connections tried in each time step. |
|
Vector giving the distribution of the vertex types.
If |
|
Matrix giving the connection probabilities for the vertex types. |
|
Whether to generate a directed graph. |
|
An initialized vector or |
Returns:
Error code. |
Added in version 0.2.
Time complexity: O(|V|*k*log(|V|)), |V| is the number of vertices,
k is edges_per_step
.
igraph_error_t igraph_establishment_game(igraph_t *graph, igraph_int_t nodes, igraph_int_t types, igraph_int_t k, const igraph_vector_t *type_dist, const igraph_matrix_t *pref_matrix, igraph_bool_t directed, igraph_vector_int_t *node_type_vec);
The simulation goes like this: a single vertex is added at each
time step. This new vertex tries to connect to k
vertices in the
graph. The probability that such a connection is realized depends
on the types of the vertices involved.
Arguments:
|
Pointer to an uninitialized graph. |
|
The number of vertices in the graph. |
|
The number of vertex types. |
|
The number of connections tried in each time step. |
|
Vector giving the distribution of vertex types.
If |
|
Matrix giving the connection probabilities for different vertex types. |
|
Whether to generate a directed graph. |
|
An initialized vector or |
Returns:
Error code. |
Added in version 0.2.
Time complexity: O(|V|*k*log(|V|)), |V| is the number of vertices
and k is the k
parameter.
igraph_error_t igraph_cited_type_game(igraph_t *graph, igraph_int_t nodes, const igraph_vector_int_t *types, const igraph_vector_t *pref, igraph_int_t edges_per_step, igraph_bool_t directed);
Function to create a network based on some vertex categories. This
function creates a citation network: in each step a single vertex
and edges_per_step
citing edges are added. Nodes with
different categories may have different probabilities to get
cited, as given by the pref
vector.
Note that this function might generate networks with multiple edges
if edges_per_step
is greater than one. You might want to call
igraph_simplify()
on the result to remove multiple edges.
Arguments:
|
Pointer to an uninitialized graph object. |
|
The number of vertices in the network. |
|
Numeric vector giving the categories of the vertices,
so it should contain |
|
The attractivity of the different vertex categories in
a vector. Its length should be the maximum element in |
|
Integer constant, the number of edges to add in each time step. |
|
Boolean constant, whether to create a directed network. |
Returns:
Error code. |
See also:
|
Time complexity: O((|V|+|E|)log|V|), |V| and |E| are number of vertices and edges, respectively.
igraph_error_t igraph_citing_cited_type_game(igraph_t *graph, igraph_int_t nodes, const igraph_vector_int_t *types, const igraph_matrix_t *pref, igraph_int_t edges_per_step, igraph_bool_t directed);
This game is similar to igraph_cited_type_game()
but here the
category of the citing vertex is also considered.
An evolving citation network is modeled here, a single vertex and
its edges_per_step
citation are added in each time step. The
odds the a given vertex is cited by the new vertex depends on the
category of both the citing and the cited vertex and is given in
the pref
matrix. The categories of the citing vertex correspond
to the rows, the categories of the cited vertex to the columns of
this matrix. I.e. the element in row i
and column j
gives the
probability that a j
vertex is cited, if the category of the
citing vertex is i
.
Note that this function might generate networks with multiple edges
if edges_per_step
is greater than one. You might want to call
igraph_simplify()
on the result to remove multiple edges.
Arguments:
|
Pointer to an uninitialized graph object. |
|
The number of vertices in the network. |
|
A numeric vector of length |
|
The preference matrix, a square matrix is required,
both the number of rows and columns should be the maximum
element in |
|
Integer constant, the number of edges to add in each time step. |
|
Boolean constant, whether to create a directed network. |
Returns:
Error code. |
Time complexity: O((|V|+|E|)log|V|), |V| and |E| are number of vertices and edges, respectively.
igraph_error_t igraph_forest_fire_game(igraph_t *graph, igraph_int_t nodes, igraph_real_t fw_prob, igraph_real_t bw_factor, igraph_int_t pambs, igraph_bool_t directed);
The forest fire model intends to reproduce the following network characteristics, observed in real networks:
Heavy-tailed in- and out-degree distributions.
Community structure.
Densification power-law. The network is densifying in time, according to a power-law rule.
Shrinking diameter. The diameter of the network decreases in time.
The network is generated in the following way. One vertex is added at
a time. This vertex connects to (cites) ambs
vertices already
present in the network, chosen uniformly random. Now, for each cited
vertex v
we do the following procedure:
We generate two random numbers, x
and y
, that are
geometrically distributed with means p/(1-p)
and
rp(1-rp)
. (p
is fw_prob
, r
is
bw_factor
.) The new vertex cites x
outgoing neighbors
and y
incoming neighbors of v
, from those which are
not yet cited by the new vertex. If there are less than x
or
y
such vertices available then we cite all of them.
The same procedure is applied to all the newly cited vertices.
See also: Jure Leskovec, Jon Kleinberg and Christos Faloutsos. Graphs over time: densification laws, shrinking diameters and possible explanations. KDD '05: Proceeding of the eleventh ACM SIGKDD international conference on Knowledge discovery in data mining , 177--187, 2005.
Note however, that the version of the model in the published paper is incorrect in the sense that it cannot generate the kind of graphs the authors claim. A corrected version is available from https://www.cs.cmu.edu/~jure/pubs/powergrowth-tkdd.pdf, our implementation is based on this.
Arguments:
|
Pointer to an uninitialized graph object. |
|
The number of vertices in the graph. |
|
The forward burning probability. |
|
The backward burning ratio. The backward burning
probability is calculated as |
|
The number of ambassador vertices. |
|
Whether to create a directed graph. |
Returns:
Error code. |
Time complexity: TODO.
igraph_degree_sequence_game
— Generates a random graph with a given degree sequence.igraph_k_regular_game
— Generates a random graph where each vertex has the same degree.igraph_rewire
— Randomly rewires a graph while preserving its degree sequence.igraph_chung_lu_game
— Samples graphs from the Chung-Lu model.igraph_static_fitness_game
— Non-growing random graph with edge probabilities proportional to node fitness scores.igraph_static_power_law_game
— Generates a non-growing random graph with expected power-law degree distributions.Random graph models with hard or soft degree constraints.
igraph_error_t igraph_degree_sequence_game( igraph_t *graph, const igraph_vector_int_t *out_degrees, const igraph_vector_int_t *in_degrees, igraph_degseq_t method);
This function generates random graphs with a prescribed degree sequence. Several sampling methods are available, which respect different constraints (simple graph or multigraphs, connected graphs, etc.), and provide different tradeoffs between performance and unbiased sampling. See Section 2.1 of Horvát and Modes (2021) for an overview of sampling techniques for graphs with fixed degrees.
References:
Fabien Viger, and Matthieu Latapy: Efficient and Simple Generation of Random Simple Connected Graphs with Prescribed Degree Sequence, Journal of Complex Networks 4, no. 1, pp. 15–37 (2015). https://doi.org/10.1093/comnet/cnv013.
Szabolcs Horvát, and Carl D Modes: Connectedness Matters: Construction and Exact Random Sampling of Connected Networks, Journal of Physics: Complexity 2, no. 1, pp. 015008 (2021). https://doi.org/10.1088/2632-072x/abced5.
Arguments:
|
Pointer to an uninitialized graph object. |
||||||||||
|
A vector of integers specifying the degree sequence for undirected graphs or the out-degree sequence for directed graphs. |
||||||||||
|
A vector of integers specifying the in-degree sequence for
directed graphs. For undirected graphs, it must be |
||||||||||
|
The method to generate the graph. Possible values:
|
Returns:
Error code:
|
Time complexity: O(|V|+|E|), the number of vertices plus the number of edges
for IGRAPH_DEGSEQ_CONFIGURATION
and IGRAPH_DEGSEQ_EDGE_SWITCHING_SIMPLE
.
The time complexity of the other modes is not known.
See also:
|
Example 12.5. File examples/simple/igraph_degree_sequence_game.c
#include <igraph.h> int main(void) { igraph_t g; igraph_vector_int_t outdeg, indeg; igraph_vector_int_t vec; igraph_bool_t is_simple; /* Initialize the library. */ igraph_setup(); /* Set random seed for reproducibility */ igraph_rng_seed(igraph_rng_default(), 42); igraph_vector_int_init_int(&outdeg, 10, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3); igraph_vector_int_init_int(&indeg, 10, 4, 4, 2, 2, 4, 4, 2, 2, 3, 3); igraph_vector_int_init(&vec, 0); /* checking the configuration model, undirected graphs */ igraph_degree_sequence_game(&g, &outdeg, 0, IGRAPH_DEGSEQ_CONFIGURATION); if (igraph_is_directed(&g) || igraph_vcount(&g) != 10) { return 1; } if (igraph_degree(&g, &vec, igraph_vss_all(), IGRAPH_OUT, IGRAPH_LOOPS)) { return 2; } igraph_vector_int_print(&vec); igraph_destroy(&g); /* checking the Viger-Latapy method, undirected graphs */ igraph_degree_sequence_game(&g, &outdeg, 0, IGRAPH_DEGSEQ_VL); if (igraph_is_directed(&g) || igraph_vcount(&g) != 10) { return 3; } if (igraph_is_simple(&g, &is_simple, IGRAPH_DIRECTED) || !is_simple) { return 4; } if (igraph_degree(&g, &vec, igraph_vss_all(), IGRAPH_OUT, IGRAPH_NO_LOOPS)) { return 5; } igraph_vector_int_print(&vec); igraph_destroy(&g); /* checking the configuration model, directed graphs */ igraph_degree_sequence_game(&g, &outdeg, &indeg, IGRAPH_DEGSEQ_CONFIGURATION); if (!igraph_is_directed(&g) || igraph_vcount(&g) != 10) { return 6; } if (igraph_degree(&g, &vec, igraph_vss_all(), IGRAPH_OUT, IGRAPH_LOOPS)) { return 7; } igraph_vector_int_print(&vec); if (igraph_degree(&g, &vec, igraph_vss_all(), IGRAPH_IN, IGRAPH_LOOPS)) { return 8; } igraph_vector_int_print(&vec); igraph_destroy(&g); /* checking the fast heuristic method, undirected graphs */ igraph_degree_sequence_game(&g, &outdeg, 0, IGRAPH_DEGSEQ_FAST_HEUR_SIMPLE); if (igraph_is_directed(&g) || igraph_vcount(&g) != 10) { return 9; } if (igraph_is_simple(&g, &is_simple, IGRAPH_DIRECTED) || !is_simple) { return 10; } if (igraph_degree(&g, &vec, igraph_vss_all(), IGRAPH_OUT, IGRAPH_LOOPS)) { return 11; } igraph_vector_int_print(&vec); igraph_destroy(&g); /* checking the fast heuristic method, directed graphs */ igraph_degree_sequence_game(&g, &outdeg, &indeg, IGRAPH_DEGSEQ_FAST_HEUR_SIMPLE); if (!igraph_is_directed(&g) || igraph_vcount(&g) != 10) { return 12; } if (igraph_is_simple(&g, &is_simple, IGRAPH_DIRECTED) || !is_simple) { return 13; } if (igraph_degree(&g, &vec, igraph_vss_all(), IGRAPH_OUT, IGRAPH_LOOPS)) { return 14; } igraph_vector_int_print(&vec); if (igraph_degree(&g, &vec, igraph_vss_all(), IGRAPH_IN, IGRAPH_LOOPS)) { return 15; } igraph_vector_int_print(&vec); igraph_destroy(&g); igraph_vector_int_destroy(&vec); igraph_vector_int_destroy(&outdeg); igraph_vector_int_destroy(&indeg); return 0; }
igraph_error_t igraph_k_regular_game(igraph_t *graph, igraph_int_t no_of_nodes, igraph_int_t k, igraph_bool_t directed, igraph_bool_t multiple);
This game generates a directed or undirected random graph where the degrees of vertices are equal to a predefined constant k. For undirected graphs, at least one of k and the number of vertices must be even.
Currently, this game simply uses igraph_degree_sequence_game
with
the IGRAPH_DEGSEQ_CONFIGURATION
or the IGRAPH_DEGSEQ_FAST_SIMPLE
method and appropriately constructed degree sequences.
Thefore, it does not sample uniformly: while it can generate all k-regular
graphs with the given number of vertices, it does not generate each one with
the same probability.
Arguments:
|
Pointer to an uninitialized graph object. |
|
The number of nodes in the generated graph. |
|
The degree of each vertex in an undirected graph, or the out-degree and in-degree of each vertex in a directed graph. |
|
Whether the generated graph will be directed. |
|
Whether to allow multiple edges in the generated graph. |
Returns:
Error code:
|
Time complexity: O(|V|+|E|) if multiple
is true, otherwise not known.
igraph_error_t igraph_rewire(igraph_t *graph, igraph_int_t n, igraph_edge_type_sw_t allowed_edge_types);
This function generates a new graph based on the original one by randomly
"rewriting" edges while preserving the original graph's degree sequence.
The rewiring is done "in place", so no new graph will be allocated. If you
would like to keep the original graph intact, use igraph_copy()
beforehand. All graph attributes will be lost.
The rewiring is performed with degree-preserving edge switches:
Two arbitrary edges are picked uniformly at random, namely
(a, b)
and (c, d)
, then they are replaced
by (a, d)
and (b, c)
if this preserves the
constraints specified by mode
.
Arguments:
|
The graph object to be rewired. |
||||
|
Number of rewiring trials to perform. |
||||
|
The types of edges that rewiring may create in the graph.
See
Multigraphs are not yet supported. |
Returns:
Error code:
|
Time complexity: TODO.
igraph_error_t igraph_chung_lu_game(igraph_t *graph, const igraph_vector_t *out_weights, const igraph_vector_t *in_weights, igraph_bool_t loops, igraph_chung_lu_t variant);
This function is experimental and its signature is not considered final yet. We reserve the right to change the function signature without changing the major version of igraph. Use it at your own risk.
The Chung-Lu model is useful for generating random graphs with fixed expected degrees. This function implements both the original model of Chung and Lu, as well as some additional variants with useful properties.
In the original Chung-Lu model, each pair of vertices i
and j
is
connected with independent probability p_ij = w_i w_j / S
,
where w_i
is a weight associated with vertex i
and
S = sum_k w_k
is the sum of weights. In the directed variant,
vertices have both out-weights, w^out
, and in-weights,
w^in
, with equal sums,
S = sum_k w^out_k = sum_k w^in_k
.
The connection probability between i
and j
is
p_ij = w^out_i w^in_j / S
.
This model is commonly used to create random graphs with a fixed expected
degree sequence. The expected degree of vertex i
is approximately equal
to the weight w_i
. Specifically, if the graph is directed and self-loops
are allowed, then the expected out- and in-degrees are precisely
w^out
and w^in
. If self-loops are disallowed,
then the expected out- and in-degrees are w^out (S - w^in) / S
and w^in (S - w^out) / S
, respectively. If the graph is
undirected, then the expected degrees with and without self-loops are
w (S + w) / S
and w (S - w) / S
, respectively.
A limitation of the original Chung-Lu model is that when some of the
weights are large, the formula for p_ij
yields values larger than 1.
Chung and Lu's original paper excludes the use of such weights. When
p_ij > 1
, this function simply issues a warning and creates
a connection between i
and j
. However, in this case the expected degrees
will no longer relate to the weights in the manner stated above. Thus the
original Chung-Lu model cannot produce certain (large) expected degrees.
The overcome this limitation, this function implements additional variants of
the model, with modified expressions for the connection probability p_ij
between vertices i
and j
. Let q_ij = w_i w_j / S
, or
q_ij = w^out_i w^in_j / S
in the directed case. All model
variants become equivalent in the limit of sparse graphs where q_ij
approaches zero. In the original Chung-Lu model, selectable by setting
variant
to IGRAPH_CHUNG_LU_ORIGINAL
, p_ij = min(q_ij, 1)
.
The IGRAPH_CHUNG_LU_MAXENT
variant, sometiems referred to a the generalized
random graph, uses p_ij = q_ij / (1 + q_ij)
, and is equivalent
to a maximum entropy model (i.e. exponential random graph model) with
a constraint on expected degrees; see Park and Newman (2004), Section B,
setting exp(-Theta_ij) = w_i w_j / S
. This model is also
discussed by Britton, Deijfen and Martin-Löf (2006). By virtue of being
a degree-constrained maximum entropy model, it produces graphs with the
same degree sequence with the same probability.
A third variant can be requested with IGRAPH_CHUNG_LU_NR
, and uses
p_ij = 1 - exp(-q_ij)
. This is the underlying simple graph
of a multigraph model introduced by Norros and Reittu (2006).
For a discussion of these three model variants, see Section 16.4 of
Bollobás, Janson, Riordan (2007), as well as Van Der Hofstad (2013).
References:
Chung F and Lu L: Connected components in a random graph with given degree sequences. Annals of Combinatorics 6, 125-145 (2002). https://doi.org/10.1007/PL00012580
Miller JC and Hagberg A: Efficient Generation of Networks with Given Expected Degrees (2011). https://doi.org/10.1007/978-3-642-21286-4_10
Park J and Newman MEJ: Statistical mechanics of networks. Physical Review E 70, 066117 (2004). https://doi.org/10.1103/PhysRevE.70.066117
Britton T, Deijfen M, Martin-Löf A: Generating Simple Random Graphs with Prescribed Degree Distribution. J Stat Phys 124, 1377–1397 (2006). https://doi.org/10.1007/s10955-006-9168-x
Norros I and Reittu H: On a conditionally Poissonian graph process. Advances in Applied Probability 38, 59–75 (2006). https://doi.org/10.1239/aap/1143936140
Bollobás B, Janson S, Riordan O: The phase transition in inhomogeneous random graphs. Random Struct Algorithms 31, 3–122 (2007). https://doi.org/10.1002/rsa.20168
Van Der Hofstad R: Critical behavior in inhomogeneous random graphs. Random Struct Algorithms 42, 480–508 (2013). https://doi.org/10.1002/rsa.20450
Arguments:
|
Pointer to an uninitialized graph object. |
||||||
|
A vector of non-negative vertex weights (or out-weights). In sparse graphs these will be approximately equal to the expected (out-)degrees. |
||||||
|
A vector of non-negative in-weights, approximately equal
to the expected in-degrees in sparse graphs. May be set to |
||||||
|
Whether to allow the creation of self-loops. Since vertex pairs are connected independently, setting this to false is equivalent to simply discarding self-loops from an existing loopy Chung-Lu graph. |
||||||
|
The model variant to sample from, with different definitions
of the connection probability between vertices
|
Returns:
Error code. |
See also:
|
Time complexity: O(|E| + |V|), linear in the number of edges.
igraph_error_t igraph_static_fitness_game(igraph_t *graph, igraph_int_t no_of_edges, const igraph_vector_t *fitness_out, const igraph_vector_t *fitness_in, igraph_edge_type_sw_t allowed_edge_types);
This game generates a directed or undirected random graph where the
probability of an edge between vertices i
and j
depends on the fitness
scores of the two vertices involved. For undirected graphs, each vertex
has a single fitness score. For directed graphs, each vertex has an out-
and an in-fitness, and the probability of an edge from i
to j
depends on
the out-fitness of vertex i
and the in-fitness of vertex j
.
The generation process goes as follows. We start from N
disconnected nodes
(where N
is given by the length of the fitness vector). Then we randomly
select two vertices i
and j
, with probabilities proportional to their
fitnesses. (When the generated graph is directed, i
is selected according to
the out-fitnesses and j
is selected according to the in-fitnesses). If the
vertices are not connected yet (or if multiple edges are allowed), we
connect them; otherwise we select a new pair. This is repeated until the
desired number of links are created.
The expected degree (though not the actual degree) of each vertex will be
proportional to its fitness. This is exactly true when self-loops and multi-edges
are allowed, and approximately true otherwise. If you need to generate a graph
with an exact degree sequence, consider igraph_degree_sequence_game()
and
igraph_realize_degree_sequence()
instead.
To generate random undirected graphs with a given expected degree sequence, set
fitness_out
(and in the directed case fitness_out
) to the desired expected
degrees, and no_of_edges
to the corresponding edge count, i.e. half the sum of
expected degrees in the undirected case, and the sum of out- or in-degrees in the
directed case.
This model is similar to the better-known Chung-Lu model, implemented in igraph
as igraph_chung_lu_game()
, but with a sharply fixed edge count.
This model is commonly used to generate static scale-free networks. To
achieve this, you have to draw the fitness scores from the desired power-law
distribution. Alternatively, you may use igraph_static_power_law_game()
which generates the fitnesses for you with a given exponent.
Reference:
Goh K-I, Kahng B, Kim D: Universal behaviour of load distribution in scale-free networks. Phys Rev Lett 87(27):278701, 2001 https://doi.org/10.1103/PhysRevLett.87.278701.
Arguments:
|
Pointer to an uninitialized graph object. |
|
The number of edges in the generated graph. |
|
A numeric vector containing the fitness of each vertex. For directed graphs, this specifies the out-fitness of each vertex. |
|
If |
|
Controls whether multi-edges and self-loops
are allowed in the generated graph. See |
Returns:
Error code:
|
See also:
Time complexity: O(|V| + |E| log |E|).
igraph_error_t igraph_static_power_law_game(igraph_t *graph, igraph_int_t no_of_nodes, igraph_int_t no_of_edges, igraph_real_t exponent_out, igraph_real_t exponent_in, igraph_edge_type_sw_t allowed_edge_types, igraph_bool_t finite_size_correction);
This game generates a directed or undirected random graph where the degrees of vertices follow power-law distributions with prescribed exponents. For directed graphs, the exponents of the in- and out-degree distributions may be specified separately.
The game simply uses igraph_static_fitness_game()
with appropriately
constructed fitness vectors. In particular, the fitness of vertex i
is i^(-alpha)
, where alpha = 1/(gamma-1)
and gamma
is the exponent given in the arguments.
To remove correlations between in- and out-degrees in case of directed
graphs, the in-fitness vector will be shuffled after it has been set up
and before igraph_static_fitness_game()
is called.
Note that significant finite size effects may be observed for exponents
smaller than 3 in the original formulation of the game. This function
provides an argument that lets you remove the finite size effects by
assuming that the fitness of vertex i
is
(i+i0-1)^(-alpha)
,
where i0
is a constant chosen appropriately to ensure that the maximum
degree is less than the square root of the number of edges times the
average degree; see the paper of Chung and Lu, and Cho et al for more
details.
References:
Goh K-I, Kahng B, Kim D: Universal behaviour of load distribution in scale-free networks. Phys Rev Lett 87(27):278701, 2001. https://doi.org/10.1103/PhysRevLett.87.278701
Chung F and Lu L: Connected components in a random graph with given degree sequences. Annals of Combinatorics 6, 125-145, 2002. https://doi.org/10.1007/PL00012580
Cho YS, Kim JS, Park J, Kahng B, Kim D: Percolation transitions in scale-free networks under the Achlioptas process. Phys Rev Lett 103:135702, 2009. https://doi.org/10.1103/PhysRevLett.103.135702
Arguments:
|
Pointer to an uninitialized graph object. |
|
The number of nodes in the generated graph. |
|
The number of edges in the generated graph. |
|
The power law exponent of the degree distribution.
For directed graphs, this specifies the exponent of the
out-degree distribution. It must be greater than or
equal to 2. If you pass |
|
If negative, the generated graph will be undirected. If greater than or equal to 2, this argument specifies the exponent of the in-degree distribution. If non-negative but less than 2, an error will be generated. |
|
Controls whether multi-edges and self-loops
are allowed in the generated graph. See |
|
Whether to use the proposed finite size correction of Cho et al. |
Returns:
Error code:
|
Time complexity: O(|V| + |E| log |E|).
igraph_error_t igraph_watts_strogatz_game( igraph_t *graph, igraph_int_t dim, igraph_int_t size, igraph_int_t nei, igraph_real_t p, igraph_edge_type_sw_t allowed_edge_types);
This function generates networks with the small-world property
based on a variant of the Watts-Strogatz model. The network is obtained
by first creating a periodic undirected lattice, then rewiring both
endpoints of each edge with probability p
, while avoiding the
creation of multi-edges.
This process differs from the original model of Watts and Strogatz
(see reference) in that it rewires both endpoints of edges. Thus in
the limit of p=1
, we obtain a G(n,m) random graph with the
same number of vertices and edges as the original lattice. In comparison,
the original Watts-Strogatz model only rewires a single endpoint of each edge,
thus the network does not become fully random even for p=1
.
For appropriate choices of p
, both models exhibit the property of
simultaneously having short path lengths and high clustering.
Reference:
Duncan J Watts and Steven H Strogatz: Collective dynamics of “small world” networks, Nature 393, 440-442, 1998. https://doi.org/10.1038/30918
Arguments:
|
The graph to initialize. |
|
The dimension of the lattice. |
|
The size of the lattice along each dimension. |
|
The size of the neighborhood for each vertex. This is
the same as the |
|
The rewiring probability. A real number between zero and one (inclusive). |
|
Controls whether multi-edges and self-loops
are allowed in the generated graph. See |
Returns:
Error code. |
See also:
|
Time complexity: O(|V|*d^o+|E|), |V| and |E| are the number of
vertices and edges, d is the average degree, o is the nei
argument.
igraph_error_t igraph_rewire_edges(igraph_t *graph, igraph_real_t prob, igraph_edge_type_sw_t allowed_edge_types);
This function rewires the edges of a graph with a constant
probability. More precisely each end point of each edge is rewired
to a uniformly randomly chosen vertex with constant probability prob
.
Note that this function modifies the input graph
,
call igraph_copy()
if you want to keep it.
Arguments:
|
The input graph, this will be rewired, it can be directed or undirected. |
|
The rewiring probability a constant between zero and one (inclusive). |
|
Controls whether multi-edges and self-loops
are allowed in the new graph. See |
Returns:
Error code. |
See also:
|
Time complexity: O(|V|+|E|).
igraph_error_t igraph_rewire_directed_edges(igraph_t *graph, igraph_real_t prob, igraph_bool_t loops, igraph_neimode_t mode);
This function rewires either the start or end of directed edges in a graph with a constant probability. Correspondingly, either the in-degree sequence or the out-degree sequence of the graph will be preserved.
Note that this function modifies the input graph
,
call igraph_copy()
if you want to keep it.
This function can produce multiple edges between two vertices.
Arguments:
|
The input graph, this will be rewired, it can be
directed or undirected. If it is undirected or |
||||||
|
The rewiring probability, a constant between zero and one (inclusive). |
||||||
|
Boolean, whether loop edges are allowed in the new graph, or not. |
||||||
|
The endpoints of directed edges to rewire. It is ignored for undirected graphs. Possible values:
|
Returns:
Error code. |
See also:
Time complexity: O(|E|).
igraph_grg_game
— Generates a geometric random graph.igraph_dot_product_game
— Generates a random dot product graph.igraph_simple_interconnected_islands_game
— Generates a random graph made of several interconnected islands, each island being a random graph.igraph_tree_game
— Generates a random tree with the given number of nodes.
igraph_error_t igraph_grg_game(igraph_t *graph, igraph_int_t nodes, igraph_real_t radius, igraph_bool_t torus, igraph_vector_t *x, igraph_vector_t *y);
A geometric random graph is created by dropping points (i.e. vertices)
randomly on the unit square and then connecting all those pairs
which are strictly less than radius
apart in Euclidean distance.
Original code contributed by Keith Briggs, thanks Keith.
Arguments:
|
Pointer to an uninitialized graph object. |
|
The number of vertices in the graph. |
|
The radius within which the vertices will be connected. |
|
Boolean constant. If true, periodic boundary conditions will be used, i.e. the vertices are assumed to be on a torus instead of a square. |
|
An initialized vector or |
|
An initialized vector or |
Returns:
Error code. |
Time complexity: TODO, less than O(|V|^2+|E|).
Example 12.6. File examples/simple/igraph_grg_game.c
#include <igraph.h> #include <math.h> int main(void) { igraph_t graph; igraph_vector_t x, y; igraph_vector_t weights; igraph_eit_t eit; igraph_real_t avg_dist; /* Initialize the library. */ igraph_setup(); /* Set random seed for reproducible results */ igraph_rng_seed(igraph_rng_default(), 42); /* Create a random geometric graph and retrieve vertex coordinates */ igraph_vector_init(&x, 0); igraph_vector_init(&y, 0); igraph_grg_game(&graph, 200, 0.1, /* torus */ false, &x, &y); /* Compute edge weights as geometric distance */ igraph_vector_init(&weights, igraph_ecount(&graph)); igraph_eit_create(&graph, igraph_ess_all(IGRAPH_EDGEORDER_ID), &eit); for (; ! IGRAPH_EIT_END(eit); IGRAPH_EIT_NEXT(eit)) { igraph_int_t e = IGRAPH_EIT_GET(eit); igraph_int_t u = IGRAPH_FROM(&graph, e); igraph_int_t v = IGRAPH_TO(&graph, e); VECTOR(weights)[e] = hypot(VECTOR(x)[u] - VECTOR(x)[v], VECTOR(y)[u] - VECTOR(y)[v]); } igraph_eit_destroy(&eit); /* Compute average path length */ igraph_average_path_length(&graph, &weights, &avg_dist, NULL, IGRAPH_UNDIRECTED, /* unconn */ true); printf("Average distance in the geometric graph: %g.\n", avg_dist); /* Destroy data structures when no longer needed */ igraph_vector_destroy(&weights); igraph_destroy(&graph); igraph_vector_destroy(&x); igraph_vector_destroy(&y); return 0; }
igraph_error_t igraph_dot_product_game(igraph_t *graph, const igraph_matrix_t *vecs, igraph_bool_t directed);
In this model, each vertex is represented by a latent position vector. Probability of an edge between two vertices are given by the dot product of their latent position vectors.
See also Christine Leigh Myers Nickel: Random dot product graphs, a model for social networks. Dissertation, Johns Hopkins University, Maryland, USA, 2006.
Arguments:
|
The output graph is stored here. |
|
A matrix in which each latent position vector is a column. The dot product of the latent position vectors should be in the [0,1] interval, otherwise a warning is given. For negative dot products, no edges are added; dot products that are larger than one always add an edge. |
|
Should the generated graph be directed? |
Returns:
Error code. |
Time complexity: O(n*n*m), where n is the number of vertices, and m is the length of the latent vectors.
See also:
|
igraph_error_t igraph_simple_interconnected_islands_game( igraph_t *graph, igraph_int_t islands_n, igraph_int_t islands_size, igraph_real_t islands_pin, igraph_int_t n_inter);
All islands are of the same size. Within an island, each edge is generated with the same probability. A fixed number of additional edges are then generated for each unordered pair of islands to connect them. The generated graph is guaranteed to be simple.
Arguments:
|
Pointer to an uninitialized graph object. |
|
The number of islands in the graph. |
|
The size of islands in the graph. |
|
The probability to create each possible edge within islands. |
|
The number of edges to create between two islands. It may be
larger than |
Returns:
Error code:
|
Time complexity: O(|V|+|E|), the number of vertices plus the number of edges in the graph.
igraph_error_t igraph_tree_game(igraph_t *graph, igraph_int_t n, igraph_bool_t directed, igraph_random_tree_t method);
This function samples uniformly from the set of labelled trees, i.e. it generates each labelled tree with the same probability.
Note that for n=0
, the null graph is returned,
which is not considered to be a tree by igraph_is_tree()
.
Arguments:
|
Pointer to an uninitialized graph object. |
||||
|
The number of nodes in the tree. |
||||
|
Whether to create a directed tree. The edges are oriented away from the root. |
||||
|
The algorithm to use to generate the tree. Possible values:
|
Returns:
Error code:
|
See also:
typedef unsigned int igraph_edge_type_sw_t;
This type is used with multiple functions to specify what types of non-simple
edges to allow, create or consider a graph. The constants below are treated
as "switches" that can be turned on individually and combined using the
bitwise-or operator. For example,
IGRAPH_LOOPS_SW
allows only self-loops but not multi-edges, while
IGRAPH_LOOPS_SW | IGRAPH_MULTI_SW
allows both.
Values:
|
A shorthand for simple graphs only, which is the default assumption. |
|
Allow or consider self-loops. |
|
Allow or consider multi-edges. |
← Chapter 11. Deterministic graph generators | Chapter 13. Bipartite, i.e. two-mode graphs → |