graph.adjacency            package:igraph            R Documentation

_C_r_e_a_t_e _g_r_a_p_h_s _f_r_o_m _a_d_j_a_c_e_n_c_y _m_a_t_r_i_c_e_s

_D_e_s_c_r_i_p_t_i_o_n:

     'graph.adjacency' is a flexible function for creating 'igraph'
     graphs from adjacency matrices.

_U_s_a_g_e:

     graph.adjacency(adjmatrix, mode=c("directed", "undirected", "max",
             "min", "upper", "lower", "plus"), weighted=NULL, diag=TRUE,
             add.colnames=NULL, add.rownames=NA)

_A_r_g_u_m_e_n_t_s:

adjmatrix: A square adjacency matrix. From igraph version 0.5.1 this
          can be a sparse matrix created with the 'Matrix' package.

    mode: Character scalar, specifies how igraph should interpret the
          supplied matrix. See also the 'weighted' argument, the
          interpretation depends on that too. Possible values are:
          'directed', 'undirected', 'upper', 'lower', 'max', 'min',
          'plus'. See details below. 

weighted: This argument specifies whether to create a weighted graph
          from an adjacency matrix. If it is 'NULL' then an unweighted
          graph is created and the elements of the adjacency matrix
          gives the number of edges between the vertices. If it is a
          character constant then for every non-zero matrix entry an
          edge is created and the value of the entry is added as an
          edge attribute named by the 'weighted' argument. If it is
          'TRUE' then a weighted graph is created and the name of the
          edge attribute will be 'weight'. See also details below. 

    diag: Logical scalar, whether to include the diagonal of the matrix
          in the calculation. If this is 'FALSE' then the diagonal is
          zero-d out first. 

add.colnames: Character scalar, whether to add the column names as
          vertex attributes. If it is ''NULL'' (the default) then, if
          present, column names are added as vertex attribute 'name'.
          If ''NA'' then they will not be added. If a character
          constant, then it gives the name of the vertex attribute to
          add.

add.rownames: Character scalar, whether to add the row names as vertex
          attributes. Possible values the same as the previous
          argument. By default row names are not added. If
          ''add.rownames'' and ''add.colnames'' specify the same vertex
          attribute, then the former is ignored. 

_D_e_t_a_i_l_s:

     'graph.adjacency' creates a graph from an adjacency matrix.

     The order of the vertices are preserved, i.e. the vertex
     corresponding to the first row will be vertex 0 in the graph, etc.

     'graph.adjacency' operates in two main modes, depending on the
     'weighted' argument.

     If this argument is 'NULL' then an unweighted graph is created and
     an element of the adjacency matrix gives the number of edges to
     create between the two corresponding vertices. The details depend
     on the value of the 'mode' argument:

   '_d_i_r_e_c_t_e_d' The graph will be directed and a matrix element gives the
        number of edges between two vertices.

   '_u_n_d_i_r_e_c_t_e_d' This is exactly the same as 'max', for convenience.
        Note that it is _not_ checked whether the matrix is symmetric. 

   '_m_a_x' An undirected graph will be created and 'max(A(i,j), A(j,i))'
        gives the number of edges.

   '_u_p_p_e_r' An undirected graph will be created, only the upper right
        triangle (including the diagonal) is used for the number of
        edges.

   '_l_o_w_e_r' An undirected graph will be created, only the lower left
        triangle (including the diagonal) is used for creating the
        edges.

   '_m_i_n' undirected graph will be created with 'min(A(i,j), A(j,i))'
        edges between vertex 'i' and 'j'.

   '_p_l_u_s' undirected graph will be created with 'A(i,j)+A(j,i)' edges
        between vertex 'i' and 'j'.  

     If the 'weighted' argument is not 'NULL' then the elements of the
     matrix give the weights of the edges (if they are not zero). The
     details depend on the value of the 'mode' argument:

   '_d_i_r_e_c_t_e_d' The graph will be directed and a matrix element gives the
        edge weights.

   '_u_n_d_i_r_e_c_t_e_d' First we check that the matrix is symmetric. It is an
        error if not. Then only the upper triangle is used to create a
        weighted undirected graph.

   '_m_a_x' An undirected graph will be created and 'max(A(i,j), A(j,i))'
        gives the edge weights.

   '_u_p_p_e_r' An undirected graph will be created, only the upper right
        triangle (including the diagonal) is used (for the edge
        weights).

   '_l_o_w_e_r' An undirected graph will be created, only the lower left
        triangle (including the diagonal) is used for creating the
        edges.

   '_m_i_n' An undirected graph will be created, 'min(A(i,j), A(j,i))'
        gives the edge weights.

   '_p_l_u_s' An undirected graph will be created, 'A(i,j)+A(j,i)' gives
        the edge weights.

_V_a_l_u_e:

     An igraph graph object.

_A_u_t_h_o_r(_s):

     Gabor Csardi csardi@rmki.kfki.hu

_S_e_e _A_l_s_o:

     graph and 'graph.formula' for other ways to create graphs.

_E_x_a_m_p_l_e_s:

     adjm <- matrix(sample(0:1, 100, replace=TRUE, prob=c(0.9,0.1)), nc=10)
     g1 <- graph.adjacency( adjm )
     adjm <- matrix(sample(0:5, 100, replace=TRUE,
                           prob=c(0.9,0.02,0.02,0.02,0.02,0.02)), nc=10)
     g2 <- graph.adjacency(adjm, weighted=TRUE)
     E(g2)$weight

     ## various modes for weighted graphs, with some tests
     nzs <- function(x) sort(x [x!=0])
     adjm <- matrix(runif(100), 10)
     adjm[ adjm<0.5 ] <- 0
     g3 <- graph.adjacency((adjm + t(adjm))/2, weighted=TRUE,
                           mode="undirected") 

     g4 <- graph.adjacency(adjm, weighted=TRUE, mode="max")
     all(nzs(pmax(adjm, t(adjm))[upper.tri(adjm)]) == sort(E(g4)$weight))

     g5 <- graph.adjacency(adjm, weighted=TRUE, mode="min")
     all(nzs(pmin(adjm, t(adjm))[upper.tri(adjm)]) == sort(E(g5)$weight))

     g6 <- graph.adjacency(adjm, weighted=TRUE, mode="upper")
     all(nzs(adjm[upper.tri(adjm)]) == sort(E(g6)$weight))

     g7 <- graph.adjacency(adjm, weighted=TRUE, mode="lower")
     all(nzs(adjm[lower.tri(adjm)]) == sort(E(g7)$weight))

     g8 <- graph.adjacency(adjm, weighted=TRUE, mode="plus")
     d2 <- function(x) { diag(x) <- diag(x)/2; x }
     all(nzs((d2(adjm+t(adjm)))[lower.tri(adjm)]) == sort(E(g8)$weight))

     g9 <- graph.adjacency(adjm, weighted=TRUE, mode="plus", diag=FALSE)
     d0 <- function(x) { diag(x) <- 0 }
     all(nzs((d0(adjm+t(adjm)))[lower.tri(adjm)]) == sort(E(g9)$weight))

     ## row/column names
     rownames(adjm) <- sample(letters, nrow(adjm))
     colnames(adjm) <- seq(ncol(adjm))
     g10 <- graph.adjacency(adjm, weighted=TRUE, add.rownames="code")
     summary(g10)

