Wolfram Language & System Documentation Center

DiagonalMatrix

DiagonalMatrix[list]

gives a matrix with the elements of list on the leading diagonal, and zero elsewhere.

DiagonalMatrix[list,k]

gives a matrix with the elements of list on the k diagonal.

DiagonalMatrix[list,k,n]

pads with zeros to create an n×n matrix.

Details and Options

A diagonal matrix can be used to scale the rows of a matrix by multiplying from the left, or scale the columns by multiplying from the right.
In the diagonal matrix  given by DiagonalMatrix[{d₁,…,d_n}], the entries are given by $D〚i,j〛=d_iTemplateBox[{{i, ,, j}}, KroneckerDeltaSeq]$ ; that is, for the i leading diagonal entry and 0 otherwise.

DiagonalMatrix[list] is a symmetric matrix, and is thus equal to its transpose.
For positive k, DiagonalMatrix[{d₁,…,d_s},k] puts the elements k positions above the leading diagonal, while DiagonalMatrix[{d₁,…,d_s},-k] puts the elements k positions below the leading diagonal of a matrix of size . Different values of k lead to different matrix dimensions.

DiagonalMatrix[list] is equivalent to DiagonalMatrix[list,0].
DiagonalMatrix[list,k,n] always creates an n×n matrix, even if this requires dropping elements of list. »
The determinant of a diagonal matrix is the product of the leading diagonal entries if , and 0 otherwise.
DiagonalMatrix[list,k,{m,n}] creates an m×n matrix.
DiagonalMatrix[SparseArray[…],…] gives a SparseArray object.
DiagonalMatrix[…,TargetStructure->struct] returns the diagonal matrix in the format specified by struct. Possible settings include:

	Automatic	automatically choose the representation returned
	"Dense"	represent the matrix as a dense matrix
	"Sparse"	represent the matrix as a sparse array
	"Structured"	represent the matrix as a structured array
	"Symmetric"	represent the matrix as a symmetric matrix

With DiagonalMatrix[…,TargetStructureAutomatic], a dense matrix is returned if the number of matrix entries is less than a preset threshold, and a structured array is returned otherwise.
Diagonal matrices, when represented as structured arrays, allow for efficient storage and more efficient operations, including Det, Inverse and LinearSolve.
Operations that are accelerated for DiagonalMatrix include:
Det time

Dot time

Inverse time

LinearSolve time
For a structured DiagonalMatrix sa, the following properties "prop" can be accessed as sa["prop"]:

	"Diagonal"	list of entries on the k diagonal
	"Offset"	the offset k
	"Properties"	list of supported properties
	"Structure"	type of structured array
	"StructuredData"	internal data stored by the structured array
	"StructuredAlgorithms"	list of functions with special methods for the structured array
	"Summary"	summary information, represented as a Dataset

Normal[DiagonalMatrix[…]] gives the diagonal matrix as an ordinary matrix.

Examples

open all close all

Basic Examples (1)

Construct a diagonal matrix:

Wolfram Language code: DiagonalMatrix[{a, b, c}]//MatrixForm

A superdiagonal matrix:

Wolfram Language code: DiagonalMatrix[{a, b}, 1]//MatrixForm

A subdiagonal matrix:

Wolfram Language code: DiagonalMatrix[{a, b}, -1]//MatrixForm

Scope (6)

The elements in DiagonalMatrix are chosen to match the elements of the vector:

Wolfram Language code: v = 1 / Range[3];

Exact number entries:

Wolfram Language code: DiagonalMatrix[v]//MatrixForm

Machine-number entries:

Wolfram Language code: DiagonalMatrix[N[v]]//MatrixForm

Arbitrary-precision number entries:

Wolfram Language code: DiagonalMatrix[N[v, 20]]//MatrixForm

Pad with zeros to make a larger square matrix:

Wolfram Language code: DiagonalMatrix[{1, 2, 3}, 0, 5] // MatrixForm

Make a square matrix with the specified dimension:

Wolfram Language code: DiagonalMatrix[{1, 2, 3, 4, 5}, 0, 3] // MatrixForm

Rectangular diagonal matrices:

Wolfram Language code: DiagonalMatrix[{1, 2, 3}, 0, {3, 5}] // MatrixForm

Wolfram Language code: DiagonalMatrix[{1, 2, 3}, 0, {5, 3}] // MatrixForm

Construct a sparse diagonal matrix using the option setting TargetStructure"Sparse":

Wolfram Language code: 𝒟 = DiagonalMatrix[RandomReal[1, 1000], TargetStructure -> "Sparse"]

The sparse representation saves a significant amount of memory for larger matrices:

Wolfram Language code: {ByteCount[𝒟], ByteCount[Normal[𝒟]]}

Generate a structured diagonal matrix using the option setting TargetStructure"Structured":

Wolfram Language code: 𝒟 = DiagonalMatrix[RandomReal[{1, 2}, 1000], TargetStructure -> "Structured"]

The representation and computation are efficient for the structured array:

Wolfram Language code: 𝒟//ByteCount

Wolfram Language code: Det[𝒟]//AbsoluteTiming

Wolfram Language code: Inverse[𝒟]//ByteCount//AbsoluteTiming

The normal representation is dramatically bigger and slower:

Wolfram Language code: (dnormal = Normal@𝒟)//ByteCount//AbsoluteTiming

Wolfram Language code: Det[dnormal]//AbsoluteTiming

The inverse needs a large amount of storage:

Wolfram Language code: Inverse[dnormal]//ByteCount//AbsoluteTiming

DiagonalMatrix objects include properties that give information about the array:

Wolfram Language code: dm = DiagonalMatrix[1 / Range[6], -2, TargetStructure -> "Structured"]

Wolfram Language code: dm["Properties"]

"Diagonal" gives the diagonal entries:

Wolfram Language code: dm["Diagonal"]

"Offset" gives the offset, which is zero, positive or negative if the diagonal elements are respectively on, above or below the main diagonal:

Wolfram Language code: dm["Offset"]

The "Summary" property gives a brief summary of information about the array:

Wolfram Language code: dm["Summary"]

The "StructuredAlgorithms" property lists the functions that have structured algorithms:

Wolfram Language code: dm["StructuredAlgorithms"]

Options (3)

TargetStructure (3)

Return the diagonal matrix as a dense matrix:

Wolfram Language code: DiagonalMatrix[{1, 2, 3}, TargetStructure -> "Dense"]

Return the diagonal matrix as a structured array:

Wolfram Language code: DiagonalMatrix[{1, 2, 3}, TargetStructure -> "Structured"]

Return the diagonal matrix as a sparse array:

Wolfram Language code: DiagonalMatrix[{1, 2, 3}, TargetStructure -> "Sparse"]

With the setting TargetStructureAutomatic, a dense matrix is returned for small dimensions:

Wolfram Language code: DiagonalMatrix[Range[5], TargetStructure -> Automatic]

For large dimensions, a structured representation is returned:

Wolfram Language code: DiagonalMatrix[Range[10000], TargetStructure -> Automatic]

The dense representation uses a lot of memory for large lists:

Wolfram Language code: DiagonalMatrix[Range[10000], TargetStructure -> "Dense"] //ByteCount

The sparse representation typically uses less memory:

Wolfram Language code: DiagonalMatrix[Range[10000], TargetStructure -> "Sparse"] //ByteCount

The structured representation uses even less memory:

Wolfram Language code: DiagonalMatrix[Range[10000], TargetStructure -> "Structured"] //ByteCount

Applications (5)

Express a matrix as the sum of its diagonal and off-diagonal parts:

Wolfram Language code: MatrixForm[m = Array[Subscript[a, ##]&, {3, 3}]]

Wolfram Language code:

md = DiagonalMatrix[Diagonal[m]];
mo = m - md;

Wolfram Language code: Map[MatrixForm, {md, mo}]

Verify the similarity of a matrix to the diagonal matrix of its eigenvalues:

Wolfram Language code: m = N[HilbertMatrix[3]]

Wolfram Language code: {vals, vecs} = Eigensystem[m]

Wolfram Language code: Transpose[vecs].DiagonalMatrix[vals].vecs

Define a Jordan matrix:

Wolfram Language code: jordanMatrix[λ_, n_] := DiagonalMatrix[Table[λ, {n}]] + DiagonalMatrix[Table[1, {n - 1}], 1]

Wolfram Language code: jordanMatrix[λ, 3]//MatrixForm

Construct a 5×5 tridiagonal matrix:

Wolfram Language code:

n = 5;
MatrixForm[DiagonalMatrix[Array[Subscript[a, #]&, n - 1], -1] + DiagonalMatrix[Array[Subscript[b, #]&, n]] + DiagonalMatrix[Array[Subscript[c, #]&, n - 1], 1]]

This can also be done using Band:

Wolfram Language code:

MatrixForm[SparseArray[{Band[{2, 1}] -> Array[Subscript[a, #]&, n - 1], Band[{1, 1}] -> Array[Subscript[b, #]&, n], Band[{1, 2}] -> Array[Subscript[c, #]&, n - 1]}]]

Extract the diagonal from a diagonal rectangular matrix:

Wolfram Language code:

m = (|   |   |
| - | - |
| a | 0 |
| 0 | b |
| 0 | 0 |);

Wolfram Language code: DiagonalMatrixQ[m]

Wolfram Language code: d = Diagonal[m]

Reconstruct the original matrix from the diagonal:

Wolfram Language code: DiagonalMatrix[d, 0, {3, 2}] == m

Properties & Relations (9)

IdentityMatrix is a special case of DiagonalMatrix:

Wolfram Language code: IdentityMatrix[5] == DiagonalMatrix[ConstantArray[1, 5]]

Convert IdentityMatrix to a structured DiagonalMatrix:

Wolfram Language code: DiagonalMatrix[IdentityMatrix[5]]

DiagonalMatrix creates matrices that are DiagonalMatrixQ:

Wolfram Language code: (m = DiagonalMatrix[{a, b, c, d}])//MatrixForm

Wolfram Language code: DiagonalMatrixQ[m]

DiagonalMatrix[l] is UpperTriangularMatrixQ and LowerTriangularMatrixQ:

Wolfram Language code: DiagonalMatrix[{a, b, c, d}]

Wolfram Language code: UpperTriangularMatrixQ[%]

Wolfram Language code: LowerTriangularMatrixQ[%%]

Several simple properties hold for diagonal matrices:

Wolfram Language code: v = Range[5];

Inverse, MatrixExp and MatrixPower commute with DiagonalMatrix:

Wolfram Language code: Inverse[DiagonalMatrix[v]] == DiagonalMatrix[1 / v]

Wolfram Language code: MatrixExp[DiagonalMatrix[v]] == DiagonalMatrix[Exp[v]]

Wolfram Language code: MatrixPower[DiagonalMatrix[v], n] == DiagonalMatrix[Power[v, n]]

Det and Tr have commuting relations:

Wolfram Language code: Det[DiagonalMatrix[v]] == Times@@v

Wolfram Language code: Tr[DiagonalMatrix[v]] == Plus@@v

The permanent of the product of a diagonal matrix and a general matrix is equal to the permanent of the general matrix multiplied by the diagonal elements of the diagonal matrix:

Wolfram Language code:

n = 5;
diag = DiagonalMatrix[Array[, n]];
mat = Array[C, {n, n}];

Wolfram Language code: Permanent[diag.mat] == Apply[Times, Diagonal[diag]] * Permanent[mat]//Simplify

Diagonal of DiagonalMatrix gives the original vector:

Wolfram Language code: v = RandomReal[1, 100];

Wolfram Language code: Diagonal[DiagonalMatrix[v]] === v

This is true even if the vector is a SparseArray object:

Wolfram Language code: s = SparseArray[v];

Wolfram Language code: Diagonal[DiagonalMatrix[s]] === s

Matrices with only subdiagonals or superdiagonals are always nilpotent:

Wolfram Language code: MatrixPower[DiagonalMatrix[Range[4], -1], 5]

Wolfram Language code: MatrixPower[DiagonalMatrix[Range[4], 1], 5]

The size of the matrix generated by DiagonalMatrix[list,k] equals Length[list]+Abs[k]:

Wolfram Language code:

list = RandomReal[1, RandomInteger[{1, 10}]];
k = RandomInteger[{-20, 20}];

Wolfram Language code: Thread[Dimensions[DiagonalMatrix[list, k]] == Length[list] + Abs[k]]

Band can be used to construct diagonals equivalent to DiagonalMatrix[list,k]:

Wolfram Language code:

list = Range[5];
k = RandomInteger[{-2, 2}];

Wolfram Language code: DiagonalMatrix[list, k] == SparseArray[Band[If[k > 0, {1, 1 + k}, {1 - k, 1}]] -> list, (Length[list] + Abs[k]){1, 1}]

They will be SameQ with the setting TargetStructure"Sparse":

Wolfram Language code:

DiagonalMatrix[list, k, TargetStructure -> "Sparse"] === SparseArray[Band[If[k > 0, {1, 1 + k}, {1 - k, 1}]] -> list, (Length[list] + Abs[k]){1, 1}]

Top

More Learning

Tech Support

Data Science, Finance & Business

Engineering

Science & Technology

Technology for Education

Education Initiatives

Get Started

Grow Your Skills

Work with Us

Educational Programs for Adults

Educational Programs for Youth

Read

DiagonalMatrix

Details and Options

Examples

Basic Examples (1)

Scope (6)

Options (3)

TargetStructure (3)

Applications (5)

Properties & Relations (9)

Text

CMS

APA

BibTeX

BibLaTeX

	Det	time
	Dot	time
	Inverse	time
	LinearSolve	time

DiagonalMatrix

Details and Options

Examples

Basic Examples (1)

Scope (6)

Options (3)

TargetStructure (3)

Applications (5)

Properties & Relations (9)

See Also

Tech Notes

Related Guides

History

Text

CMS

APA

BibTeX

BibLaTeX