Movatterモバイル変換

Title:	Network Analysis and Visualization
Version:	2.2.1
Description:	Routines for simple graphs and network analysis. It can handle large graphs very well and provides functions for generating random and regular graphs, graph visualization, centrality methods and much more.
License:	GPL-2 |GPL-3 [expanded from: GPL (≥ 2)]
URL:	https://r.igraph.org/,https://igraph.org/,https://igraph.discourse.group/
BugReports:	https://github.com/igraph/rigraph/issues
Depends:	methods, R (≥ 3.5.0)
Imports:	cli, graphics, grDevices, lifecycle, magrittr, Matrix,pkgconfig (≥ 2.0.0), rlang (≥ 1.1.0), stats, utils, vctrs
Suggests:	ape (≥ 5.7-0.1), callr, decor, digest, igraphdata, knitr,rgl (≥ 1.3.14), rmarkdown, scales, stats4, tcltk, testthat,vdiffr, withr
Enhances:	graph
LinkingTo:	cpp11 (≥ 0.5.0)
VignetteBuilder:	knitr
Config/build/compilation-database:	false
Config/build/never-clean:	true
Config/comment/compilation-database:	Generate manually withpkgload:::generate_db() for faster pkgload::load_all()
Config/Needs/build:	r-lib/roxygen2, devtools, irlba, pkgconfig,igraph/igraph.r2cdocs, moodymudskipper/devtag
Config/Needs/coverage:	covr
Config/Needs/website:	here, readr, tibble, xmlparsedata, xml2
Config/testthat/edition:	3
Config/testthat/parallel:	true
Config/testthat/start-first:	aaa-auto, vs-es, scan, vs-operators,weakref, watts.strogatz.game
Encoding:	UTF-8
RoxygenNote:	7.3.3.9000
SystemRequirements:	libxml2 (optional), glpk (>= 4.57, optional)
NeedsCompilation:	yes
Packaged:	2025-10-27 06:14:50 UTC; kirill
Author:	Gábor Csárdi [aut], Tamás Nepusz [aut], Vincent Traag [aut], Szabolcs Horvát [aut], Fabio Zanini [aut], Daniel Noom [aut], Kirill Müller [aut, cre], Michael Antonov [ctb], Chan Zuckerberg Initiative [fnd], David Schoch [aut], Maëlle Salmon [aut]
Maintainer:	Kirill Müller <kirill@cynkra.com>
Repository:	CRAN
Date/Publication:	2025-10-27 09:50:02 UTC

The igraph package

Description

igraph is a library and R package for network analysis.

Introduction

The main goals of the igraph library is to provide a set of data typesand functions for 1) pain-free implementation of graph algorithms, 2)fast handling of large graphs, with millions of vertices and edges, 3)allowing rapid prototyping via high level languages like R.

igraph graphs

igraph graphs have a class ‘igraph’. They are printed tothe screen in a special format, here is an example, a ring graphcreated usingmake_ring():

    IGRAPH U--- 10 10 -- Ring graph    + attr: name (g/c), mutual (g/x), circular (g/x)

‘IGRAPH’ denotes that this is an igraph graph. Thencome four bits that denote the kind of the graph: the first is‘U’ for undirected and ‘D’ for directedgraphs. The second is ‘N’ for named graph (i.e. if thegraph has the ‘name’ vertex attribute set). The third is‘W’ for weighted graphs (i.e. if the‘weight’ edge attribute is set). The fourth is‘B’ for bipartite graphs (i.e. if the‘type’ vertex attribute is set).

Then come two numbers, the number of vertices and the number of edgesin the graph, and after a double dash, the name of the graph (the‘name’ graph attribute) is printed if present. Thesecond line is optional and it contains all the attributes of thegraph. This graph has a ‘name’ graph attribute, of typecharacter, and two other graph attributes called‘mutual’ and ‘circular’, of a complextype. A complex type is simply anything that is not numeric orcharacter. See the documentation ofprint.igraph() fordetails.

If you want to see the edges of the graph as well, then use theprint_all() function:

    > print_all(g)    IGRAPH badcafe U--- 10 10 -- Ring graph    + attr: name (g/c), mutual (g/x), circular (g/x)    + edges:     [1] 1-- 2 2-- 3 3-- 4 4-- 5 5-- 6 6-- 7 7-- 8 8-- 9 9--10 1--10

Creating graphs

There are many functions in igraph for creating graphs, bothdeterministic and stochastic; stochastic graph constructors are called‘games’.

To create small graphs with a given structure probably thegraph_from_literal() function is easiest. It uses R's formulainterface, its manual page contains many examples. Another option ismake_graph(), which takes numeric vertex ids directly.graph_from_atlas() creates graph from the Graph Atlas,make_graph() can create some special graphs.

To create graphs from field data,graph_from_edgelist(),graph_from_data_frame() andgraph_from_adjacency_matrix() areprobably the best choices.

The igraph package includes some classic random graphs like theErdős-Rényi GNP and GNM graphs (sample_gnp(),sample_gnm()) andsome recent popular models, like preferential attachment(sample_pa()) and the small-world model(sample_smallworld()).

Vertex and edge IDs

Vertices and edges have numerical vertex ids in igraph. Vertex ids arealways consecutive and they start with one. I.e. for a graph withn vertices the vertex ids are between1 andn. If some operation changes the number of vertices in thegraphs, e.g. a subgraph is created viainduced_subgraph(), thenthe vertices are renumbered to satisfy this criteria.

The same is true for the edges as well, edge ids are always betweenone andm, the total number of edges in the graph.

It is often desirable to follow vertices along a number of graphoperations, and vertex ids don't allow this because of therenumbering. The solution is to assign attributes to thevertices. These are kept by all operations, if possible. See moreabout attributes in the next section.

Attributes

In igraph it is possible to assign attributes to the vertices or edgesof a graph, or to the graph itself. igraph provides flexibleconstructs for selecting a set of vertices or edges based on theirattribute values, seevertex_attr(),V() andE() for details.

Some vertex/edge/graph attributes are treated specially. One of themis the ‘name’ attribute. This is used for printing the graphinstead of the numerical ids, if it exists. Vertex names can also beused to specify a vector or set of vertices, in all igraphfunctions. E.g.degree() has av argumentthat gives the vertices for which the degree is calculated. Thisargument can be given as a character vector of vertex names.

Edges can also have a ‘name’ attribute, and this is treatedspecially as well. Just like for vertices, edges can also be selectedbased on their names, e.g. in thedelete_edges() andother functions.

We note here, that vertex names can also be used to select edges.The form ‘from|to’, where ‘from’ and‘to’ are vertex names, select a single, possiblydirected, edge going from ‘from’ to‘to’. The two forms can also be mixed in the same edgeselector.

Other attributes define visualization parameters, seeigraph.plotting for details.

Attribute values can be set to any R object, but note that storing thegraph in some file formats might result the loss of complex attributevalues. All attribute values are preserved if you usebase::save() andbase::load() to store/retrieve yourgraphs.

Visualization

igraph provides three different ways for visualization. The first istheplot.igraph() function. (Actually you don't need towriteplot.igraph(),plot() is enough. This function usesregular R graphics and can be used with any R device.

The second function istkplot(), which uses a Tk GUI forbasic interactive graph manipulation. (Tk is quite resource hungry, sodon't try this for very large graphs.)

The third way requires thergl package and uses OpenGL. See therglplot() function for the details.

Make sure you readigraph.plotting before you startplotting your graphs.

File formats

igraph can handle various graph file formats, usually both for readingand writing. We suggest that you use the GraphML file format for yourgraphs, except if the graphs are too big. For big graphs a simplerformat is recommended. Seeread_graph() andwrite_graph() for details.

Further information

The igraph homepage is athttps://igraph.org.See especially the documentation section. Join the discussion forum athttps://igraph.discourse.group if you have questions or comments.

Author(s)

Maintainer: Kirill Müllerkirill@cynkra.com (ORCID)

Authors:

• Gábor Csárdicsardi.gabor@gmail.com (ORCID)

• Tamás Nepuszntamas@gmail.com (ORCID)

• Vincent Traag (ORCID)

• Szabolcs Horvátszhorvat@gmail.com (ORCID)

• Fabio Zaninifabio.zanini@unsw.edu.au (ORCID)

• Daniel Noom

• David Schochdavid.schoch@cynkra.com (ORCID)

• Maëlle Salmonmaelle@cynkra.com (ORCID)

Other contributors:

• Michael Antonov [contributor]

• Chan Zuckerberg Initiative (ROR) [funder]

See Also

Useful links:

• https://r.igraph.org/

• https://igraph.org/

• https://igraph.discourse.group/

• Report bugs athttps://github.com/igraph/rigraph/issues

Magrittr's pipes

Description

igraph re-exports the⁠%>%⁠ operator of magrittr, becausewe find it very useful. Please see the documentation in themagrittr package.

Arguments

Value

Result of applying the right hand side to theresult of the left hand side.

Examples

make_ring(10) %>%  add_edges(c(1, 6)) %>%  plot()

Add vertices, edges or another graph to a graph

Description

Add vertices, edges or another graph to a graph

Usage

## S3 method for class 'igraph'e1 + e2

Arguments

Details

The plus operator can be used to add vertices or edges to graph.The actual operation that is performed depends on the type of theright hand side argument.

• If is is another igraph graph object and they are bothnamed graphs, then the union of the two graphs are calculated,seeunion().

• If it is another igraph graph object, but either of the twoare not named, then the disjoint union ofthe two graphs is calculated, seedisjoint_union().

• If it is a numeric scalar, then the specified number of verticesare added to the graph.

• If it is a character scalar or vector, then it is interpreted asthe names of the vertices to add to the graph.

• If it is an object created with thevertex() orvertices() function, then new vertices are added to thegraph. This form is appropriate when one wants to add some vertexattributes as well. The operands of thevertices() functionspecifies the number of vertices to add and their attributes aswell.

  The unnamed arguments ofvertices() are concatenated andused as the ‘name’ vertex attribute (i.e. vertexnames), the named arguments will be added as additional vertexattributes. Examples:

    g <- g +        vertex(shape="circle", color= "red")  g <- g + vertex("foo", color="blue")  g <- g + vertex("bar", "foobar")  g <- g + vertices("bar2", "foobar2", color=1:2, shape="rectangle")

  vertex() is just an alias tovertices(), and it isprovided for readability. The user should use it if a single vertexis added to the graph.

• If it is an object created with theedge() oredges() function, then new edges will be added to thegraph. The new edges and possibly their attributes can be specified asthe arguments of theedges() function.

  The unnamed arguments ofedges() are concatenated and usedas vertex ids of the end points of the new edges. The namedarguments will be added as edge attributes.

  Examples:

    g <- make_empty_graph() +         vertices(letters[1:10]) +         vertices("foo", "bar", "bar2", "foobar2")  g <- g + edge("a", "b")  g <- g + edges("foo", "bar", "bar2", "foobar2")  g <- g + edges(c("bar", "foo", "foobar2", "bar2"), color="red", weight=1:2)

  See more examples below.

  edge() is just an alias toedges() and it is providedfor readability. The user should use it if a single edge is added tothe graph.

• If it is an object created with thepath() function, thennew edges that form a path are added. The edges and possibly theirattributes are specified as the arguments to thepath()function. The non-named arguments are concatenated and interpretedas the vertex ids along the path. The remaining arguments are addedas edge attributes.

  Examples:

    g <- make_empty_graph() + vertices(letters[1:10])  g <- g + path("a", "b", "c", "d")  g <- g + path("e", "f", "g", weight=1:2, color="red")  g <- g + path(c("f", "c", "j", "d"), width=1:3, color="green")

It is important to note that, although the plus operator iscommutative, i.e. is possible to write

  graph <- "foo" + make_empty_graph()

it is not associative, e.g.

  graph <- "foo" + "bar" + make_empty_graph()

results a syntax error, unless parentheses are used:

  graph <- "foo" + ( "bar" + make_empty_graph() )

For clarity, we suggest to always put the graph object on the lefthand side of the operator:

  graph <- make_empty_graph() + "foo" + "bar"

See Also

Other functions for manipulating graph structure:add_edges(),add_vertices(),complementer(),compose(),connect(),contract(),delete_edges(),delete_vertices(),difference(),difference.igraph(),disjoint_union(),edge(),igraph-minus,intersection(),intersection.igraph(),path(),permute(),rep.igraph(),reverse_edges(),simplify(),union(),union.igraph(),vertex()

Examples

# 10 vertices named a,b,c,... and no edgesg <- make_empty_graph() + vertices(letters[1:10])# Add edges to make it a ringg <- g + path(letters[1:10], letters[1], color = "grey")# Add some extra random edgesg <- g + edges(sample(V(g), 10, replace = TRUE), color = "red")g$layout <- layout_in_circleplot(g)

Helpers within vertex/index sequences

Description

Functions to be used only with⁠[.igraph.es⁠ and⁠[.igraph.vs⁠

Usage

.nei(...).innei(...).outnei(...).inc(...).from(...).to(...)

Arguments

Details

See[.igraph.vs and[.igraph.es.

Value

An error

Edges of a graph

Description

An edge sequence is a vector containing numeric edge ids, with a specialclass attribute that allows custom operations: selecting subsets ofedges based on attributes, or graph structure, creating theintersection, union of edges, etc.

Usage

E(graph, P = NULL, path = NULL, directed = TRUE)

Arguments

Details

Edge sequences are usually used as igraph function arguments thatrefer to edges of a graph.

An edge sequence is tied to the graph it refers to: it really denotedthe specific edges of that graph, and cannot be used together withanother graph.

An edge sequence is most often created by theE() function. Theresult includes edges in increasing edge id order by default (if. noneof theP andpath arguments are used). An edgesequence can be indexed by a numeric vector, just like a regular Rvector. See links to other edge sequence operations below.

Value

An edge sequence of the graph.

Indexing edge sequences

Edge sequences mostly behave like regular vectors, but there are someadditional indexing operations that are specific for them;e.g. selecting edges based on graph structure, or based on edgeattributes. See[.igraph.es for details.

Querying or setting attributes

Edge sequences can be used to query or set attributes for theedges in the sequence. See$.igraph.es() for details.

See Also

Other vertex and edge sequences:V(),as_ids(),igraph-es-attributes,igraph-es-indexing,igraph-es-indexing2,igraph-vs-attributes,igraph-vs-indexing,igraph-vs-indexing2,print.igraph.es(),print.igraph.vs()

Examples

# Edges of an unnamed graphg <- make_ring(10)E(g)# Edges of a named graphg2 <- make_ring(10) %>%  set_vertex_attr("name", value = letters[1:10])E(g2)

Vertices of a graph

Description

Create a vertex sequence (vs) containing all vertices of a graph.

Usage

V(graph)

Arguments

Details

A vertex sequence is just what the name says it is: a sequence ofvertices. Vertex sequences are usually used as igraph function argumentsthat refer to vertices of a graph.

A vertex sequence is tied to the graph it refers to: it really denotedthe specific vertices of that graph, and cannot be used together withanother graph.

At the implementation level, a vertex sequence is simply a vectorcontaining numeric vertex ids, but it has a special class attributewhich makes it possible to perform graph specific operations on it, likeselecting a subset of the vertices based on graph structure, or vertexattributes.

A vertex sequence is most often created by theV() function. Theresult of this includes all vertices in increasing vertex id order. Avertex sequence can be indexed by a numeric vector, just like a regularR vector. See[.igraph.vs and additional links to othervertex sequence operations below.

Value

A vertex sequence containing all vertices, in the orderof their numeric vertex ids.

Indexing vertex sequences

Vertex sequences mostly behave like regular vectors, but there are someadditional indexing operations that are specific for them;e.g. selecting vertices based on graph structure, or based on vertexattributes. See[.igraph.vs for details.

Querying or setting attributes

Vertex sequences can be used to query or set attributes for thevertices in the sequence. See$.igraph.vs() for details.

See Also

Other vertex and edge sequences:E(),as_ids(),igraph-es-attributes,igraph-es-indexing,igraph-es-indexing2,igraph-vs-attributes,igraph-vs-indexing,igraph-vs-indexing2,print.igraph.es(),print.igraph.vs()

Examples

# Vertex ids of an unnamed graphg <- make_ring(10)V(g)# Vertex ids of a named graphg2 <- make_ring(10) %>%  set_vertex_attr("name", value = letters[1:10])V(g2)

Query and manipulate a graph as it were an adjacency matrix

Description

Query and manipulate a graph as it were an adjacency matrix

Usage

## S3 method for class 'igraph'  x[  i,  j,  ...,  from,  to,  sparse = igraph_opt("sparsematrices"),  edges = FALSE,  drop = TRUE,  attr = if (is_weighted(x)) "weight" else NULL]

Arguments

Details

The single bracket indexes the (possibly weighted) adjacency matrix ofthe graph. Here is what you can do with it:

1. Check whether there is an edge between two vertices (vandw) in the graph:

     graph[v, w]

   A numeric scalar is returned, one if the edge exists, zerootherwise.

2. Extract the (sparse) adjacency matrix of the graph, or part ofit:

     graph[]graph[1:3,5:6]graph[c(1,3,5),]

   The first variants returns the full adjacency matrix, the othertwo return part of it.

3. Thefrom andto arguments can be used to checkthe existence of many edges. In this case, bothfrom andto must be present and they must have the same length. Theymust contain vertex ids or names. A numeric vector is returned, ofthe same length asfrom andto, it contains onesfor existing edges edges and zeros for non-existing ones.Example:

     graph[from=1:3, to=c(2,3,5)]

   .

4. For weighted graphs, the[ operator returns the edgeweights. For non-esistent edges zero weights are returned. Otheredge attributes can be queried as well, by giving theattrargument.

5. Querying edge ids instead of the existance of edges or edgeattributes. E.g.

     graph[1, 2, edges=TRUE]

   returns the id of the edge between vertices 1 and 2, or zero ifthere is no such edge.

6. Adding one or more edges to a graph. For this the element(s) ofthe imaginary adjacency matrix must be set to a non-zero numericvalue (orTRUE):

     graph[1, 2] <- 1graph[1:3,1] <- 1graph[from=1:3, to=c(2,3,5)] <- TRUE

   This does not affect edges that are already present in the graph,i.e. no multiple edges are created.

7. Adding weighted edges to a graph. Theattr argumentcontains the name of the edge attribute to set, so it does nothave to be ‘weight’:

     graph[1, 2, attr="weight"]<- 5graph[from=1:3, to=c(2,3,5)] <- c(1,-1,4)

   If an edge is already present in the network, then only itsweights or other attribute are updated. If the graph is alreadyweighted, then theattr="weight" setting is implicit, andone does not need to give it explicitly.

8. Deleting edges. The replacement syntax allow the deletion ofedges, by specifyingFALSE orNULL as thereplacement value:

     graph[v, w] <- FALSE

   removes the edge from vertexv to vertexw.As this can be used to delete edges between two sets of vertices,either pairwise:

     graph[from=v, to=w] <- FALSE

   or not:

     graph[v, w] <- FALSE

   ifv andw are vectors of edge ids or names.

‘[’ allows logical indices and negative indices as well,with the usual R semantics. E.g.

  graph[degree(graph)==0, 1] <- 1

adds an edge from every isolate vertex to vertex one,and

  G <- make_empty_graph(10)G[-1,1] <- TRUE

creates a star graph.

Of course, the indexing operators support vertex names,so instead of a numeric vertex id a vertex can also be given to‘[’ and ‘[[’.

Value

A scalar or matrix. See details below.

See Also

Other structural queries:[[.igraph(),adjacent_vertices(),are_adjacent(),ends(),get_edge_ids(),gorder(),gsize(),head_of(),incident(),incident_edges(),is_directed(),neighbors(),tail_of()

Query and manipulate a graph as it were an adjacency list

Description

Query and manipulate a graph as it were an adjacency list

Usage

## S3 method for class 'igraph'x[[i, j, from, to, ..., directed = TRUE, edges = FALSE, exact = TRUE]]

Arguments

Details

The double bracket operator indexes the (imaginary) adjacency listof the graph. This can used for the following operations:

1. Querying the adjacent vertices for one or morevertices:

     graph[[1:3,]]graph[[,1:3]]

   The first form gives the successors, the second the predecessorsor the 1:3 vertices. (For undirected graphs they are equivalent.)

2. Querying the incident edges for one or more vertices,if theedges argument is set toTRUE:

     graph[[1:3, , edges=TRUE]]graph[[, 1:3, edges=TRUE]]

3. Querying the edge ids between two sets or vertices,if both indices are used. E.g.

     graph[[v, w, edges=TRUE]]

   gives the edge ids of all the edges that exist from verticesv to verticesw.

The alternative argument namesfrom andto can be usedinstead of the usuali andj, to make the code morereadable:

 graph[[from = 1:3]]graph[[from = v, to = w, edges = TRUE]]

‘[[’ operators allows logical indices and negative indicesas well, with the usual R semantics.

Vertex names are also supported, so instead of a numeric vertex id avertex can also be given to ‘[’ and ‘[[’.

See Also

Other structural queries:[.igraph(),adjacent_vertices(),are_adjacent(),ends(),get_edge_ids(),gorder(),gsize(),head_of(),incident(),incident_edges(),is_directed(),neighbors(),tail_of()

Add edges to a graph

Description

add.edges() was renamed toadd_edges() to create a moreconsistent API.

Usage

add.edges(graph, edges, ..., attr = list())

Arguments

Various vertex shapes when plotting igraph graphs

Description

add.vertex.shape() was renamed toadd_shape() to create a moreconsistent API.

Usage

add.vertex.shape(  shape,  clip = shape_noclip,  plot = shape_noplot,  parameters = list())

Arguments

Add vertices to a graph

Description

add.vertices() was renamed toadd_vertices() to create a moreconsistent API.

Usage

add.vertices(graph, nv, ..., attr = list())

Arguments

Add edges to a graph

Description

The new edges are given as a vertex sequence, e.g. internalnumeric vertex ids, or vertex names. The first edge points fromedges[1] toedges[2], the second fromedges[3]toedges[4], etc.

Usage

add_edges(graph, edges, ..., attr = list())

Arguments

Details

If attributes are supplied, and they are not present in the graph,their values for the original edges of the graph are set toNA.

Value

The graph, with the edges (and attributes) added.

See Also

Other functions for manipulating graph structure:+.igraph(),add_vertices(),complementer(),compose(),connect(),contract(),delete_edges(),delete_vertices(),difference(),difference.igraph(),disjoint_union(),edge(),igraph-minus,intersection(),intersection.igraph(),path(),permute(),rep.igraph(),reverse_edges(),simplify(),union(),union.igraph(),vertex()

Examples

g <- make_empty_graph(n = 5) %>%  add_edges(c(    1, 2,    2, 3,    3, 4,    4, 5  )) %>%  set_edge_attr("color", value = "red") %>%  add_edges(c(5, 1), color = "green")E(g)[[]]plot(g)

Add layout to graph

Description

Add layout to graph

Usage

add_layout_(graph, ..., overwrite = TRUE)

Arguments

Value

The input graph, with the layout added.

See Also

layout_() for a description of the layout API.

Other graph layouts:component_wise(),layout_(),layout_as_bipartite(),layout_as_star(),layout_as_tree(),layout_in_circle(),layout_nicely(),layout_on_grid(),layout_on_sphere(),layout_randomly(),layout_with_dh(),layout_with_fr(),layout_with_gem(),layout_with_graphopt(),layout_with_kk(),layout_with_lgl(),layout_with_mds(),layout_with_sugiyama(),merge_coords(),norm_coords(),normalize()

Examples

(make_star(11) + make_star(11)) %>%  add_layout_(as_star(), component_wise()) %>%  plot()

Add vertices to a graph

Description

If attributes are supplied, and they are not present in the graph,their values for the original vertices of the graph are set toNA.

Usage

add_vertices(graph, nv, ..., attr = list())

Arguments

Value

The graph, with the vertices (and attributes) added.

See Also

Other functions for manipulating graph structure:+.igraph(),add_edges(),complementer(),compose(),connect(),contract(),delete_edges(),delete_vertices(),difference(),difference.igraph(),disjoint_union(),edge(),igraph-minus,intersection(),intersection.igraph(),path(),permute(),rep.igraph(),reverse_edges(),simplify(),union(),union.igraph(),vertex()

Examples

g <- make_empty_graph() %>%  add_vertices(3, color = "red") %>%  add_vertices(2, color = "green") %>%  add_edges(c(    1, 2,    2, 3,    3, 4,    4, 5  ))gV(g)[[]]plot(g)

Find triangles in graphs

Description

adjacent.triangles() was renamed tocount_triangles() to create a moreconsistent API.

Usage

adjacent.triangles(graph, vids = V(graph))

Arguments

Adjacent vertices of multiple vertices in a graph

Description

This function is similar toneighbors(), but it queriesthe adjacent vertices for multiple vertices at once.

Usage

adjacent_vertices(graph, v, mode = c("out", "in", "all", "total"))

Arguments

Value

A list of vertex sequences.

See Also

Other structural queries:[.igraph(),[[.igraph(),are_adjacent(),ends(),get_edge_ids(),gorder(),gsize(),head_of(),incident(),incident_edges(),is_directed(),neighbors(),tail_of()

Examples

g <- make_graph("Zachary")adjacent_vertices(g, c(1, 34))

Generate an evolving random graph with preferential attachment and aging

Description

aging.ba.game() was renamed tosample_pa_age() to create a moreconsistent API.

Usage

aging.ba.game(  n,  pa.exp,  aging.exp,  m = NULL,  aging.bin = 300,  out.dist = NULL,  out.seq = NULL,  out.pref = FALSE,  directed = TRUE,  zero.deg.appeal = 1,  zero.age.appeal = 0,  deg.coef = 1,  age.coef = 1,  time.window = NULL)

Arguments

Generate an evolving random graph with preferential attachment and aging

Description

aging.barabasi.game() was renamed tosample_pa_age() to create a moreconsistent API.

Usage

aging.barabasi.game(  n,  pa.exp,  aging.exp,  m = NULL,  aging.bin = 300,  out.dist = NULL,  out.seq = NULL,  out.pref = FALSE,  directed = TRUE,  zero.deg.appeal = 1,  zero.age.appeal = 0,  deg.coef = 1,  age.coef = 1,  time.window = NULL)

Arguments

Generate an evolving random graph with preferential attachment and aging

Description

aging.prefatt.game() was renamed tosample_pa_age() to create a moreconsistent API.

Usage

aging.prefatt.game(  n,  pa.exp,  aging.exp,  m = NULL,  aging.bin = 300,  out.dist = NULL,  out.seq = NULL,  out.pref = FALSE,  directed = TRUE,  zero.deg.appeal = 1,  zero.age.appeal = 0,  deg.coef = 1,  age.coef = 1,  time.window = NULL)

Arguments

Align a vertex layoutThis function centers a vertex layout on the coordinate system origin androtates the layout to achieve a visually pleasing alignment with the coordinateaxes. Doing this is particularly useful with force-directed layouts such aslayout_with_fr().

Description

Align a vertex layoutThis function centers a vertex layout on the coordinate system origin androtates the layout to achieve a visually pleasing alignment with the coordinateaxes. Doing this is particularly useful with force-directed layouts such aslayout_with_fr().

Usage

align_layout(graph, layout)

Arguments

Value

modified layout matrix

Examples

g <- make_lattice(c(3, 3))l1 <- layout_with_fr(g)l2 <- align_layout(g,l1)plot(g, layout = l1)plot(g, layout = l2)

List all simple paths from one source

Description

This function lists all simple paths from one source vertex to anothervertex or vertices. A path is simple if contains no repeated vertices.

Usage

all_simple_paths(  graph,  from,  to = V(graph),  mode = c("out", "in", "all", "total"),  cutoff = -1)

Arguments

Details

Note that potentially there are exponentially many paths between twovertices of a graph, and you may run out of memory when using thisfunction, if your graph is lattice-like.

This function ignores multiple and loop edges.

Value

A list of integer vectors, each integer vector is a path fromthe source vertex to one of the target vertices. A path is given by itsvertex ids.

See Also

Other paths:diameter(),distance_table(),eccentricity(),graph_center(),radius()

Examples

g <- make_ring(10)all_simple_paths(g, 1, 5)all_simple_paths(g, 1, c(3, 5))

Find Bonacich alpha centrality scores of network positions

Description

alpha.centrality() was renamed toalpha_centrality() to create a moreconsistent API.

Usage

alpha.centrality(  graph,  nodes = V(graph),  alpha = 1,  loops = FALSE,  exo = 1,  weights = NULL,  tol = 1e-07,  sparse = TRUE)

Arguments

Find Bonacich alpha centrality scores of network positions

Description

alpha_centrality() calculates the alpha centrality of some (or all)vertices in a graph.

Usage

alpha_centrality(  graph,  nodes = V(graph),  alpha = 1,  loops = FALSE,  exo = 1,  weights = NULL,  tol = 1e-07,  sparse = TRUE)

Arguments

Details

The alpha centrality measure can be considered as a generalization ofeigenvector centrality to directed graphs. It was proposed by Bonacich in2001 (see reference below).

The alpha centrality of the vertices in a graph is defined as the solutionof the following matrix equation:

x=\alpha A^T x+e,

whereA is the (not necessarily symmetric) adjacency matrix of thegraph,e is the vector of exogenous sources of status of thevertices and\alpha is the relative importance of theendogenous versus exogenous factors.

Value

A numeric vector contaning the centrality scores for the selectedvertices.

Warning

Singular adjacency matrices cause problems for thisalgorithm, the routine may fail is certain cases.

Author(s)

Gabor Csardicsardi.gabor@gmail.com

References

Bonacich, P. and Lloyd, P. (2001). “Eigenvector-likemeasures of centrality for asymmetric relations”Social Networks,23, 191-201.

See Also

eigen_centrality() andpower_centrality()

Centrality measuresauthority_score(),betweenness(),closeness(),diversity(),eigen_centrality(),harmonic_centrality(),hits_scores(),page_rank(),power_centrality(),spectrum(),strength(),subgraph_centrality()

Examples

# The examples from Bonacich's paperg.1 <- make_graph(c(1, 3, 2, 3, 3, 4, 4, 5))g.2 <- make_graph(c(2, 1, 3, 1, 4, 1, 5, 1))g.3 <- make_graph(c(1, 2, 2, 3, 3, 4, 4, 1, 5, 1))alpha_centrality(g.1)alpha_centrality(g.2)alpha_centrality(g.3, alpha = 0.5)

Are two vertices adjacent?

Description

are.connected() was renamed toare_adjacent() to create a moreconsistent API.

Usage

are.connected(graph, v1, v2)

Arguments

Are two vertices adjacent?

Description

The order of the vertices only matters in directed graphs,where the existence of a directed⁠(v1, v2)⁠ edge is queried.

Usage

are_adjacent(graph, v1, v2)

Arguments

Value

A logical scalar,TRUE if edge⁠(v1, v2)⁠ exists in the graph.

Related documentation in the C library

are_adjacent().

See Also

Other structural queries:[.igraph(),[[.igraph(),adjacent_vertices(),ends(),get_edge_ids(),gorder(),gsize(),head_of(),incident(),incident_edges(),is_directed(),neighbors(),tail_of()

Examples

ug <- make_ring(10)ugare_adjacent(ug, 1, 2)are_adjacent(ug, 2, 1)dg <- make_ring(10, directed = TRUE)dgare_adjacent(ug, 1, 2)are_adjacent(ug, 2, 1)

ARPACK eigenvector calculation

Description

Interface to the ARPACK library for calculating eigenvectors of sparsematrices

Usage

arpack_defaults()arpack(  func,  extra = NULL,  sym = FALSE,  options = arpack_defaults(),  env = parent.frame(),  complex = !sym)

Arguments

Details

ARPACK is a library for solving large scale eigenvalue problems. Thepackage is designed to compute a few eigenvalues and correspondingeigenvectors of a generaln byn matrixA. It is mostappropriate for large sparse or structured matricesA where structuredmeans that a matrix-vector productw <- Av requires ordernrather than the usual ordern^2 floating point operations.

This function is an interface to ARPACK. igraph does not contain all ARPACKroutines, only the ones dealing with symmetric and non-symmetric eigenvalueproblems using double precision real numbers.

The eigenvalue calculation in ARPACK (in the simplest case) involves thecalculation of theAv product whereA is the matrix we work withandv is an arbitrary vector. The function supplied in thefunargument is expected to perform this product. If the product can be doneefficiently, e.g. if the matrix is sparse, thenarpack() is usuallyable to calculate the eigenvalues very quickly.

Theoptions argument specifies what kind of calculation to perform.It is a list with the following members, they correspond directly to ARPACKparameters. On input it has the following fields:

bmat

Character constant, possible values:‘I’, standard eigenvalue problem,Ax=\lambda x; and‘G’, generalized eigenvalue problem,Ax=\lambda B x.Currently only ‘I’ is supported.

n

Numeric scalar. The dimension of the eigenproblem.You only need to set this if you callarpack() directly.(I.e. not needed foreigen_centrality(),page_rank(), etc.)

which

Specify which eigenvalues/vectors to compute,character constant with exactly two characters.Possible values for symmetric input matrices:

"LA"

Computenev largest (algebraic) eigenvalues.

"SA"

Computenev smallest (algebraic) eigenvalues.

"LM"

Computenev largest (in magnitude) eigenvalues.

"SM"

Computenev smallest (in magnitude) eigenvalues.

"BE"

Computenev eigenvalues, half from each end of the spectrum.Whennev is odd, compute one more from the high end than from the low end.

Possible values for non-symmetric input matrices:

"LM"

Computenev eigenvalues of largest magnitude.

"SM"

Computenev eigenvalues of smallest magnitude.

"LR"

Computenev eigenvalues of largest real part.

"SR"

Computenev eigenvalues of smallest real part.

"LI"

Computenev eigenvalues of largest imaginary part.

"SI"

Computenev eigenvalues of smallest imaginary part.

This parameter is sometimes overwritten by the various functions,e.g.page_rank() always sets ‘LM’.

nev

Numeric scalar. The number of eigenvalues to be computed.

tol

Numeric scalar. Stopping criterion:the relative accuracy of the Ritz value is considered acceptableif its error is less thantol times its estimated value.If this is set to zero then machine precision is used.

ncv

Number of Lanczos vectors to be generated.

ldv

Numberic scalar. It should be set to zero in the current implementation.

ishift

Either zero or one.If zero then the shifts are provided by the user via reverse communication.If one then exact shifts with respect to the reduced tridiagonal matrixT.Please always set this to one.

maxiter

Maximum number of Arnoldi update iterations allowed.

nb

Blocksize to be used in the recurrence. Please always leave this on the default value, one.

mode

The type of the eigenproblem to be solved. Possible values if the input matrix is symmetric:

1

Ax=\lambda x,A is symmetric.

2

Ax=\lambda Mx,A is symmetric,M is symmetric positive definite.

3

Kx=\lambda Mx,K is symmetric,M is symmetric positive semi-definite.

4

Kx=\lambda KGx,K is symmetric positive semi-definite,KG is symmetric indefinite.

5

Ax=\lambda Mx,A is symmetric,M is symmetric positive semi-definite. (Cayley transformed mode.)

Please note that onlymode==1 was tested and other values might not work properly.Possible values if the input matrix is not symmetric:

1

Ax=\lambda x.

2

Ax=\lambda Mx,M is symmetric positive definite.

3

Ax=\lambda Mx,M is symmetric semi-definite.

4

Ax=\lambda Mx,M is symmetric semi-definite.

Please note that onlymode==1 was tested and other values might not work properly.

start

Not used currently. Later it be used to set a starting vector.

sigma

Not used currently.

sigmai

Not use currently.

:On output the following additional fields are added:

info

Error flag of ARPACK. Possible values:

0

Normal exit.

1

Maximum number of iterations taken.

3

No shifts could be applied during a cycleof the implicitly restarted Arnoldi iteration.One possibility is to increase the size ofncv relative tonev.

ARPACK can return more error conditions than these,but they are converted to regular igraph errors.

iter

Number of Arnoldi iterations taken.

nconv

Number of “converged” Ritz values.This represents the number of Ritz values that satisfy the convergence critetion.

numop

Total number of matrix-vector multiplications.

numopb

Not used currently.

numreo

Total number of steps of re-orthogonalization.

Please see the ARPACK documentation for additional details.

Value

A named list with the following members:

values

Numeric vector, the desired eigenvalues.

vectors

Numeric matrix, the desired eigenvectors as columns.Ifcomplex=TRUE (the default for non-symmetric problems), then the matrix is complex.

options

A named list with the suppliedoptionsand some information about the performed calculation,including an ARPACK exit code.See the details above.

Author(s)

Rich Lehoucq, Kristi Maschhoff, Danny Sorensen, Chao Yang forARPACK, Gabor Csardicsardi.gabor@gmail.com for the R interface.

References

D.C. Sorensen, Implicit Application of Polynomial Filters in ak-Step Arnoldi Method.SIAM J. Matr. Anal. Apps., 13 (1992), pp357-385.

R.B. Lehoucq, Analysis and Implementation of an Implicitly Restarted ArnoldiIteration.Rice University Technical Report TR95-13, Department ofComputational and Applied Mathematics.

B.N. Parlett & Y. Saad, Complex Shift and Invert Strategies for RealMatrices.Linear Algebra and its Applications, vol 88/89, pp 575-595,(1987).

See Also

eigen_centrality(),page_rank(),hub_score(),cluster_leading_eigen() are some of thefunctions in igraph that use ARPACK.

Examples

# Identity matrixf <- function(x, extra = NULL) xarpack(f, options = list(n = 10, nev = 2, ncv = 4), sym = TRUE)# Graph laplacian of a star graph (undirected), n>=2# Note that this is a linear operationf <- function(x, extra = NULL) {  y <- x  y[1] <- (length(x) - 1) * x[1] - sum(x[-1])  for (i in 2:length(x)) {    y[i] <- x[i] - x[1]  }  y}arpack(f, options = list(n = 10, nev = 1, ncv = 3), sym = TRUE)# double checkeigen(laplacian_matrix(make_star(10, mode = "undirected")))## First three eigenvalues of the adjacency matrix of a graph## We need the 'Matrix' package for thislibrary("Matrix")set.seed(42)g <- sample_gnp(1000, 5 / 1000)M <- as_adjacency_matrix(g, sparse = TRUE)f2 <- function(x, extra = NULL) {  cat(".")  as.vector(M %*% x)}baev <- arpack(  f2,  sym = TRUE,  options = list(    n = vcount(g),    nev = 3,    ncv = 8,    which = "LM",    maxiter = 2000  ))

Articulation points and bridges of a graph

Description

articulation.points() was renamed toarticulation_points() to create a moreconsistent API.

Usage

articulation.points(graph)

Arguments

Articulation points and bridges of a graph

Description

articulation_points() finds the articulation points (or cut vertices)

Usage

articulation_points(graph)bridges(graph)

Arguments

Details

Articulation points or cut vertices are vertices whose removal increases thenumber of connected components in a graph. Similarly, bridges or cut-edgesare edges whose removal increases the number of connected components in agraph. If the original graph was connected, then the removal of a singlearticulation point or a single bridge makes it disconnected. If a graphcontains no articulation points, then its vertex connectivity is at leasttwo.

Value

Forarticulation_points(), a numeric vector giving the vertexIDs of the articulation points of the input graph. Forbridges(), anumeric vector giving the edge IDs of the bridges of the input graph.

Related documentation in the C library

articulation_points(),bridges().

Author(s)

Gabor Csardicsardi.gabor@gmail.com

See Also

biconnected_components(),components(),is_connected(),vertex_connectivity(),edge_connectivity()

Connected componentsbiconnected_components(),component_distribution(),decompose(),is_biconnected()

Examples

g <- disjoint_union(make_full_graph(5), make_full_graph(5))clu <- components(g)$membershipg <- add_edges(g, c(match(1, clu), match(2, clu)))articulation_points(g)g <- make_graph("krackhardt_kite")bridges(g)

Convert between directed and undirected graphs

Description

as.directed() was renamed toas_directed() to create a moreconsistent API.

Usage

as.directed(graph, mode = c("mutual", "arbitrary", "random", "acyclic"))

Arguments

Conversion to igraph

Description

These functions convert various objects to igraph graphs.

Usage

as.igraph(x, ...)

Arguments

Details

You can useas.igraph() to convert various objects to igraph graphs.Right now the following objects are supported:

• codeigraphHRGThese objects are created by thefit_hrg() andconsensus_tree() functions.

Value

All these functions return an igraph graph.

Author(s)

Gabor Csardicsardi.gabor@gmail.com.

Examples

g <- make_full_graph(5) + make_full_graph(5)hrg <- fit_hrg(g)as.igraph(hrg)

Convert igraph objects to adjacency or edge list matrices

Description

Get adjacency or edgelist representation of the network stored as anigraph object.

Usage

## S3 method for class 'igraph'as.matrix(x, matrix.type = c("adjacency", "edgelist"), ...)

Arguments

Details

Ifmatrix.type is"edgelist", then a two-column numeric edge listmatrix is returned. The value ofattrname is ignored.

Ifmatrix.type is"adjacency", then a square adjacency matrix isreturned. For adjacency matrices, you can use theattr keyword argumentto use the values of an edge attribute in the matrix cells. See thedocumentation ofas_adjacency_matrix for more details.

Other arguments passed through... are passed to eitheras_adjacency_matrix() oras_edgelist()depending on the value ofmatrix.type.

Value

Depending on the value ofmatrix.type either a squareadjacency matrix or a two-column numeric matrix representing the edgelist.

Author(s)

Michal Bojanowski, originally from theintergraph package

See Also

Other conversion:as_adj_list(),as_adjacency_matrix(),as_biadjacency_matrix(),as_data_frame(),as_directed(),as_edgelist(),as_graphnel(),as_long_data_frame(),graph_from_adj_list(),graph_from_graphnel()

Examples

g <- make_graph("zachary")as.matrix(g, "adjacency")as.matrix(g, "edgelist")# use edge attribute "weight"E(g)$weight <- rep(1:10, length.out = ecount(g))as.matrix(g, "adjacency", sparse = FALSE, attr = "weight")

Convert between undirected and unundirected graphs

Description

as.undirected() was renamed toas_undirected() to create a moreconsistent API.

Usage

as.undirected(  graph,  mode = c("collapse", "each", "mutual"),  edge.attr.comb = igraph_opt("edge.attr.comb"))

Arguments

Convert a graph to an adjacency matrix

Description

We plan to removeas_adj() in favor of the more explicitly namedas_adjacency_matrix() so please useas_adjacency_matrix() instead.

Usage

as_adj(  graph,  type = c("both", "upper", "lower"),  attr = NULL,  edges = deprecated(),  names = TRUE,  sparse = igraph_opt("sparsematrices"))

Arguments

Adjacency lists

Description

Create adjacency lists from a graph, either for adjacent edges or forneighboring vertices

Usage

as_adj_list(  graph,  mode = c("all", "out", "in", "total"),  loops = c("twice", "once", "ignore"),  multiple = TRUE)as_adj_edge_list(  graph,  mode = c("all", "out", "in", "total"),  loops = c("twice", "once", "ignore"))

Arguments

Details

as_adj_list() returns a list of numeric vectors, which include the idsof neighbor vertices (according to themode argument) of allvertices.

as_adj_edge_list() returns a list of numeric vectors, which include theids of adjacent edges (according to themode argument) of allvertices.

Ifigraph_opt("return.vs.es") is true (default), the numericvectors of the adjacency lists are coerced toigraph.vs, this can bea very expensive operation on large graphs.

Value

A list ofigraph.vs or a list of numeric vectors depending onthe value ofigraph_opt("return.vs.es"), see details for performancecharacteristics.

Author(s)

Gabor Csardicsardi.gabor@gmail.com

See Also

as_edgelist(),as_adjacency_matrix()

Other conversion:as.matrix.igraph(),as_adjacency_matrix(),as_biadjacency_matrix(),as_data_frame(),as_directed(),as_edgelist(),as_graphnel(),as_long_data_frame(),graph_from_adj_list(),graph_from_graphnel()

Examples

g <- make_ring(10)as_adj_list(g)as_adj_edge_list(g)

Convert a graph to an adjacency matrix

Description

Sometimes it is useful to work with a standard representation of agraph, like an adjacency matrix.

Usage

as_adjacency_matrix(  graph,  type = c("both", "upper", "lower"),  attr = NULL,  edges = deprecated(),  names = TRUE,  sparse = igraph_opt("sparsematrices"))

Arguments

Details

as_adjacency_matrix() returns the adjacency matrix of a graph, aregular matrix ifsparse isFALSE, or a sparse matrix, asdefined in the ‘Matrix’ package, ifsparse ifTRUE.

Value

Avcount(graph) byvcount(graph) (usually) numericmatrix.

See Also

graph_from_adjacency_matrix(),read_graph()

Other conversion:as.matrix.igraph(),as_adj_list(),as_biadjacency_matrix(),as_data_frame(),as_directed(),as_edgelist(),as_graphnel(),as_long_data_frame(),graph_from_adj_list(),graph_from_graphnel()

Examples

g <- sample_gnp(10, 2 / 10)as_adjacency_matrix(g)V(g)$name <- letters[1:vcount(g)]as_adjacency_matrix(g)E(g)$weight <- runif(ecount(g))as_adjacency_matrix(g, attr = "weight")

Bipartite adjacency matrix of a bipartite graph

Description

This function can return a sparse or dense bipartite adjacency matrix of a bipartitenetwork. The bipartite adjacency matrix is ann timesm matrix,nandm are the number of vertices of the two kinds.

Usage

as_biadjacency_matrix(  graph,  types = NULL,  attr = NULL,  names = TRUE,  sparse = FALSE)

Arguments

Details

Bipartite graphs have atype vertex attribute in igraph, this isboolean andFALSE for the vertices of the first kind andTRUEfor vertices of the second kind.

Some authors refer to the bipartite adjacency matrix as the"bipartite incidence matrix". igraph 1.6.0 and later does not usethis naming to avoid confusion with the edge-vertex incidence matrix.

Value

A sparse or dense matrix.

Author(s)

Gabor Csardicsardi.gabor@gmail.com

See Also

graph_from_biadjacency_matrix() for the opposite operation.

Other conversion:as.matrix.igraph(),as_adj_list(),as_adjacency_matrix(),as_data_frame(),as_directed(),as_edgelist(),as_graphnel(),as_long_data_frame(),graph_from_adj_list(),graph_from_graphnel()

Examples

g <- make_bipartite_graph(c(0, 1, 0, 1, 0, 0), c(1, 2, 2, 3, 3, 4))as_biadjacency_matrix(g)

Creating igraph graphs from data frames or vice-versa

Description

This function creates an igraph graph from one or two data frames containingthe (symbolic) edge list and edge/vertex attributes.

Usage

as_data_frame(x, what = c("edges", "vertices", "both"))graph_from_data_frame(d, directed = TRUE, vertices = NULL)from_data_frame(...)

Arguments

Details

graph_from_data_frame() creates igraph graphs from one or two data frames.It has two modes of operation, depending whether theverticesargument isNULL or not.

Ifvertices isNULL, then the first two columns ofdare used as a symbolic edge list and additional columns as edge attributes.The names of the attributes are taken from the names of the columns.

Ifvertices is notNULL, then it must be a data frame givingvertex metadata. The first column ofvertices is assumed to containsymbolic vertex names, this will be added to the graphs as the‘name’ vertex attribute. Other columns will be added asadditional vertex attributes. Ifvertices is notNULL then thesymbolic edge list given ind is checked to contain only vertex nameslisted invertices.

Typically, the data frames are exported from some spreadsheet software likeExcel and are imported into R viaread.table(),read.delim() orread.csv().

All edges in the data frame are included in the graph, which may includemultiple parallel edges and loops.

as_data_frame() converts the igraph graph into one or more dataframes, depending on thewhat argument.

If thewhat argument isedges (the default), then the edges ofthe graph and also the edge attributes are returned. The edges will be inthe first two columns, namedfrom andto. (This also denotesedge direction for directed graphs.) For named graphs, the vertex nameswill be included in these columns, for other graphs, the numeric vertex ids.The edge attributes will be in the other columns. It is not a good idea tohave an edge attribute namedfrom orto, because then thecolumn named in the data frame will not be unique. The edges are listed inthe order of their numeric ids.

If thewhat argument isvertices, then vertex attributes arereturned. Vertices are listed in the order of their numeric vertex ids.

If thewhat argument isboth, then both vertex and edge datais returned, in a list with named entriesvertices andedges.

Value

An igraph graph object forgraph_from_data_frame(), and either adata frame or a list of two data frames namededges andvertices foras.data.frame.

Note

Forgraph_from_data_frame()NA elements in the first twocolumns ‘d’ are replaced by the string “NA” before creatingthe graph. This means that allNAs will correspond to a singlevertex.

NA elements in the first column of ‘vertices’ are alsoreplaced by the string “NA”, but the rest of ‘vertices’ is nottouched. In other words, vertex names (=the first column) cannot beNA, but other vertex attributes can.

Author(s)

Gabor Csardicsardi.gabor@gmail.com

See Also

graph_from_literal()for another way to create graphs,read.table() to read in tablesfrom files.

Other conversion:as.matrix.igraph(),as_adj_list(),as_adjacency_matrix(),as_biadjacency_matrix(),as_directed(),as_edgelist(),as_graphnel(),as_long_data_frame(),graph_from_adj_list(),graph_from_graphnel()

Other biadjacency:graph_from_biadjacency_matrix()

Examples

## A simple example with a couple of actors## The typical case is that these tables are read in from files....actors <- data.frame(  name = c(    "Alice", "Bob", "Cecil", "David",    "Esmeralda"  ),  age = c(48, 33, 45, 34, 21),  gender = c("F", "M", "F", "M", "F"))relations <- data.frame(  from = c(    "Bob", "Cecil", "Cecil", "David",    "David", "Esmeralda"  ),  to = c("Alice", "Bob", "Alice", "Alice", "Bob", "Alice"),  same.dept = c(FALSE, FALSE, TRUE, FALSE, FALSE, TRUE),  friendship = c(4, 5, 5, 2, 1, 1), advice = c(4, 5, 5, 4, 2, 3))g <- graph_from_data_frame(relations, directed = TRUE, vertices = actors)print(g, e = TRUE, v = TRUE)## The opposite operationas_data_frame(g, what = "vertices")as_data_frame(g, what = "edges")

Convert between directed and undirected graphs

Description

as_directed() converts an undirected graph to directed,as_undirected() does the opposite, it converts a directed graph toundirected.

Usage

as_directed(graph, mode = c("mutual", "arbitrary", "random", "acyclic"))as_undirected(  graph,  mode = c("collapse", "each", "mutual"),  edge.attr.comb = igraph_opt("edge.attr.comb"))

Arguments

Details

Conversion algorithms foras_directed():

"arbitrary"

The number of edges in the graph stays the same, anarbitrarily directed edge is created for each undirected edge, but thedirection of the edge is deterministic (i.e. it always points the sameway if you call the function multiple times).

"mutual"

Two directed edges are created for each undirectededge, one in each direction.

"random"

The number of edges in the graph stays the same, anda randomly directed edge is created for each undirected edge. Youwill get different results if you call the function multiple timeswith the same graph.

"acyclic"

The number of edges in the graph stays the same, anda directed edge is created for each undirected edge such that theresulting graph is guaranteed to be acyclic. This is achieved by ensuringthat edges always point from a lower index vertex to a higher index.Note that the graph may include cycles of length 1 if the originalgraph contained loop edges.

Conversion algorithms foras_undirected():

"each"

The number of edges remains constant, an undirected edgeis created for each directed one, this version might create graphs withmultiple edges.

"collapse"

One undirected edge will be createdfor each pair of vertices which are connected with at least one directededge, no multiple edges will be created.

"mutual"

Oneundirected edge will be created for each pair of mutual edges. Non-mutualedges are ignored. This mode might create multiple edges if there are morethan one mutual edge pairs between the same pair of vertices.

Value

A new graph object.

Related documentation in the C library

to_directed().

Author(s)

Gabor Csardicsardi.gabor@gmail.com

See Also

simplify() for removing multiple and/or loop edges froma graph.

Other conversion:as.matrix.igraph(),as_adj_list(),as_adjacency_matrix(),as_biadjacency_matrix(),as_data_frame(),as_edgelist(),as_graphnel(),as_long_data_frame(),graph_from_adj_list(),graph_from_graphnel()

Examples

g <- make_ring(10)as_directed(g, "mutual")g2 <- make_star(10)as_undirected(g)# Combining edge attributesg3 <- make_ring(10, directed = TRUE, mutual = TRUE)E(g3)$weight <- seq_len(ecount(g3))ug3 <- as_undirected(g3)print(ug3, e = TRUE)x11(width = 10, height = 5)layout(rbind(1:2))plot(g3, layout = layout_in_circle, edge.label = E(g3)$weight)plot(ug3, layout = layout_in_circle, edge.label = E(ug3)$weight)g4 <- make_graph(c(  1, 2, 3, 2, 3, 4, 3, 4, 5, 4, 5, 4,  6, 7, 7, 6, 7, 8, 7, 8, 8, 7, 8, 9, 8, 9,  9, 8, 9, 8, 9, 9, 10, 10, 10, 10))E(g4)$weight <- seq_len(ecount(g4))ug4 <- as_undirected(g4,  mode = "mutual",  edge.attr.comb = list(weight = length))print(ug4, e = TRUE)

Convert a graph to an edge list

Description

Sometimes it is useful to work with a standard representation of agraph, like an edge list.

Usage

as_edgelist(graph, names = TRUE)

Arguments

Details

as_edgelist() returns the list of edges in a graph.

Value

Aecount(graph) by 2 numeric matrix.

See Also

graph_from_adjacency_matrix(),read_graph()

Other conversion:as.matrix.igraph(),as_adj_list(),as_adjacency_matrix(),as_biadjacency_matrix(),as_data_frame(),as_directed(),as_graphnel(),as_long_data_frame(),graph_from_adj_list(),graph_from_graphnel()

Examples

g <- sample_gnp(10, 2 / 10)as_edgelist(g)V(g)$name <- LETTERS[seq_len(gorder(g))]as_edgelist(g)

Convert igraph graphs to graphNEL objects from the graph package

Description

The graphNEL class is defined in thegraph package, it is anotherway to represent graphs. These functions are provided to convert betweenthe igraph and the graphNEL objects.

Usage

as_graphnel(graph)

Arguments

Details

as_graphnel() converts an igraph graph to a graphNEL graph. Itconverts all graph/vertex/edge attributes. If the igraph graph has avertex attribute ‘name’, then it will be used to assignvertex names in the graphNEL graph. Otherwise numeric igraph vertex idswill be used for this purpose.

Value

as_graphnel() returns a graphNEL graph object.

See Also

graph_from_graphnel() for the other direction,as_adjacency_matrix(),graph_from_adjacency_matrix(),as_adj_list() andgraph_from_adj_list() forother graph representations.

Other conversion:as.matrix.igraph(),as_adj_list(),as_adjacency_matrix(),as_biadjacency_matrix(),as_data_frame(),as_directed(),as_edgelist(),as_long_data_frame(),graph_from_adj_list(),graph_from_graphnel()

Examples

## Undirectedg <- make_ring(10)V(g)$name <- letters[1:10]GNEL <- as_graphnel(g)g2 <- graph_from_graphnel(GNEL)g2## Directedg3 <- make_star(10, mode = "in")V(g3)$name <- letters[1:10]GNEL2 <- as_graphnel(g3)g4 <- graph_from_graphnel(GNEL2)g4

Convert a vertex or edge sequence to an ordinary vector

Description

Convert a vertex or edge sequence to an ordinary vector

Usage

as_ids(seq)## S3 method for class 'igraph.vs'as_ids(seq)## S3 method for class 'igraph.es'as_ids(seq)

Arguments

Details

For graphs without names, a numeric vector is returned, containing theinternal numeric vertex or edge ids.

For graphs with names, and vertex sequences, the vertex names arereturned in a character vector.

For graphs with names and edge sequences, a character vector isreturned, with the ‘bar’ notation:a|b means an edge fromvertexa to vertexb.

Value

A character or numeric vector, see details below.

See Also

Other vertex and edge sequences:E(),V(),igraph-es-attributes,igraph-es-indexing,igraph-es-indexing2,igraph-vs-attributes,igraph-vs-indexing,igraph-vs-indexing2,print.igraph.es(),print.igraph.vs()

Examples

g <- make_ring(10)as_ids(V(g))as_ids(E(g))V(g)$name <- letters[1:10]as_ids(V(g))as_ids(E(g))

As incidence matrix

Description

as_incidence_matrix() was renamed toas_biadjacency_matrix() to create a moreconsistent API.

Usage

as_incidence_matrix(...)

Details

Some authors refer to the bipartite adjacency matrix as the"bipartite incidence matrix". igraph 1.6.0 and later does not usethis naming to avoid confusion with the edge-vertex incidence matrix.

Convert a graph to a long data frame

Description

A long data frame contains all metadata about both the verticesand edges of the graph. It contains one row for each edge, andall metadata about that edge and its incident vertices are includedin that row. The names of the columns that contain the metadataof the incident vertices are prefixed withfrom_ andto_.The first two columns are always namedfrom andto andthey contain the numeric ids of the incident vertices. The rows arelisted in the order of numeric vertex ids.

Usage

as_long_data_frame(graph)

Arguments

Value

A long data frame.

See Also

Other conversion:as.matrix.igraph(),as_adj_list(),as_adjacency_matrix(),as_biadjacency_matrix(),as_data_frame(),as_directed(),as_edgelist(),as_graphnel(),graph_from_adj_list(),graph_from_graphnel()

Examples

g <- make_(  ring(10),  with_vertex_(name = letters[1:10], color = "red"),  with_edge_(weight = 1:10, color = "green"))as_long_data_frame(g)

Declare a numeric vector as a membership vector

Description

This is useful if you want to use functions defined onmembership vectors, but your membership vector does notcome from an igraph clustering method.

Usage

as_membership(x)

Arguments

Value

The input vector, with themembership class added.

See Also

Community detectioncluster_edge_betweenness(),cluster_fast_greedy(),cluster_fluid_communities(),cluster_infomap(),cluster_label_prop(),cluster_leading_eigen(),cluster_leiden(),cluster_louvain(),cluster_optimal(),cluster_spinglass(),cluster_walktrap(),compare(),groups(),make_clusters(),membership(),modularity.igraph(),plot_dendrogram(),split_join_distance(),voronoi_cells()

Examples

## Compare to the correct clusteringg <- (make_full_graph(10) + make_full_graph(10)) %>%  rewire(each_edge(p = 0.2))correct <- rep(1:2, each = 10) %>% as_membership()fc <- cluster_fast_greedy(g)compare(correct, fc)compare(correct, membership(fc))

as_phylo

Description

as_phylo methods were renamedas.phylofor more consistency with other R methods.

Usage

as_phylo(x, ...)

Arguments

Assortativity coefficient

Description

The assortativity coefficient is positive if similar vertices (based on someexternal property) tend to connect to each, and negative otherwise.

Usage

assortativity(  graph,  values,  ...,  values.in = NULL,  directed = TRUE,  normalized = TRUE,  types1 = NULL,  types2 = NULL)assortativity_nominal(graph, types, directed = TRUE, normalized = TRUE)assortativity_degree(graph, directed = TRUE)

Arguments

Details

The assortativity coefficient measures the level of homophyly of the graph,based on some vertex labeling or values assigned to vertices. If thecoefficient is high, that means that connected vertices tend to have thesame labels or similar assigned values.

M.E.J. Newman defined two kinds of assortativity coefficients, the first oneis for categorical labels of vertices.assortativity_nominal()calculates this measure. It is defined as

r=\frac{\sum_i e_{ii}-\sum_i a_i b_i}{1-\sum_i a_i b_i}

wheree_{ij} is the fraction of edges connecting vertices oftypei andj,a_i=\sum_j e_{ij} andb_j=\sum_i e_{ij}.

The second assortativity variant is based on values assigned to thevertices.assortativity() calculates this measure. It is defined as

r=\frac1{\sigma_q^2}\sum_{jk} jk(e_{jk}-q_j q_k)

for undirected graphs (q_i=\sum_j e_{ij}) and as

r=\frac1{\sigma_o\sigma_i}\sum_{jk}jk(e_{jk}-q_j^o q_k^i)

for directed ones. Hereq_i^o=\sum_j e_{ij},q_i^i=\sum_j e_{ji}, moreover,\sigma_q,\sigma_o and\sigma_i are the standard deviations ofq,q^o andq^i, respectively.

The reason of the difference is that in directed networks the relationshipis not symmetric, so it is possible to assign different values to theoutgoing and the incoming end of the edges.

assortativity_degree() uses vertex degree as vertex valuesand callsassortativity().

Undirected graphs are effectively treated as directed ones with all-reciprocal edges.Thus, self-loops are taken into account twice in undirected graphs.

Value

A single real number.

Related documentation in the C library

assortativity(),assortativity_nominal(),assortativity_degree().

Author(s)

Gabor Csardicsardi.gabor@gmail.com

References

M. E. J. Newman: Mixing patterns in networks,Phys. Rev.E 67, 026126 (2003)https://arxiv.org/abs/cond-mat/0209450

M. E. J. Newman: Assortative mixing in networks,Phys. Rev. Lett. 89,208701 (2002)https://arxiv.org/abs/cond-mat/0205405

Examples

# random network, close to zeroassortativity_degree(sample_gnp(10000, 3 / 10000))# BA model, tends to be dissortativeassortativity_degree(sample_pa(10000, m = 4))

Assortativity coefficient

Description

assortativity.degree() was renamed toassortativity_degree() to create a moreconsistent API.

Usage

assortativity.degree(graph, directed = TRUE)

Arguments

Assortativity coefficient

Description

assortativity.nominal() was renamed toassortativity_nominal() to create a moreconsistent API.

Usage

assortativity.nominal(graph, types, directed = TRUE, normalized = TRUE)

Arguments

Trait-based random generation

Description

asymmetric.preference.game() was renamed tosample_asym_pref() to create a moreconsistent API.

Usage

asymmetric.preference.game(  nodes,  types,  type.dist.matrix = matrix(1, types, types),  pref.matrix = matrix(1, types, types),  loops = FALSE)

Arguments

Kleinberg's hub and authority centrality scores.

Description

authority.score() was renamed toauthority_score() to create a moreconsistent API.

Usage

authority.score(  graph,  scale = TRUE,  weights = NULL,  options = arpack_defaults())

Arguments

Kleinberg's authority centrality scores.

Description

Kleinberg's authority centrality scores.

Kleinberg's hub centrality scores.

Usage

authority_score(  graph,  scale = TRUE,  weights = NULL,  options = arpack_defaults())hub_score(graph, scale = TRUE, weights = NULL, options = arpack_defaults())

Arguments

See Also

Centrality measuresalpha_centrality(),betweenness(),closeness(),diversity(),eigen_centrality(),harmonic_centrality(),hits_scores(),page_rank(),power_centrality(),spectrum(),strength(),subgraph_centrality()

Optimal edge curvature when plotting graphs

Description

autocurve.edges() was renamed tocurve_multiple() to create a moreconsistent API.

Usage

autocurve.edges(graph, start = 0.5)

Arguments

Generating set of the automorphism group of a graph

Description

Compute the generating set of the automorphism group of a graph.

Usage

automorphism_group(  graph,  colors = NULL,  sh = c("fm", "f", "fs", "fl", "flm", "fsm"),  details = FALSE)

Arguments

Details

An automorphism of a graph is a permutation of its vertices which brings thegraph into itself. The automorphisms of a graph form a group and there existsa subset of this group (i.e. a set of permutations) such that every otherpermutation can be expressed as a combination of these permutations. Thesepermutations are called the generating set of the automorphism group.

This function calculates a possible generating set of the automorphism ofa graph using the BLISS algorithm. See also the BLISS homepage athttp://www.tcs.hut.fi/Software/bliss/index.html. The calculatedgenerating set is not necessarily minimal, and it may depend on the splittingheuristics used by BLISS.

Value

Whendetails isFALSE, a list of vertex permutationsthat form a generating set of the automorphism group of the input graph.Whendetails isTRUE, a named list with two members:

generators

Returns the generators themselves

info

Additional information about the BLISS internals.Seecount_automorphisms() for more details.

Related documentation in the C library

automorphism_group().

Author(s)

Tommi Junttila (https://users.ics.aalto.fi/tjunttil/) for BLISS,Gabor Csardicsardi.gabor@gmail.com for the igraph glue code andTamas Nepuszntamas@gmail.com for this manual page.

References

Tommi Junttila and Petteri Kaski: Engineering an EfficientCanonical Labeling Tool for Large and Sparse Graphs,Proceedings ofthe Ninth Workshop on Algorithm Engineering and Experiments and the FourthWorkshop on Analytic Algorithms and Combinatorics. 2007.

See Also

canonical_permutation(),permute(),count_automorphisms()

Other graph automorphism:count_automorphisms()

Examples

## A ring has n*2 automorphisms, and a possible generating set is one that## "turns" the ring by one vertex to the left or rightg <- make_ring(10)automorphism_group(g)

Number of automorphisms

Description

automorphisms() was renamed tocount_automorphisms() to create a moreconsistent API.

Usage

automorphisms(  graph,  colors = NULL,  sh = c("fm", "f", "fs", "fl", "flm", "fsm"))

Arguments

Shortest (directed or undirected) paths between vertices

Description

average.path.length() was renamed tomean_distance() to create a moreconsistent API.

Usage

average.path.length(  graph,  weights = NULL,  directed = TRUE,  unconnected = TRUE,  details = FALSE)

Arguments

Generate random graphs using preferential attachment

Description

ba.game() was renamed tosample_pa() to create a moreconsistent API.

Usage

ba.game(  n,  power = 1,  m = NULL,  out.dist = NULL,  out.seq = NULL,  out.pref = FALSE,  zero.appeal = 1,  directed = TRUE,  algorithm = c("psumtree", "psumtree-multiple", "bag"),  start.graph = NULL)

Arguments

Generate random graphs using preferential attachment

Description

barabasi.game() was renamed tosample_pa() to create a moreconsistent API.

Usage

barabasi.game(  n,  power = 1,  m = NULL,  out.dist = NULL,  out.seq = NULL,  out.pref = FALSE,  zero.appeal = 1,  directed = TRUE,  algorithm = c("psumtree", "psumtree-multiple", "bag"),  start.graph = NULL)

Arguments

Vertex and edge betweenness centrality

Description

The vertex and edge betweenness are (roughly) defined by the number ofgeodesics (shortest paths) going through a vertex or an edge.

Usage

betweenness(  graph,  v = V(graph),  directed = TRUE,  weights = NULL,  normalized = FALSE,  cutoff = -1)edge_betweenness(  graph,  e = E(graph),  directed = TRUE,  weights = NULL,  cutoff = -1)

Arguments

Details

The vertex betweenness of vertexv is defined by

\sum_{i\ne j, i\ne v, j\ne v} g_{ivj}/g_{ij}

The edge betweenness of edgee is defined by

\sum_{i\ne j} g_{iej}/g_{ij}.

betweenness() calculates vertex betweenness,edge_betweenness()calculates edge betweenness.

Hereg_{ij} is the total number of shortest paths between verticesi andj whileg_{ivj} is the number of those shortest pathswhich pass though vertexv.

Both functions allow you to consider only paths of lengthcutoff orsmaller; this can be run for larger graphs, as the running time is notquadratic (ifcutoff is small). Ifcutoff is negative (the default),then the function calculates the exact betweenness scores. Since igraph 1.6.0,acutoff value of zero is treated literally, i.e. paths of length largerthan zero are ignored.

For calculating the betweenness a similar algorithm to the one proposed byBrandes (see References) is used.

Value

A numeric vector with the betweenness score for each vertex inv forbetweenness().

A numeric vector with the edge betweenness score for each edge ineforedge_betweenness().

Note

edge_betweenness() might give false values for graphs withmultiple edges.

Author(s)

Gabor Csardicsardi.gabor@gmail.com

References

Freeman, L.C. (1979). Centrality in Social Networks I:Conceptual Clarification.Social Networks, 1, 215-239.doi:10.1016/0378-8733(78)90021-7

Ulrik Brandes, A Faster Algorithm for Betweenness Centrality.Journalof Mathematical Sociology 25(2):163-177, 2001.doi:10.1080/0022250X.2001.9990249

See Also

closeness(),degree(),harmonic_centrality()

Centrality measuresalpha_centrality(),authority_score(),closeness(),diversity(),eigen_centrality(),harmonic_centrality(),hits_scores(),page_rank(),power_centrality(),spectrum(),strength(),subgraph_centrality()

Examples

g <- sample_gnp(10, 3 / 10)betweenness(g)edge_betweenness(g)

Breadth-first search

Description

Breadth-first search is an algorithm to traverse a graph. We start from aroot vertex and spread along every edge “simultaneously”.

Usage

bfs(  graph,  root,  mode = c("out", "in", "all", "total"),  ...,  unreachable = TRUE,  restricted = NULL,  order = TRUE,  rank = FALSE,  parent = FALSE,  pred = FALSE,  succ = FALSE,  dist = FALSE,  callback = NULL,  extra = NULL,  rho = parent.frame(),  neimode = deprecated(),  father = deprecated())

Arguments

Details

The callback function must have the following arguments:

graph

The input graph is passed to the callback function here.

data

A named numeric vector, with the following entries:‘vid’, the vertex that was just visited,‘pred’, its predecessor (zero if this is the first vertex),‘succ’, its successor (zero if this is the last vertex),‘rank’, the rank of the current vertex,‘dist’, its distance from the root of the search tree.

extra

The extra argument.

The callback must returnFALSEto continue the search orTRUE to terminate it. See examples below on how touse the callback function.

Value

A named list with the following entries:

root

Numeric scalar. The root vertex that was used as the starting point of the search.

neimode

Character scalar. Themode argument of the function call.Note that for undirected graphs this is always ‘all’, irrespectively of the supplied value.

order

Numeric vector. The vertex ids, in the order in which they were visited by the search.

rank

Numeric vector. The rank for each vertex, zero for unreachable vertices.

parent

Numeric vector. The parent of each vertex, i.e. the vertex it was discovered from.

father

Like parent, kept for compatibility for now.

pred

Numeric vector. The previously visited vertex for each vertex, or 0 if there was no such vertex.

succ

Numeric vector. The next vertex that was visited after the current one, or 0 if there was no such vertex.

dist

Numeric vector, for each vertex its distance from the root of the search tree.Unreachable vertices have a negative distance as of igraph 1.6.0, this used to beNaN.

Note thatorder,rank,parent,pred,succanddist might beNULL if their corresponding argument isFALSE, i.e. if their calculation is not requested.

Author(s)

Gabor Csardicsardi.gabor@gmail.com

See Also

dfs() for depth-first search.

Other structural.properties:component_distribution(),connect(),constraint(),coreness(),degree(),dfs(),distance_table(),edge_density(),feedback_arc_set(),feedback_vertex_set(),girth(),is_acyclic(),is_dag(),is_matching(),k_shortest_paths(),knn(),reciprocity(),subcomponent(),subgraph(),topo_sort(),transitivity(),unfold_tree(),which_multiple(),which_mutual()

Examples

## Two ringsbfs(make_ring(10) %du% make_ring(10),  root = 1, "out",  order = TRUE, rank = TRUE, parent = TRUE, pred = TRUE,  succ = TRUE, dist = TRUE)## How to use a callbackf <- function(graph, data, extra) {  print(data)  FALSE}tmp <- bfs(make_ring(10) %du% make_ring(10),  root = 1, "out",  callback = f)## How to use a callback to stop the search## We stop after visiting all vertices in the initial componentf <- function(graph, data, extra) {  data["succ"] == -1}bfs(make_ring(10) %du% make_ring(10), root = 1, callback = f)

Biconnected components

Description

biconnected.components() was renamed tobiconnected_components() to create a moreconsistent API.

Usage

biconnected.components(graph)

Arguments

Biconnected components

Description

Finding the biconnected components of a graph

Usage

biconnected_components(graph)

Arguments

Details

A graph is biconnected if the removal of any single vertex (and its adjacentedges) does not disconnect it.

A biconnected component of a graph is a maximal biconnected subgraph of it.The biconnected components of a graph can be given by the partition of itsedges: every edge is a member of exactly one biconnected component. Notethat this is not true for vertices: the same vertex can be part of manybiconnected components.

Value

A named list with three components:

no

Numeric scalar, an integer giving the number of biconnected components in the graph.

tree_edges

The components themselves, a list of numeric vectors.Each vector is a set of edge ids giving the edges in a biconnected component.These edges define a spanning tree of the component.

component_edges

A list of numeric vectors. It gives all edges in the components.

components

A list of numeric vectors, the vertices of the components.

articulation_points

The articulation points of the graph. Seearticulation_points().

Related documentation in the C library

biconnected_components().

Author(s)

Gabor Csardicsardi.gabor@gmail.com

See Also

articulation_points(),components(),is_connected(),vertex_connectivity()

Connected componentsarticulation_points(),component_distribution(),decompose(),is_biconnected()

Examples

g <- disjoint_union(make_full_graph(5), make_full_graph(5))clu <- components(g)$membershipg <- add_edges(g, c(which(clu == 1), which(clu == 2)))bc <- biconnected_components(g)

Decide whether a graph is bipartite

Description

bipartite.mapping() was renamed tobipartite_mapping() to create a moreconsistent API.

Usage

bipartite.mapping(graph)

Arguments

Project a bipartite graph

Description

bipartite.projection() was renamed tobipartite_projection() to create a moreconsistent API.

Usage

bipartite.projection(  graph,  types = NULL,  multiplicity = TRUE,  probe1 = NULL,  which = c("both", "true", "false"),  remove.type = TRUE)

Arguments

Project a bipartite graph

Description

bipartite.projection.size() was renamed tobipartite_projection_size() to create a moreconsistent API.

Usage

bipartite.projection.size(graph, types = NULL)

Arguments

Bipartite random graphs

Description

bipartite.random.game() was renamed tosample_bipartite() to create a moreconsistent API.

Usage

bipartite.random.game(  n1,  n2,  type = c("gnp", "gnm"),  p,  m,  directed = FALSE,  mode = c("out", "in", "all"))

Arguments

Bipartite random graphs

Description

Generate bipartite graphs using the Erdős-Rényi model

Usage

bipartite_gnm(...)bipartite_gnp(...)sample_bipartite_gnm(  n1,  n2,  m,  ...,  directed = FALSE,  mode = c("out", "in", "all"))sample_bipartite_gnp(  n1,  n2,  p,  ...,  directed = FALSE,  mode = c("out", "in", "all"))

Arguments

Details

Similarly to unipartite (one-mode) networks, we can define theG(n,p), andG(n,m) graph classes for bipartite graphs, via their generating process.InG(n,p) every possible edge between top and bottom vertices is realizedwith probabilityp, independently of the rest of the edges. InG(n,m), weuniformly choosem edges to realize.

See Also

Random graph models (games)erdos.renyi.game(),sample_(),sample_bipartite(),sample_chung_lu(),sample_correlated_gnp(),sample_correlated_gnp_pair(),sample_degseq(),sample_dot_product(),sample_fitness(),sample_fitness_pl(),sample_forestfire(),sample_gnm(),sample_gnp(),sample_grg(),sample_growing(),sample_hierarchical_sbm(),sample_islands(),sample_k_regular(),sample_last_cit(),sample_pa(),sample_pa_age(),sample_pref(),sample_sbm(),sample_smallworld(),sample_traits_callaway(),sample_tree()

Examples

## empty graphsample_bipartite_gnp(10, 5, p = 0)## full graphsample_bipartite_gnp(10, 5, p = 1)## random bipartite graphsample_bipartite_gnp(10, 5, p = .1)## directed bipartite graph, G(n,m)sample_bipartite_gnm(10, 5, m = 20, directed = TRUE, mode = "all")

Decide whether a graph is bipartite

Description

This function decides whether the vertices of a network can be mapped to twovertex types in a way that no vertices of the same type are connected.

Usage

bipartite_mapping(graph)

Arguments

Details

A bipartite graph in igraph has a ‘type’ vertex attributegiving the two vertex types.

This function simply checks whether a graphcould be bipartite. Ittries to find a mapping that gives a possible division of the vertices intotwo classes, such that no two vertices of the same class are connected by anedge.

The existence of such a mapping is equivalent of having no circuits of oddlength in the graph. A graph with loop edges cannot bipartite.

Note that the mapping is not necessarily unique, e.g. if the graph has atleast two components, then the vertices in the separate components can bemapped independently.

Value

A named list with two elements:

res

A logical scalar,TRUE if the can be bipartite,FALSE otherwise.

type

A possible vertex type mapping, a logical vector.If no such mapping exists, then an empty vector.

Related documentation in the C library

is_bipartite().

Author(s)

Gabor Csardicsardi.gabor@gmail.com

See Also

Bipartite graphsbipartite_projection(),is_bipartite(),make_bipartite_graph()

Examples

## Rings with an even number of vertices are bipartiteg <- make_ring(10)bipartite_mapping(g)## All star graphs are bipartiteg2 <- make_star(10)bipartite_mapping(g2)## A graph containing a triangle is not bipartiteg3 <- make_ring(10)g3 <- add_edges(g3, c(1, 3))bipartite_mapping(g3)

Project a bipartite graph

Description

A bipartite graph is projected into two one-mode networks

Usage

bipartite_projection(  graph,  types = NULL,  multiplicity = TRUE,  probe1 = NULL,  which = c("both", "true", "false"),  remove.type = TRUE)bipartite_projection_size(graph, types = NULL)

Arguments

Details

Bipartite graphs have atype vertex attribute in igraph, this isboolean andFALSE for the vertices of the first kind andTRUEfor vertices of the second kind.

bipartite_projection_size() calculates the number of vertices and edgesin the two projections of the bipartite graphs, without calculating theprojections themselves. This is useful to check how much memory theprojections would need if you have a large bipartite graph.

bipartite_projection() calculates the actual projections. You can usetheprobe1 argument to specify the order of the projections in theresult. By default vertex typeFALSE is the first andTRUE isthe second.

bipartite_projection() keeps vertex attributes.

Value

A list of two undirected graphs. See details above.

Related documentation in the C library

bipartite_projection_size().

Author(s)

Gabor Csardicsardi.gabor@gmail.com

See Also

Bipartite graphsbipartite_mapping(),is_bipartite(),make_bipartite_graph()

Examples

## Projection of a full bipartite graph is a full graphg <- make_full_bipartite_graph(10, 5)proj <- bipartite_projection(g)isomorphic(proj[[1]], make_full_graph(10))isomorphic(proj[[2]], make_full_graph(5))## The projection keeps the vertex attributesM <- matrix(0, nrow = 5, ncol = 3)rownames(M) <- c("Alice", "Bob", "Cecil", "Dan", "Ethel")colnames(M) <- c("Party", "Skiing", "Badminton")M[] <- sample(0:1, length(M), replace = TRUE)Mg2 <- graph_from_biadjacency_matrix(M)g2$name <- "Event network"proj2 <- bipartite_projection(g2)print(proj2[[1]], g = TRUE, e = TRUE)print(proj2[[2]], g = TRUE, e = TRUE)

Calculate Cohesive Blocks

Description

blockGraphs() was renamed tographs_from_cohesive_blocks() to create a moreconsistent API.

Usage

blockGraphs(blocks, graph)

Arguments

Find Bonacich Power Centrality Scores of Network Positions

Description

bonpow() was renamed topower_centrality() to create a moreconsistent API.

Usage

bonpow(  graph,  nodes = V(graph),  loops = FALSE,  exponent = 1,  rescale = FALSE,  tol = 1e-07,  sparse = TRUE)

Arguments

Concatenate edge sequences

Description

Concatenate edge sequences

Usage

## S3 method for class 'igraph.es'c(..., recursive = FALSE)

Arguments

Value

An edge sequence, the input sequences concatenated.

See Also

Other vertex and edge sequence operations:c.igraph.vs(),difference.igraph.es(),difference.igraph.vs(),igraph-es-indexing,igraph-es-indexing2,igraph-vs-indexing,igraph-vs-indexing2,intersection.igraph.es(),intersection.igraph.vs(),rev.igraph.es(),rev.igraph.vs(),union.igraph.es(),union.igraph.vs(),unique.igraph.es(),unique.igraph.vs()

Examples

g <- make_(ring(10), with_vertex_(name = LETTERS[1:10]))c(E(g)[1], E(g)["A|B"], E(g)[1:4])

Concatenate vertex sequences

Description

Concatenate vertex sequences

Usage

## S3 method for class 'igraph.vs'c(..., recursive = FALSE)

Arguments

Value

A vertex sequence, the input sequences concatenated.

See Also

Other vertex and edge sequence operations:c.igraph.es(),difference.igraph.es(),difference.igraph.vs(),igraph-es-indexing,igraph-es-indexing2,igraph-vs-indexing,igraph-vs-indexing2,intersection.igraph.es(),intersection.igraph.vs(),rev.igraph.es(),rev.igraph.vs(),union.igraph.es(),union.igraph.vs(),unique.igraph.es(),unique.igraph.vs()

Examples

g <- make_(ring(10), with_vertex_(name = LETTERS[1:10]))c(V(g)[1], V(g)["A"], V(g)[1:4])

Graph generation based on different vertex types

Description

callaway.traits.game() was renamed tosample_traits_callaway() to create a moreconsistent API.

Usage

callaway.traits.game(  nodes,  types,  edge.per.step = 1,  type.dist = rep(1, types),  pref.matrix = matrix(1, types, types),  directed = FALSE)

Arguments

Canonical permutation of a graph

Description

canonical.permutation() was renamed tocanonical_permutation() to create a moreconsistent API.

Usage

canonical.permutation(  graph,  colors = NULL,  sh = c("fm", "f", "fs", "fl", "flm", "fsm"))

Arguments

Canonical permutation of a graph

Description

The canonical permutation brings every isomorphic graphs into the same(labeled) graph.

Usage

canonical_permutation(  graph,  colors = NULL,  sh = c("fm", "f", "fs", "fl", "flm", "fsm"))

Arguments

Details

canonical_permutation() computes a permutation which brings the graphinto canonical form, as defined by the BLISS algorithm. All isomorphicgraphs have the same canonical form.

See the paper below for the details about BLISS. This and more informationis available athttp://www.tcs.hut.fi/Software/bliss/index.html.

The possible values for thesh argument are:

"f"

First non-singleton cell.

"fl"

First largest non-singleton cell.

"fs"

First smallest non-singleton cell.

"fm"

First maximally non-trivially connectec non-singleton cell.

"flm"

Largest maximally non-trivially connected non-singleton cell.

"fsm"

Smallest maximally non-trivially connected non-singleton cell.

See the paper in references for detailsabout these.

Value

A list with the following members:

labeling

The canonical permutation which takes the input graph into canonical form.A numeric vector, the first element is the new label of vertex 0, the second element for vertex 1, etc.

info

Some information about the BLISS computation. A named list with the following members:

"nof_nodes"

The number of nodes in the search tree.

"nof_leaf_nodes"

The number of leaf nodes in the search tree.

"nof_bad_nodes"

Number of bad nodes.

"nof_canupdates"

Number of canrep updates.

"max_level"

Maximum level.

"group_size"

The size of the automorphism group of the input graph, as a string.The string representation is necessary because the group sizecan easily exceed values that are exactly representable in floating point.

Related documentation in the C library

canonical_permutation().

Author(s)

Tommi Junttila for BLISS, Gabor Csardicsardi.gabor@gmail.com for the igraph and R interfaces.

References

Tommi Junttila and Petteri Kaski: Engineering an EfficientCanonical Labeling Tool for Large and Sparse Graphs,Proceedings ofthe Ninth Workshop on Algorithm Engineering and Experiments and the FourthWorkshop on Analytic Algorithms and Combinatorics. 2007.

See Also

permute() to apply a permutation to a graph,isomorphic() for deciding graph isomorphism, possiblybased on canonical labels.

Other graph isomorphism:count_isomorphisms(),count_subgraph_isomorphisms(),graph_from_isomorphism_class(),isomorphic(),isomorphism_class(),isomorphisms(),subgraph_isomorphic(),subgraph_isomorphisms()

Examples

## Calculate the canonical form of a random graphg1 <- sample_gnm(10, 20)cp1 <- canonical_permutation(g1)cf1 <- permute(g1, cp1$labeling)## Do the same with a random permutation of itg2 <- permute(g1, sample(vcount(g1)))cp2 <- canonical_permutation(g2)cf2 <- permute(g2, cp2$labeling)## Check that they are the sameel1 <- as_edgelist(cf1)el2 <- as_edgelist(cf2)el1 <- el1[order(el1[, 1], el1[, 2]), ]el2 <- el2[order(el2[, 1], el2[, 2]), ]all(el1 == el2)

Palette for categories

Description

This is a color blind friendly palette fromhttps://jfly.uni-koeln.de/color/. It has 8 colors.

Usage

categorical_pal(n)

Arguments

Details

This is the suggested palette for visualizations where vertex colorsmark categories, e.g. community membership.

Value

A character vector of RGB color codes.

Examples

library(igraphdata)data(karate)karate <- karate   add_layout_(with_fr())   set_vertex_attr("size", value = 10)cl_k <- cluster_optimal(karate)V(karate)$color <- membership(cl_k)karate$palette <- categorical_pal(length(cl_k))plot(karate)

See Also

Other palettes:diverging_pal(),r_pal(),sequential_pal()

Centralize a graph according to the betweenness of vertices

Description

Seecentralize() for a summary of graph centralization.

Usage

centr_betw(graph, directed = TRUE, normalized = TRUE)

Arguments

Value

A named list with the following components:

res

The node-level centrality scores.

centralization

The graph level centrality index.

theoretical_max

The maximum theoretical graph level centralization scorefor a graph with the given number of vertices,using the same parameters.If thenormalized argument wasTRUE,then the result was divided by this number.

See Also

Other centralization related:centr_betw_tmax(),centr_clo(),centr_clo_tmax(),centr_degree(),centr_degree_tmax(),centr_eigen(),centr_eigen_tmax(),centralize()

Examples

# A BA graph is quite centralizedg <- sample_pa(1000, m = 4)centr_degree(g)$centralizationcentr_clo(g, mode = "all")$centralizationcentr_betw(g, directed = FALSE)$centralizationcentr_eigen(g, directed = FALSE)$centralization

Theoretical maximum for betweenness centralization

Description

Seecentralize() for a summary of graph centralization.

Usage

centr_betw_tmax(graph = NULL, nodes = 0, directed = TRUE)

Arguments

Value

Real scalar, the theoretical maximum (unnormalized) graphbetweenness centrality score for graphs with given order and otherparameters.

Related documentation in the C library

centralization_betweenness_tmax().

See Also

Other centralization related:centr_betw(),centr_clo(),centr_clo_tmax(),centr_degree(),centr_degree_tmax(),centr_eigen(),centr_eigen_tmax(),centralize()

Examples

# A BA graph is quite centralizedg <- sample_pa(1000, m = 4)centr_betw(g, normalized = FALSE)$centralization %>%  `/`(centr_betw_tmax(g))centr_betw(g, normalized = TRUE)$centralization

Centralize a graph according to the closeness of vertices

Description

Seecentralize() for a summary of graph centralization.

Usage

centr_clo(graph, mode = c("out", "in", "all", "total"), normalized = TRUE)

Arguments

Value

A named list with the following components:

res

The node-level centrality scores.

centralization

The graph level centrality index.

theoretical_max

The maximum theoretical graph level centralization scorefor a graph with the given number of vertices,using the same parameters.If thenormalized argument wasTRUE,then the result was divided by this number.

Related documentation in the C library

centralization_closeness().

See Also

Other centralization related:centr_betw(),centr_betw_tmax(),centr_clo_tmax(),centr_degree(),centr_degree_tmax(),centr_eigen(),centr_eigen_tmax(),centralize()

Examples

# A BA graph is quite centralizedg <- sample_pa(1000, m = 4)centr_degree(g)$centralizationcentr_clo(g, mode = "all")$centralizationcentr_betw(g, directed = FALSE)$centralizationcentr_eigen(g, directed = FALSE)$centralization

Theoretical maximum for closeness centralization

Description

Seecentralize() for a summary of graph centralization.

Usage

centr_clo_tmax(graph = NULL, nodes = 0, mode = c("out", "in", "all", "total"))

Arguments

Value

Real scalar, the theoretical maximum (unnormalized) graphcloseness centrality score for graphs with given order and otherparameters.

Related documentation in the C library

centralization_closeness_tmax().

See Also

Other centralization related:centr_betw(),centr_betw_tmax(),centr_clo(),centr_degree(),centr_degree_tmax(),centr_eigen(),centr_eigen_tmax(),centralize()

Examples

# A BA graph is quite centralizedg <- sample_pa(1000, m = 4)centr_clo(g, normalized = FALSE)$centralization %>%  `/`(centr_clo_tmax(g))centr_clo(g, normalized = TRUE)$centralization

Centralize a graph according to the degrees of vertices

Description

Seecentralize() for a summary of graph centralization.

Usage

centr_degree(  graph,  mode = c("all", "out", "in", "total"),  loops = TRUE,  normalized = TRUE)

Arguments

Value

A named list with the following components:

res

The node-level centrality scores.

centralization

The graph level centrality index.

theoretical_max

The maximum theoretical graph level centralization scorefor a graph with the given number of vertices,using the same parameters.If thenormalized argument wasTRUE,then the result was divided by this number.

Related documentation in the C library

centralization_degree().

See Also

Other centralization related:centr_betw(),centr_betw_tmax(),centr_clo(),centr_clo_tmax(),centr_degree_tmax(),centr_eigen(),centr_eigen_tmax(),centralize()

Examples

# A BA graph is quite centralizedg <- sample_pa(1000, m = 4)centr_degree(g)$centralizationcentr_clo(g, mode = "all")$centralizationcentr_betw(g, directed = FALSE)$centralizationcentr_eigen(g, directed = FALSE)$centralization

Theoretical maximum for degree centralization

Description

Seecentralize() for a summary of graph centralization.

Usage

centr_degree_tmax(  graph = NULL,  nodes = 0,  mode = c("all", "out", "in", "total"),  loops)

Arguments

Value

Real scalar, the theoretical maximum (unnormalized) graph degreecentrality score for graphs with given order and other parameters.

See Also

Other centralization related:centr_betw(),centr_betw_tmax(),centr_clo(),centr_clo_tmax(),centr_degree(),centr_eigen(),centr_eigen_tmax(),centralize()

Examples

# A BA graph is quite centralizedg <- sample_pa(1000, m = 4)centr_degree(g, normalized = FALSE)$centralization %>%  `/`(centr_degree_tmax(g, loops = FALSE))centr_degree(g, normalized = TRUE)$centralization

Centralize a graph according to the eigenvector centrality of vertices

Description

Seecentralize() for a summary of graph centralization.

Usage

centr_eigen(  graph,  directed = FALSE,  scale = deprecated(),  options = arpack_defaults(),  normalized = TRUE)

Arguments

Value

A named list with the following components:

vector

The node-level centrality scores.

value

The corresponding eigenvalue.

options

ARPACK options, see the return value ofeigen_centrality() for details.

centralization

The graph level centrality index.

theoretical_max

The same as above, the theoretical maximum centralization scorefor a graph with the same number of vertices.

Related documentation in the C library

centralization_eigenvector_centrality().

See Also

Other centralization related:centr_betw(),centr_betw_tmax(),centr_clo(),centr_clo_tmax(),centr_degree(),centr_degree_tmax(),centr_eigen_tmax(),centralize()

Examples

# A BA graph is quite centralizedg <- sample_pa(1000, m = 4)centr_degree(g)$centralizationcentr_clo(g, mode = "all")$centralizationcentr_betw(g, directed = FALSE)$centralizationcentr_eigen(g, directed = FALSE)$centralization# The most centralized graph according to eigenvector centralityg0 <- make_graph(c(2, 1), n = 10, dir = FALSE)g1 <- make_star(10, mode = "undirected")centr_eigen(g0)$centralizationcentr_eigen(g1)$centralization

Theoretical maximum for eigenvector centralization

Description

Seecentralize() for a summary of graph centralization.

Usage

centr_eigen_tmax(  graph = NULL,  nodes = 0,  directed = FALSE,  scale = deprecated())

Arguments

Value

Real scalar, the theoretical maximum (unnormalized) grapheigenvector centrality score for graphs with given vertex count andother parameters.

Related documentation in the C library

centralization_eigenvector_centrality_tmax().

See Also

Other centralization related:centr_betw(),centr_betw_tmax(),centr_clo(),centr_clo_tmax(),centr_degree(),centr_degree_tmax(),centr_eigen(),centralize()

Examples

# A BA graph is quite centralizedg <- sample_pa(1000, m = 4)centr_eigen(g, normalized = FALSE)$centralization %>%  `/`(centr_eigen_tmax(g))centr_eigen(g, normalized = TRUE)$centralization

Centralize a graph according to the betweenness of vertices

Description

centralization.betweenness() was renamed tocentr_betw() to create a moreconsistent API.

Usage

centralization.betweenness(graph, directed = TRUE, normalized = TRUE)

Arguments

Theoretical maximum for betweenness centralization

Description

centralization.betweenness.tmax() was renamed tocentr_betw_tmax() to create a moreconsistent API.

Usage

centralization.betweenness.tmax(graph = NULL, nodes = 0, directed = TRUE)

Arguments

Centralize a graph according to the closeness of vertices

Description

centralization.closeness() was renamed tocentr_clo() to create a moreconsistent API.

Usage

centralization.closeness(  graph,  mode = c("out", "in", "all", "total"),  normalized = TRUE)

Arguments

Theoretical maximum for closeness centralization

Description

centralization.closeness.tmax() was renamed tocentr_clo_tmax() to create a moreconsistent API.

Usage

centralization.closeness.tmax(  graph = NULL,  nodes = 0,  mode = c("out", "in", "all", "total"))

Arguments

Centralize a graph according to the degrees of vertices

Description

centralization.degree() was renamed tocentr_degree() to create a moreconsistent API.

Usage

centralization.degree(  graph,  mode = c("all", "out", "in", "total"),  loops = TRUE,  normalized = TRUE)

Arguments

Theoretical maximum for degree centralization

Description

centralization.degree.tmax() was renamed tocentr_degree_tmax() to create a moreconsistent API.

Usage

centralization.degree.tmax(  graph = NULL,  nodes = 0,  mode = c("all", "out", "in", "total"),  loops = FALSE)

Arguments

Centralize a graph according to the eigenvector centrality of vertices

Description

centralization.evcent() was renamed tocentr_eigen() to create a moreconsistent API.

Usage

centralization.evcent(  graph,  directed = FALSE,  scale = TRUE,  options = arpack_defaults(),  normalized = TRUE)

Arguments

Theoretical maximum for betweenness centralization

Description

centralization.evcent.tmax() was renamed tocentr_eigen_tmax() to create a moreconsistent API.

Usage

centralization.evcent.tmax(  graph = NULL,  nodes = 0,  directed = FALSE,  scale = TRUE)

Arguments

Centralization of a graph

Description

Centralization is a method for creating a graph level centralizationmeasure from the centrality scores of the vertices.

Usage

centralize(scores, theoretical.max = 0, normalized = TRUE)

Arguments

Details

Centralization is a general method for calculating a graph-levelcentrality score based on node-level centrality measure. The formula forthis is

C(G)=\sum_v (\max_w c_w - c_v),

wherec_v is the centrality of vertexv.

The graph-level centralization measure can be normalized by dividing by themaximum theoretical score for a graph with the same number of vertices,using the same parameters, e.g. directedness, whether we consider loopedges, etc.

For degree, closeness and betweenness the most centralized structure issome version of the star graph, in-star, out-star or undirected star.

For eigenvector centrality the most centralized structure is the graphwith a single edge (and potentially many isolates).

centralize() implements general centralization formula to calculatea graph-level score from vertex-level scores.

Value

A real scalar, the centralization of the graph from whichscores were derived.

Related documentation in the C library

centralization().

References

Freeman, L.C. (1979). Centrality in Social Networks I:Conceptual Clarification.Social Networks 1, 215–239.

Wasserman, S., and Faust, K. (1994).Social Network Analysis:Methods and Applications. Cambridge University Press.

See Also

Other centralization related:centr_betw(),centr_betw_tmax(),centr_clo(),centr_clo_tmax(),centr_degree(),centr_degree_tmax(),centr_eigen(),centr_eigen_tmax()

Examples

# A BA graph is quite centralizedg <- sample_pa(1000, m = 4)centr_degree(g)$centralizationcentr_clo(g, mode = "all")$centralizationcentr_eigen(g, directed = FALSE)$centralization# Calculate centralization from pre-computed scoresdeg <- degree(g)tmax <- centr_degree_tmax(g, loops = FALSE)centralize(deg, tmax)# The most centralized graph according to eigenvector centralityg0 <- make_graph(c(2, 1), n = 10, dir = FALSE)g1 <- make_star(10, mode = "undirected")centr_eigen(g0)$centralizationcentr_eigen(g1)$centralization

Centralization of a graph

Description

centralize.scores() was renamed tocentralize() to create a moreconsistent API.

Usage

centralize.scores(scores, theoretical.max = 0, normalized = TRUE)

Arguments

Random citation graphs

Description

cited.type.game() was renamed tosample_cit_types() to create a moreconsistent API.

Usage

cited.type.game(  n,  edges = 1,  types = rep(0, n),  pref = rep(1, length(types)),  directed = TRUE,  attr = TRUE)

Arguments

Random citation graphs

Description

citing.cited.type.game() was renamed tosample_cit_cit_types() to create a moreconsistent API.

Usage

citing.cited.type.game(  n,  edges = 1,  types = rep(0, n),  pref = matrix(1, nrow = length(types), ncol = length(types)),  directed = TRUE,  attr = TRUE)

Arguments

Functions to find cliques, i.e. complete subgraphs in a graph

Description

clique.number() was renamed toclique_num() to create a moreconsistent API.

Usage

clique.number(graph)

Arguments

Functions to find cliques, i.e. complete subgraphs in a graph

Description

These functions find all, the largest or all the maximal cliques in anundirected graph. The size of the largest clique can also be calculated.

Tests if all pairs within a set of vertices are adjacent, i.e. whether theyform a clique. An empty set and singleton set are considered to be a clique.

Usage

cliques(graph, min = 0, max = 0)largest_cliques(graph)max_cliques(graph, min = NULL, max = NULL, subset = NULL, file = NULL)count_max_cliques(graph, min = NULL, max = NULL, subset = NULL)clique_num(graph)largest_weighted_cliques(graph, vertex.weights = NULL)weighted_clique_num(graph, vertex.weights = NULL)clique_size_counts(graph, min = 0, max = 0, maximal = FALSE)is_clique(graph, candidate, directed = FALSE)

Arguments

Details

cliques() find all complete subgraphs in the input graph, obeying thesize limitations given in themin andmax arguments.

largest_cliques() finds all largest cliques in the input graph. Aclique is largest if there is no other clique including more vertices.

max_cliques() finds all maximal cliques in the input graph. Aclique is maximal if it cannot be extended to a larger clique. The largestcliques are always maximal, but a maximal clique is not necessarily thelargest.

count_max_cliques() counts the maximal cliques.

clique_num() calculates the size of the largest clique(s).

clique_size_counts() returns a numeric vector representing a histogramof clique sizes, between the given minimum and maximum clique size.

is_clique() tests whether all pairs within a vertex set are connected.

Value

cliques(),largest_cliques() andclique_num()return a list containing numeric vectors of vertex ids. Each list element isa clique, i.e. a vertex sequence of classigraph.vs.

max_cliques() returnsNULL, invisibly, if itsfileargument is notNULL. The output is written to the specified file inthis case.

clique_num() andcount_max_cliques() return an integerscalar.

clique_size_counts() returns a numeric vector with the clique sizes such thatthe i-th item belongs to cliques of size i. Trailing zeros are currentlytruncated, but this might change in future versions.

is_clique() returnsTRUE if the candidate vertex set formsa clique.

Related documentation in the C library

cliques(),largest_cliques(),clique_number(),largest_weighted_cliques(),weighted_clique_number(),maximal_cliques_hist(),clique_size_hist(),is_clique().

Author(s)

Tamas Nepuszntamas@gmail.com and Gabor Csardicsardi.gabor@gmail.com

References

For maximal cliques the following algorithm is implemented:David Eppstein, Maarten Loffler, Darren Strash: Listing All Maximal Cliquesin Sparse Graphs in Near-optimal Time.https://arxiv.org/abs/1006.5440

See Also

Other cliques:is_complete(),ivs(),weighted_cliques()

Examples

# this usually contains cliques of size sixg <- sample_gnp(100, 0.3)clique_num(g)cliques(g, min = 6)largest_cliques(g)# To have a bit less maximal cliques, about 100-200 usuallyg <- sample_gnp(100, 0.03)max_cliques(g)# Check that all returned vertex sets are indeed cliquesall(sapply(max_cliques(g), function (c) is_clique(g, c)))

Closeness centrality of vertices

Description

Closeness centrality measures how many steps are required to access every othervertex from a given vertex.

Usage

closeness(  graph,  vids = V(graph),  mode = c("out", "in", "all", "total"),  weights = NULL,  normalized = FALSE,  cutoff = -1)

Arguments

Details

The closeness centrality of a vertex is defined as the inverse of thesum of distances to all the other vertices in the graph:

\frac{1}{\sum_{i\ne v} d_{vi}}

If there is no (directed) path between vertexv andi, theni is omitted from the calculation. If no other vertices are reachablefromv, then its closeness is returned as NaN.

cutoff or smaller. This can be run for larger graphs, as the runningtime is not quadratic (ifcutoff is small). Ifcutoff isnegative (which is the default), then the function calculates the exactcloseness scores. Since igraph 1.6.0, acutoff value of zero is treatedliterally, i.e. path with a length greater than zero are ignored.

Closeness centrality is meaningful only for connected graphs. In disconnectedgraphs, consider using the harmonic centrality withharmonic_centrality()

Value

Numeric vector with the closeness values of all the vertices inv.

Author(s)

Gabor Csardicsardi.gabor@gmail.com

References

Freeman, L.C. (1979). Centrality in Social Networks I:Conceptual Clarification.Social Networks, 1, 215-239.

See Also

Centrality measuresalpha_centrality(),authority_score(),betweenness(),diversity(),eigen_centrality(),harmonic_centrality(),hits_scores(),page_rank(),power_centrality(),spectrum(),strength(),subgraph_centrality()

Examples

g <- make_ring(10)g2 <- make_star(10)closeness(g)closeness(g2, mode = "in")closeness(g2, mode = "out")closeness(g2, mode = "all")

Connected components of a graph

Description

cluster.distribution() was renamed tocomponent_distribution() to create a moreconsistent API.

Usage

cluster.distribution(graph, cumulative = FALSE, mul.size = FALSE, ...)

Arguments

Community structure detection based on edge betweenness

Description

Community structure detection based on the betweenness of the edgesin the network. This method is also known as the Girvan-Newmanalgorithm.

Usage

cluster_edge_betweenness(  graph,  weights = NULL,  directed = TRUE,  edge.betweenness = TRUE,  merges = TRUE,  bridges = TRUE,  modularity = TRUE,  membership = TRUE)

Arguments

Details

The idea behind this method is that the betweenness of the edges connectingtwo communities is typically high, as many of the shortest paths betweenvertices in separate communities pass through them. The algorithmsuccessively removes edges with the highest betweenness, recalculatingbetweenness values after each removal. This way eventually the network splitsinto two components, then one of these components splits again, and so on,until all edges are removed. The resulting hierarhical partitioning of thevertices can be encoded as a dendrogram.

cluster_edge_betweenness() returns various information collectedthrough the run of the algorithm. Specifically,removed.edges containsthe edge IDs in order of the edges' removal;edge.betweenness containsthe betweenness of each of these at the time of their removal; andbridges contains the IDs of edges whose removal caused a split.

Value

cluster_edge_betweenness() returns acommunities() object, please see thecommunities()manual page for details.

Author(s)

Gabor Csardicsardi.gabor@gmail.com

References

M Newman and M Girvan: Finding and evaluating communitystructure in networks,Physical Review E 69, 026113 (2004)

See Also

edge_betweenness() for the definition and calculationof the edge betweenness,cluster_walktrap(),cluster_fast_greedy(),cluster_leading_eigen() for other community detectionmethods.

Seecommunities() for extracting the results of the communitydetection.

Community detectionas_membership(),cluster_fast_greedy(),cluster_fluid_communities(),cluster_infomap(),cluster_label_prop(),cluster_leading_eigen(),cluster_leiden(),cluster_louvain(),cluster_optimal(),cluster_spinglass(),cluster_walktrap(),compare(),groups(),make_clusters(),membership(),modularity.igraph(),plot_dendrogram(),split_join_distance(),voronoi_cells()

Examples

g <- sample_pa(100, m = 2, directed = FALSE)eb <- cluster_edge_betweenness(g)g <- make_full_graph(10) %du% make_full_graph(10)g <- add_edges(g, c(1, 11))eb <- cluster_edge_betweenness(g)eb

Community structure via greedy optimization of modularity

Description

This function tries to find dense subgraph, also called communities ingraphs via directly optimizing a modularity score.

Usage

cluster_fast_greedy(  graph,  merges = TRUE,  modularity = TRUE,  membership = TRUE,  weights = NULL)

Arguments

Details

This function implements the fast greedy modularity optimization algorithmfor finding community structure, see A Clauset, MEJ Newman, C Moore: Findingcommunity structure in very large networks,http://www.arxiv.org/abs/cond-mat/0408187 for the details.

Value

cluster_fast_greedy() returns acommunities()object, please see thecommunities() manual page for details.

Author(s)

Tamas Nepuszntamas@gmail.com and Gabor Csardicsardi.gabor@gmail.com for the R interface.

References

A Clauset, MEJ Newman, C Moore: Finding community structure invery large networks, http://www.arxiv.org/abs/cond-mat/0408187

See Also

communities() for extracting the results.

See alsocluster_walktrap(),cluster_spinglass(),cluster_leading_eigen() andcluster_edge_betweenness(),cluster_louvain()cluster_leiden() for other methods.

Community detectionas_membership(),cluster_edge_betweenness(),cluster_fluid_communities(),cluster_infomap(),cluster_label_prop(),cluster_leading_eigen(),cluster_leiden(),cluster_louvain(),cluster_optimal(),cluster_spinglass(),cluster_walktrap(),compare(),groups(),make_clusters(),membership(),modularity.igraph(),plot_dendrogram(),split_join_distance(),voronoi_cells()

Examples

g <- make_full_graph(5) %du% make_full_graph(5) %du% make_full_graph(5)g <- add_edges(g, c(1, 6, 1, 11, 6, 11))fc <- cluster_fast_greedy(g)membership(fc)sizes(fc)

Community detection algorithm based on interacting fluids

Description

The algorithm detects communities based on the simple idea ofseveral fluids interacting in a non-homogeneous environment(the graph topology), expanding and contracting based on theirinteraction and density.

Usage

cluster_fluid_communities(graph, no.of.communities)

Arguments

Value

cluster_fluid_communities() returns acommunities()object, please see thecommunities() manual page for details.

Author(s)

Ferran Parés

References

Parés F, Gasulla DG, et. al. (2018) Fluid Communities: A Competitive,Scalable and Diverse Community Detection Algorithm. In: Complex Networks& Their Applications VI: Proceedings of Complex Networks 2017 (The SixthInternational Conference on Complex Networks and Their Applications),Springer, vol 689, p 229, doi: 10.1007/978-3-319-72150-7_19

See Also

Seecommunities() for extracting the membership,modularity scores, etc. from the results.

Other community detection algorithms:cluster_walktrap(),cluster_spinglass(),cluster_leading_eigen(),cluster_edge_betweenness(),cluster_fast_greedy(),cluster_label_prop()cluster_louvain(),cluster_leiden()

Community detectionas_membership(),cluster_edge_betweenness(),cluster_fast_greedy(),cluster_infomap(),cluster_label_prop(),cluster_leading_eigen(),cluster_leiden(),cluster_louvain(),cluster_optimal(),cluster_spinglass(),cluster_walktrap(),compare(),groups(),make_clusters(),membership(),modularity.igraph(),plot_dendrogram(),split_join_distance(),voronoi_cells()

Examples

g <- make_graph("Zachary")comms <- cluster_fluid_communities(g, 2)

Infomap community finding

Description

Find community structure that minimizes the expected description length of arandom walker trajectory. If the graph is directed, edge directions willbe taken into account.

Usage

cluster_infomap(  graph,  e.weights = NULL,  v.weights = NULL,  nb.trials = 10,  modularity = TRUE)

Arguments

Details

Please see the details of this method in the references given below.

Value

cluster_infomap() returns acommunities() object,please see thecommunities() manual page for details.

Author(s)

Martin Rosvall wrote the original C++ code. This was ported tobe more igraph-like by Emmanuel Navarro. The R interface andsome cosmetics was done by Gabor Csardicsardi.gabor@gmail.com.

References

The original paper: M. Rosvall and C. T. Bergstrom, Maps ofinformation flow reveal community structure in complex networks,PNAS105, 1118 (2008)doi:10.1073/pnas.0706851105,https://arxiv.org/abs/0707.0609

A more detailed paper: M. Rosvall, D. Axelsson, and C. T. Bergstrom, The mapequation,Eur. Phys. J. Special Topics 178, 13 (2009).doi:10.1140/epjst/e2010-01179-1,https://arxiv.org/abs/0906.1405.

See Also

Other community finding methods andcommunities().

Community detectionas_membership(),cluster_edge_betweenness(),cluster_fast_greedy(),cluster_fluid_communities(),cluster_label_prop(),cluster_leading_eigen(),cluster_leiden(),cluster_louvain(),cluster_optimal(),cluster_spinglass(),cluster_walktrap(),compare(),groups(),make_clusters(),membership(),modularity.igraph(),plot_dendrogram(),split_join_distance(),voronoi_cells()

Examples

## Zachary's karate clubg <- make_graph("Zachary")imc <- cluster_infomap(g)membership(imc)communities(imc)

Finding communities based on propagating labels

Description

This is a fast, nearly linear time algorithm for detecting communitystructure in networks. In works by labeling the vertices with unique labelsand then updating the labels by majority voting in the neighborhood of thevertex.

Usage

cluster_label_prop(  graph,  weights = NULL,  ...,  mode = c("out", "in", "all"),  initial = NULL,  fixed = NULL)

Arguments

Details

This function implements the community detection method described in:Raghavan, U.N. and Albert, R. and Kumara, S.: Near linear time algorithm todetect community structures in large-scale networks. Phys Rev E 76, 036106.(2007). This version extends the original method by the ability to take edgeweights into consideration and also by allowing some labels to be fixed.

From the abstract of the paper: “In our algorithm every node isinitialized with a unique label and at every step each node adopts the labelthat most of its neighbors currently have. In this iterative process denselyconnected groups of nodes form a consensus on a unique label to formcommunities.”

Value

cluster_label_prop() returns acommunities() object, please see thecommunities()manual page for details.

Author(s)

Tamas Nepuszntamas@gmail.com for the C implementation,Gabor Csardicsardi.gabor@gmail.com for this manual page.

References

Raghavan, U.N. and Albert, R. and Kumara, S.: Near linear timealgorithm to detect community structures in large-scale networks.PhysRev E 76, 036106. (2007)

See Also

communities() for extracting the actual results.

cluster_fast_greedy(),cluster_walktrap(),cluster_spinglass(),cluster_louvain() andcluster_leiden() for other community detection methods.

Community detectionas_membership(),cluster_edge_betweenness(),cluster_fast_greedy(),cluster_fluid_communities(),cluster_infomap(),cluster_leading_eigen(),cluster_leiden(),cluster_louvain(),cluster_optimal(),cluster_spinglass(),cluster_walktrap(),compare(),groups(),make_clusters(),membership(),modularity.igraph(),plot_dendrogram(),split_join_distance(),voronoi_cells()

Examples

g <- sample_gnp(10, 5 / 10) %du% sample_gnp(9, 5 / 9)g <- add_edges(g, c(1, 12))cluster_label_prop(g)

Community structure detecting based on the leading eigenvector of thecommunity matrix

Description

This function tries to find densely connected subgraphs in a graph bycalculating the leading non-negative eigenvector of the modularity matrix ofthe graph.

Usage

cluster_leading_eigen(  graph,  steps = -1,  weights = NULL,  start = NULL,  options = arpack_defaults(),  callback = NULL,  extra = NULL,  env = parent.frame())

Arguments

Details

The function documented in these section implements the ‘leadingeigenvector’ method developed by Mark Newman, see the reference below.

The heart of the method is the definition of the modularity matrix,B, which isB=A-P,A being the adjacency matrix of the(undirected) network, andP contains the probability that certainedges are present according to the ‘configuration model’. In otherwords, aP[i,j] element ofP is the probability that there isan edge between verticesi andj in a random network in whichthe degrees of all vertices are the same as in the input graph.

The leading eigenvector method works by calculating the eigenvector of themodularity matrix for the largest positive eigenvalue and then separatingvertices into two community based on the sign of the corresponding elementin the eigenvector. If all elements in the eigenvector are of the same signthat means that the network has no underlying comuunity structure. CheckNewman's paper to understand why this is a good method for detectingcommunity structure.

Value

cluster_leading_eigen() returns a named list with thefollowing members:

membership

The membership vector at the end of the algorithm,when no more splits are possible.

merges

The merges matrix starting from the statedescribed by themembership member.This is a two-column matrix and each line describes a merge of two communities,the first line is the first merge and it creates community ‘N’,N is the number of initial communities in the graph,the second line creates communityN+1, etc.

options

Information about the underlying ARPACK computation, seearpack() for details.

Callback functions

Thecallback argument can be used tosupply a function that is called after each eigenvector calculation. Thefollowing arguments are supplied to this function:

membership

The actual membership vector, with zero-based indexing.

community

The community that the algorithm just tried to split, community numbering starts with zero here.

value

The eigenvalue belonging to the leading eigenvector the algorithm just found.

vector

The leading eigenvector the algorithm just found.

multiplier

An R function that can be used to multiple the actual modularity matrixwith an arbitrary vector.Supply the vector as an argument to perform this multiplication.This function can be used with ARPACK.

extra

Theextra argument that was passed tocluster_leading_eigen().

The callback function should return a scalar number. If this numberis non-zero, then the clustering is terminated.

Author(s)

Gabor Csardicsardi.gabor@gmail.com

References

MEJ Newman: Finding community structure using the eigenvectorsof matrices, Physical Review E 74 036104, 2006.

See Also

modularity(),cluster_walktrap(),cluster_edge_betweenness(),cluster_fast_greedy(),as.dendrogram()

Community detectionas_membership(),cluster_edge_betweenness(),cluster_fast_greedy(),cluster_fluid_communities(),cluster_infomap(),cluster_label_prop(),cluster_leiden(),cluster_louvain(),cluster_optimal(),cluster_spinglass(),cluster_walktrap(),compare(),groups(),make_clusters(),membership(),modularity.igraph(),plot_dendrogram(),split_join_distance(),voronoi_cells()

Examples

g <- make_full_graph(5) %du% make_full_graph(5) %du% make_full_graph(5)g <- add_edges(g, c(1, 6, 1, 11, 6, 11))lec <- cluster_leading_eigen(g)leccluster_leading_eigen(g, start = membership(lec))

Finding community structure of a graph using the Leiden algorithm of Traag,van Eck & Waltman.

Description

The Leiden algorithm is similar to the Louvain algorithm,cluster_louvain(), but it is faster and yields higher qualitysolutions. It can optimize both modularity and the Constant Potts Model,which does not suffer from the resolution-limit (see preprinthttps://arxiv.org/abs/1104.3083).

Usage

cluster_leiden(  graph,  objective_function = c("CPM", "modularity"),  ...,  weights = NULL,  resolution = 1,  resolution_parameter = deprecated(),  beta = 0.01,  initial_membership = NULL,  n_iterations = 2,  vertex_weights = NULL)

Arguments

Details

The Leiden algorithm consists of three phases: (1) local moving of nodes,(2) refinement of the partition and (3) aggregation of the network based onthe refined partition, using the non-refined partition to create an initialpartition for the aggregate network. In the local move procedure in theLeiden algorithm, only nodes whose neighborhood has changed are visited. Therefinement is done by restarting from a singleton partition within eachcluster and gradually merging the subclusters. When aggregating, a singlecluster may then be represented by several nodes (which are the subclustersidentified in the refinement).

The Leiden algorithm provides several guarantees. The Leiden algorithm istypically iterated: the output of one iteration is used as the input for thenext iteration. At each iteration all clusters are guaranteed to beconnected and well-separated. After an iteration in which nothing haschanged, all nodes and some parts are guaranteed to be locally optimallyassigned. Finally, asymptotically, all subsets of all clusters areguaranteed to be locally optimally assigned. For more details, please seeTraag, Waltman & van Eck (2019).

The objective function being optimized is

\frac{1}{2m} \sum_{ij} (A_{ij} - \gamma n_i n_j)\delta(\sigma_i, \sigma_j)

wherem is the total edge weight,A_{ij} is the weightof edge(i, j),\gamma is the so-called resolutionparameter,n_i is the node weight of nodei,\sigma_iis the cluster of nodei and\delta(x, y) = 1 if andonly ifx = y and0 otherwise. By settingn_i = k_i, thedegree of nodei, and dividing\gamma by2m, youeffectively obtain an expression for modularity.

Hence, the standard modularity will be optimized when you supply the degreesasvertex_weights and by supplying as a resolution parameter\frac{1}{2m}, withm the number of edges. If you do notspecify anyvertex_weights, the correct vertex weights and scaling of\gamma is determined automatically by theobjective_function argument.

Value

cluster_leiden() returns acommunities()object, please see thecommunities() manual page for details.

Author(s)

Vincent Traag

References

Traag, V. A., Waltman, L., & van Eck, N. J. (2019). From Louvainto Leiden: guaranteeing well-connected communities. Scientificreports, 9(1), 5233. doi: 10.1038/s41598-019-41695-z, arXiv:1810.08473v3 [cs.SI]

See Also

Seecommunities() for extracting the membership,modularity scores, etc. from the results.

Other community detection algorithms:cluster_walktrap(),cluster_spinglass(),cluster_leading_eigen(),cluster_edge_betweenness(),cluster_fast_greedy(),cluster_label_prop()cluster_louvain()cluster_fluid_communities()cluster_infomap()cluster_optimal()cluster_walktrap()

Community detectionas_membership(),cluster_edge_betweenness(),cluster_fast_greedy(),cluster_fluid_communities(),cluster_infomap(),cluster_label_prop(),cluster_leading_eigen(),cluster_louvain(),cluster_optimal(),cluster_spinglass(),cluster_walktrap(),compare(),groups(),make_clusters(),membership(),modularity.igraph(),plot_dendrogram(),split_join_distance(),voronoi_cells()

Examples

g <- make_graph("Zachary")# By default CPM is usedr <- quantile(strength(g))[2] / (gorder(g) - 1)# Set seed for sake of reproducibilityset.seed(1)ldc <- cluster_leiden(g, resolution = r)print(ldc)plot(ldc, g)

Finding community structure by multi-level optimization of modularity

Description

This function implements the multi-level modularity optimization algorithmfor finding community structure, see references below. It is based on themodularity measure and a hierarchical approach.

Usage

cluster_louvain(graph, weights = NULL, resolution = 1)

Arguments

Details

This function implements the multi-level modularity optimization algorithmfor finding community structure, see VD Blondel, J-L Guillaume, R Lambiotteand E Lefebvre: Fast unfolding of community hierarchies in large networks,https://arxiv.org/abs/0803.0476 for the details.

It is based on the modularity measure and a hierarchical approach.Initially, each vertex is assigned to a community on its own. In every step,vertices are re-assigned to communities in a local, greedy way: each vertexis moved to the community with which it achieves the highest contribution tomodularity. When no vertices can be reassigned, each community is considereda vertex on its own, and the process starts again with the mergedcommunities. The process stops when there is only a single vertex left orwhen the modularity cannot be increased any more in a step. Since igraph 1.3,vertices are processed in a random order.

This function was contributed by Tom Gregorovic.

Value

cluster_louvain() returns acommunities()object, please see thecommunities() manual page for details.

Author(s)

Tom Gregorovic, Tamas Nepuszntamas@gmail.com

References

Vincent D. Blondel, Jean-Loup Guillaume, Renaud Lambiotte,Etienne Lefebvre: Fast unfolding of communities in large networks. J. Stat.Mech. (2008) P10008

See Also

Seecommunities() for extracting the membership,modularity scores, etc. from the results.

Other community detection algorithms:cluster_walktrap(),cluster_spinglass(),cluster_leading_eigen(),cluster_edge_betweenness(),cluster_fast_greedy(),cluster_label_prop()cluster_leiden()

Community detectionas_membership(),cluster_edge_betweenness(),cluster_fast_greedy(),cluster_fluid_communities(),cluster_infomap(),cluster_label_prop(),cluster_leading_eigen(),cluster_leiden(),cluster_optimal(),cluster_spinglass(),cluster_walktrap(),compare(),groups(),make_clusters(),membership(),modularity.igraph(),plot_dendrogram(),split_join_distance(),voronoi_cells()

Examples

# This is so simple that we will have only one levelg <- make_full_graph(5) %du% make_full_graph(5) %du% make_full_graph(5)g <- add_edges(g, c(1, 6, 1, 11, 6, 11))cluster_louvain(g)

Optimal community structure

Description

This function calculates the optimal community structure of a graph, bymaximizing the modularity measure over all possible partitions.

Usage

cluster_optimal(graph, weights = NULL)

Arguments

Details

This function calculates the optimal community structure for a graph, interms of maximal modularity score.

The calculation is done by transforming the modularity maximization into aninteger programming problem, and then calling the GLPK library to solvethat. Please the reference below for details.

Note that modularity optimization is an NP-complete problem, and all knownalgorithms for it have exponential time complexity. This means that youprobably don't want to run this function on larger graphs. Graphs with up tofifty vertices should be fine, graphs with a couple of hundred verticesmight be possible.

Value

cluster_optimal() returns acommunities() object,please see thecommunities() manual page for details.

Examples

## Zachary's karate clubg <- make_graph("Zachary")## We put everything into a big 'try' block, in case## igraph was compiled without GLPK support## The calculation only takes a couple of secondsoc <- cluster_optimal(g)## Double check the resultprint(modularity(oc))print(modularity(g, membership(oc)))## Compare to the greedy optimizerfc <- cluster_fast_greedy(g)print(modularity(fc))

Author(s)

Gabor Csardicsardi.gabor@gmail.com

References

Ulrik Brandes, Daniel Delling, Marco Gaertler, Robert Gorke,Martin Hoefer, Zoran Nikoloski, Dorothea Wagner: On Modularity Clustering,IEEE Transactions on Knowledge and Data Engineering 20(2):172-188,2008.

See Also

communities() for the documentation of the result,modularity(). See alsocluster_fast_greedy() for afast greedy optimizer.

Community detectionas_membership(),cluster_edge_betweenness(),cluster_fast_greedy(),cluster_fluid_communities(),cluster_infomap(),cluster_label_prop(),cluster_leading_eigen(),cluster_leiden(),cluster_louvain(),cluster_spinglass(),cluster_walktrap(),compare(),groups(),make_clusters(),membership(),modularity.igraph(),plot_dendrogram(),split_join_distance(),voronoi_cells()

Finding communities in graphs based on statistical meachanics

Description

This function tries to find communities in graphs via a spin-glass model andsimulated annealing.

Usage

cluster_spinglass(  graph,  weights = NULL,  vertex = NULL,  spins = 25,  parupdate = FALSE,  start.temp = 1,  stop.temp = 0.01,  cool.fact = 0.99,  update.rule = c("config", "random", "simple"),  gamma = 1,  implementation = c("orig", "neg"),  gamma.minus = 1)

Arguments