# Diagonal {Matrix}

Create Diagonal Matrix Object
Package:
Matrix
Version:
1.0-12

### Description

Create a diagonal matrix object, i.e., an object inheriting from `diagonalMatrix`.

### Usage

```Diagonal(n, x = NULL)

.symDiagonal(n, x = rep.int(1,n), uplo = "U")
.sparseDiagonal(n, x = 1, uplo = "U",
shape = if(missing(cols)) "t" else "g",
unitri, kind, cols = if(n) 0:(n - 1L) else integer(0))
```

### Arguments

n
integer specifying the dimension of the (square) matrix. If missing, `length(x)` is used.
x
numeric or logical; if missing, a unit diagonal n x n matrix is created.
uplo
for `.symDiagonal`, the resulting sparse `symmetricMatrix` will have slot `uplo` set from this argument, either `"U"` or `"L"`. Only rarely will it make sense to change this from the default.
shape
string of 1 character, one of `c("t","s","g")`, to chose a triangular, symmetric or general result matrix.
unitri
optional logical indicating if a triangular result should be “unit-triangular”, i.e., with `diag = "U"` slot, if possible. The default, `missing`, is the same as `TRUE`.
kind
string of 1 character, one of `c("d","l","n")`, to chose the storage mode of the result, from classes `dsparseMatrix`, `lsparseMatrix`, or `nsparseMatrix`, respectively.
cols
integer vector with values from `0:(n-1)`, denoting the columns to subselect conceptually, i.e., get the equivalent of `Diagonal(n,*)[, cols + 1]`.

### Values

`Diagonal()` returns an object of class `ddiMatrix` or `ldiMatrix` (with “superclass” `diagonalMatrix`).

`.symDiagonal()` returns an object of class `dsCMatrix` or `lsCMatrix`, i.e., a sparse symmetric matrix. This can be more efficient than `Diagonal(n)` when the result is combined with further symmetric (sparse) matrices, however not for matrix multiplications where `Diagonal()` is clearly preferred.

`.sparseDiagonal()`, the workhorse of `.symDiagonal` returns a `CsparseMatrix` (the resulting class depending on `shape` and `kind`) representation of `Diagonal(n)`, or, when `cols` are specified, of `Diagonal(n)[, cols+1]`.

the generic function `diag` for extraction of the diagonal from a matrix works for all “Matrices”.

`bandSparse` constructs a banded sparse matrix from its non-zero sub-/super - diagonals. `band(A)` returns a band matrix containing some sub-/super - diagonals of `A`.

`Matrix` for general matrix construction; further, class `diagonalMatrix`.

### Examples

```Diagonal(3)
Diagonal(x = 10^(3:1))
Diagonal(x = (1:4) >= 2)#-> "ldiMatrix"

## Use Diagonal() + kronecker() for "repeated-block" matrices:
M1 <- Matrix(0+0:5, 2,3)
(M <- kronecker(Diagonal(3), M1))

(S <- crossprod(Matrix(rbinom(60, size=1, prob=0.1), 10,6)))
(SI <- S + 10*.symDiagonal(6)) # sparse symmetric still
stopifnot(is(SI, "dsCMatrix"))
(I4 <- .sparseDiagonal(4, shape="t"))# now (2012-10) unitriangular
stopifnot(I4@diag == "U", all(I4 == diag(4)))```

### Author(s)

Martin Maechler

Documentation reproduced from package Matrix, version 1.0-12. License: GPL (>= 2)