graph.constructors          package:igraph          R Documentation

_V_a_r_i_o_u_s _m_e_t_h_o_d_s _f_o_r _c_r_e_a_t_i_n_g _g_r_a_p_h_s

_D_e_s_c_r_i_p_t_i_o_n:

     These method can create various (mostly regular) graphs: empty
     graphs, graphs with the given edges, graphs from adjacency
     matrices, star graphs, lattices, rings, trees.

_U_s_a_g_e:

     graph.empty(n=0, directed=TRUE)
     graph(edges, n=max(edges)+1, directed=TRUE)
     graph.star(n, mode = "in", center = 0)
     graph.lattice(dimvector, nei = 1, directed = FALSE, mutual = FALSE, 
                   circular = FALSE)
     graph.lattice(length, dim, nei = 1, directed = FALSE, mutual = FALSE,
                   circular = FALSE)
     graph.ring(n, directed = FALSE, mutual = FALSE, circular=TRUE)
     graph.tree(n, children = 2, mode="out")
     graph.full(n, directed = FALSE, loops = FALSE)
     graph.full.citation(n, directed = TRUE)
     graph.atlas(n)
     graph.edgelist(el, directed=TRUE)
     graph.extended.chordal.ring(n, w)

_A_r_g_u_m_e_n_t_s:

   edges: Numeric vector defining the edges, the first edge points from
          the first element to the second, the second edge from the
          third to the fourth, etc.

directed: Logical, if TRUE a directed graph will be created. Note that
          for while most constructors the default is TRUE, for
          'graph.lattice' and 'graph.ring' it is FALSE. For
          'graph.star' the 'mode' argument should be used for creating
          an undirected graph.

       n: The number of vertices in the graph for most functions.

          For 'graph' this parameter is ignored if there is a bigger
          vertex id in 'edges'. This means that for this function it is
          safe to supply zero here if the vertex with the largest id is
          not an isolate.

          For 'graph.atlas' this is the number (id) of the graph to
          create.  

    mode: For 'graph.star' it defines the direction of the edges, 'in':
          the edges point _to_ the center, 'out': the edges point
          _from_ the center, 'undirected': the edges are undirected.

          For 'igraph.tree' this parameter defines the direction of the
          edges. 'out' indicates that the edges point from the parent
          to the children, 'in' indicates that they point from the
          children to their parents, while 'undirected' creates an
          undirected graph.  

  center: For 'graph.star' the center vertex of the graph, by default
          the first vertex.

dimvector: A vector giving the size of the lattice in each dimension,
          for 'graph.lattice'.

     nei: The distance within which (inclusive) the neighbors on the
          lattice will be connected. This parameter is not used right
          now.

  mutual: Logical, if TRUE directed lattices will be mutually
          connected.

circular: Logical, if TRUE the lattice or ring will be circular.

  length: Integer constant, for regular lattices, the size of the
          lattice in each dimension.

     dim: Integer constant, the dimension of the lattice.

children: Integer constant, the number of children of a vertex (except
          for leafs) for 'graph.tree'.

   loops: If TRUE also loops edges (self edges) are added.

   graph: An object.

      el: An edge list, a two column matrix, character or numeric. See
          details below.

       w: A matrix which specifies the extended chordal ring. See
          details below.

_D_e_t_a_i_l_s:

     All these functions create graphs in a deterministic way.

     'graph.empty' is the simplest one, this creates an empty graph.

     'graph' creates a graph with the given edges.

     'graph.star' creates a star graph, in this every single vertex is
     connected to the center vertex and nobody else.

     'graph.lattice' is a flexible function, it can create lattices of
     arbitrary dimensions, periodic or unperiodic ones.

     'graph.ring' is actually a special case of 'graph.lattice', it
     creates a one dimensional circular lattice.

     'graph.tree' creates regular trees.

     'graph.full' simply creates full graphs.

     'graph.full.citation' creates a full citation graph. This is a
     directed graph, where every i->j edge is present if and only if
     j<i. If 'directed=FALSE' then the graph is just a full graph.

     'graph.atlas' creates graphs from the book An Atlas of Graphs by
     Roland C. Read and Robin J. Wilson. The atlas contains all
     undirected graphs with up to seven vertices, numbered from 0 up to
     1252. The graphs are listed: 

        1.  in increasing order of number of nodes;

        2.  for a fixed number of nodes, in increasing order of the
           number of edges;

        3.  for fixed numbers of nodes and edges, in increasing order
           of the degree sequence, for example 111223 < 112222;

        4.  for fixed degree sequence, in increasing number of
           automorphisms.

     'graph.edgelist' creates a graph from an edge list. Its argument
     is a two-column matrix, each row defines one edge. If it is  a
     numeric matrix then its elements are interpreted as vertex ids. If
     it is a character matrix then it is interpreted as symbolic vertex
     names and a vertex id will be assigned to each name, and also a
     'name' vertex attribute will be added.

     'graph.extended.chordal.ring' creates an extended chordal ring. An
     extended chordal ring is regular graph, each node has the same
     degree. It can be obtained from a simple ring by adding some extra
     edges specified by a matrix. Let p denote the number of columns in
     the ''W'' matrix. The extra edges of vertex 'i' are added
     according to column 'i mod p' in ''W''. The number of extra edges
     is the number of rows in ''W'': for each row 'j' an edge
     'i->i+w[ij]' is added if 'i+w[ij]' is less than the number of
     total nodes. See also Kotsis, G: Interconnection Topologies for
     Parallel Processing Systems, PARS Mitteilungen 11, 1-6, 1993.

_V_a_l_u_e:

     Every function documented here returns a 'graph' object.

_A_u_t_h_o_r(_s):

     Gabor Csardi csardi@rmki.kfki.hu

_S_e_e _A_l_s_o:

     'graph.adjacency' to create graphs from adjacency matrices,
     'graph.formula' for a handy way to create small graphs,
     'graph.data.frame' for an easy way to create graphs with many
     edge/vertex attributes.

_E_x_a_m_p_l_e_s:

     g1 <- graph.empty()
     g2 <- graph( c(1,2,2,3,3,4,5,6), directed=FALSE )
     g5 <- graph.star(10, mode="out")
     g6 <- graph.lattice(c(5,5,5))
     g7 <- graph.lattice(length=5, dim=3)
     g8 <- graph.ring(10)
     g9 <- graph.tree(10, 2)
     g10 <- graph.full(5, loops=TRUE)
     g11 <- graph.full.citation(10)
     g12 <- graph.atlas(sample(0:1252, 1))
     el <- matrix( c("foo", "bar", "bar", "foobar"), nc=2, byrow=TRUE)
     g13 <- graph.edgelist(el)
     g15 <- graph.extended.chordal.ring(15, matrix(c(3,12,4,7,8,11), nr=2))

