# matrix-products: Matrix (Cross) Products (of Transpose)

### Description

The basic matrix product, `%*%` is implemented for all our `Matrix` and also for `sparseVector` classes, fully analogously to R's base `matrix` and vector objects.

The functions `crossprod` and `tcrossprod` are matrix products or “cross products”, ideally implemented efficiently without computing `t(.)`'s unnecessarily. They also return `symmetricMatrix` classed matrices when easily detectable, e.g., in `crossprod(m)`, the one argument case.

`tcrossprod()` takes the cross-product of the transpose of a matrix. `tcrossprod(x)` is formally equivalent to, but faster than, the call `x %*% t(x)`, and so is `tcrossprod(x, y)` instead of `x %*% t(y)`.

Boolean matrix products are computed via either `%&%` or `boolArith = TRUE`.

### Usage

 ``` 1 2 3 4 5 6 7 8 9 10 11 12 13 14``` ```## S4 method for signature 'CsparseMatrix,diagonalMatrix' x %*% y ## S4 method for signature 'dgeMatrix,missing' crossprod(x, y = NULL, boolArith = NA, ...) ## S4 method for signature 'CsparseMatrix,diagonalMatrix' crossprod(x, y = NULL, boolArith = NA, ...) ## .... and for many more signatures ## S4 method for signature 'CsparseMatrix,ddenseMatrix' tcrossprod(x, y = NULL, boolArith = NA, ...) ## S4 method for signature 'TsparseMatrix,missing' tcrossprod(x, y = NULL, boolArith = NA, ...) ## .... and for many more signatures ```

### Arguments

 `x` a matrix-like object `y` a matrix-like object, or for `[t]crossprod()` `NULL` (by default); the latter case is formally equivalent to `y = x`. `boolArith` `logical`, i.e., `NA`, `TRUE`, or `FALSE`. If true the result is (coerced to) a pattern matrix, i.e., `"nMatrix"`, unless there are `NA` entries and the result will be a `"lMatrix"`. If false the result is (coerced to) numeric. When `NA`, currently the default, the result is a pattern matrix when `x` and `y` are `"nsparseMatrix"` and numeric otherwise. `...` potentially more arguments passed to and from methods.

### Details

For some classes in the `Matrix` package, such as `dgCMatrix`, it is much faster to calculate the cross-product of the transpose directly instead of calculating the transpose first and then its cross-product.

`boolArith = TRUE` for regular (“non cross”) matrix products, `%*%` cannot be specified. Instead, we provide the `%&%` operator for boolean matrix products.

### Value

A `Matrix` object, in the one argument case of an appropriate symmetric matrix class.

### Methods

%*%

`signature(x = "dgeMatrix", y = "dgeMatrix")`: Matrix multiplication; ditto for several other signature combinations, see `showMethods("%*%", class = "dgeMatrix")`.

%*%

`signature(x = "dtrMatrix", y = "matrix")` and other signatures (use `showMethods("%*%", class="dtrMatrix")`): matrix multiplication. Multiplication of (matching) triangular matrices now should remain triangular (in the sense of class triangularMatrix).

crossprod

`signature(x = "dgeMatrix", y = "dgeMatrix")`: ditto for several other signatures, use `showMethods("crossprod", class = "dgeMatrix")`, matrix crossproduct, an efficient version of `t(x) %*% y`.

crossprod

`signature(x = "CsparseMatrix", y = "missing")` returns `t(x) %*% x` as an `dsCMatrix` object.

crossprod

`signature(x = "TsparseMatrix", y = "missing")` returns `t(x) %*% x` as an `dsCMatrix` object.

crossprod,tcrossprod

```signature(x = "dtrMatrix", y = "matrix")``` and other signatures, see `"%*%"` above.

### Note

`boolArith = TRUE`, `FALSE` or `NA` has been newly introduced for Matrix 1.2.0 (March 2015). Its implementation may be incomplete and partly missing. Please report such omissions if detected!

Currently, `boolArith = TRUE` is implemnted via `CsparseMatrix` coercions which may be quite inefficient for dense matrices. Contributions for efficiency improvements are welcome.

`tcrossprod` in R's base, `crossprod` and `%*%`.

### Examples

 ``` 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16``` ``` ## A random sparse "incidence" matrix : m <- matrix(0, 400, 500) set.seed(12) m[runif(314, 0, length(m))] <- 1 mm <- as(m, "dgCMatrix") object.size(m) / object.size(mm) # smaller by a factor of > 200 ## tcrossprod() is very fast: system.time(tCmm <- tcrossprod(mm))# 0 (PIII, 933 MHz) system.time(cm <- crossprod(t(m))) # 0.16 system.time(cm. <- tcrossprod(m)) # 0.02 stopifnot(cm == as(tCmm, "matrix")) ## show sparse sub matrix tCmm[1:16, 1:30] ```

Search within the Matrix package
Search all R packages, documentation and source code

Questions? Problems? Suggestions? or email at ian@mutexlabs.com.

Please suggest features or report bugs with the GitHub issue tracker.

All documentation is copyright its authors; we didn't write any of that.