lsparseMatrix-classes         package:Matrix         R Documentation

_S_p_a_r_s_e _l_o_g_i_c_a_l _m_a_t_r_i_c_e_s

_D_e_s_c_r_i_p_t_i_o_n:

     The 'lsparseMatrix' class is a virtual class of sparse matrices
     with 'TRUE'/'FALSE' entries.  Only the positions of the elements
     that are 'TRUE' are stored.  These can be stored in the
     ``triplet'' form (classes 'lgTMatrix', 'lsTMatrix', and
     'ltTMatrix' which really contain pairs, not triplets) or in
     compressed column-oriented form (classes 'lgCMatrix', 'lsCMatrix',
     and 'ltCMatrix') or in compressed row-oriented form (classes
     'lgRMatrix', 'lsRMatrix', and 'ltRMatrix').  The second letter in
     the name of these non-virtual classes indicates 'g'eneral,
     's'ymmetric, or 't'riangular.

_O_b_j_e_c_t_s _f_r_o_m _t_h_e _C_l_a_s_s:

     Objects can be created by calls of the form 'new("lgCMatrix",
     ...)' and so on.  More frequently objects are created by coercion
     of a numeric sparse matrix to the logical form for use in the
     symbolic analysis phase of an algorithm involving sparse matrices.
      Such algorithms often involve two phases: a symbolic phase
     wherein the positions of the non-zeros in the result are
     determined and a numeric phase wherein the actual results are
     calculated.  During the symbolic phase only the positions of the
     non-zero elements in any operands are of interest, hence any
     numeric sparse matrices can be treated as logical sparse matrices.

_S_l_o_t_s:


     '_x': Object of class '"logical"', i.e., either 'TRUE', 'NA', or
          'FALSE'.

     '_u_p_l_o': Object of class '"character"'. Must be either "U", for
          upper triangular, and "L", for lower triangular. Present in
          the triangular and symmetric classes but not in the general
          class.

     '_d_i_a_g': Object of class '"character"'. Must be either '"U"', for
          unit triangular (diagonal is all ones), or '"N"' for
          non-unit.  The implicit diagonal elements are not explicitly
          stored when 'diag' is '"U"'.  Present in the triangular
          classes only.

     '_p': Object of class '"integer"' of pointers, one for each column
          (row), to the initial (zero-based) index of elements in the
          column.  Present in compressed column-oriented and compressed
          row-oriented forms only.

     '_i': Object of class '"integer"' of length nnzero (number of
          non-zero elements).  These are the row numbers for each TRUE
          element in the matrix.  All other elements are FALSE. Present
          in triplet and compressed column-oriented forms only.

     '_j': Object of class '"integer"' of length nnzero (number of
          non-zero elements).  These are the column numbers for each
          TRUE element in the matrix.  All other elements are FALSE.
          Present in triplet and compressed column-oriented forms only.

     '_D_i_m': Object of class '"integer"' - the dimensions of the matrix.

_M_e_t_h_o_d_s:


     _c_o_e_r_c_e 'signature(from = "dgCMatrix", to = "lgCMatrix")'

     _t 'signature(x = "lgCMatrix")': returns the transpose of 'x'

_S_e_e _A_l_s_o:

     the class 'dgCMatrix'

_E_x_a_m_p_l_e_s:

     (m <- Matrix(c(0,0,2:0), 3,5, dimnames=list(LETTERS[1:3],NULL)))
     (lm <- (m > 1)) # lgC
     !lm     # no longer sparse
     stopifnot(is(lm,"lsparseMatrix"),
               identical(!lm, m <= 1))

     data(KNex)
     str(mmG.1 <- (KNex $ mm) > 0.1)# "lgC..."
     table(mmG.1@x)# however with many ``non-structural zeros''
     ## from logical to nz_pattern -- okay when there are no NA's :
     nmG.1 <- as(mmG.1, "nMatrix") # <<< has "TRUE" also where mmG.1 had FALSE
     ## from logical to "double"
     dmG.1 <- as(mmG.1, "dMatrix") # has '0' and back:
     lmG.1 <- as(dmG.1, "lMatrix") # has no extra FALSE, i.e. drop0() included
     stopifnot(identical(nmG.1, as((KNex $ mm) != 0,"nMatrix")),
               validObject(lmG.1), all(lmG.1@x),
               # same "logical" but lmG.1 has no 'FALSE' in x slot:
               all(lmG.1 == mmG.1))

     class(xnx <- crossprod(nmG.1))# "nsC.."
     class(xlx <- crossprod(mmG.1))# "dsC.." : numeric
     is0 <- (xlx == 0)
     mean(as.vector(is0))# 99.3% zeros: quite sparse, but
     table(xlx@x == 0)# more than half of the entries are (non-structural!) 0
     stopifnot(isSymmetric(xlx), isSymmetric(xnx),
               ## compare xnx and xlx : have the *same* non-structural 0s :
               sapply(slotNames(xnx),
                      function(n) identical(slot(xnx, n), slot(xlx, n))))

