Wolfram Language & System Documentation Center

MatrixExp

gives the matrix exponential of m.

gives the matrix exponential of m applied to the vector v.

Details and Options

MatrixExp[m] effectively evaluates the power series for the exponential function, with ordinary powers replaced by matrix powers. »
MatrixExp works only on square matrices.
MatrixExp takes the following options:
Method Automatic method to use

Parameter 1 scalar parameter in exponential
Possible values for the option Method include:

	Automatic	automatic selection
	"BlockDecomposition"	Jordan decomposition with triangular optimization and block preprocessing
	"Jordan"	direct Jordan decomposition
	"Krylov"	Krylov iteration for the exponential applied to a vector
	"Pade"	Padé approximation for inexact input
	"SpectralBasis"	spectral method for exact matrices »
	"Schur"	Schur decomposition

The Krylov method is only applicable to the two-argument form MatrixExp[m,v] with inexact numerical inputs.
The Padé approximation and Schur methods are only applicable to inexact numerical inputs.
The default setting of Method->Automatic uses "Pade" for inexact numerical matrices, "Krylov" for inexact numerical matrix—vector pairs and, based on input contents, selects between the "BlockDecomposition" and the "SpectralBasis" for exact and symbolic matrices.
MatrixExp[m,…,Parametert] effectively computes MatrixExp[m t,…]. »

Examples

open all close all

Basic Examples (3)

Exponential of a 3×3 numerical matrix:

Wolfram Language code:

m = (⁠|      |      |     |
| ---- | ---- | --- |
| 1.2  | 3.7  | 5.6 |
| 0    | -2.2 | 4   |
| -5.3 | 0    | 1.4 |⁠)

Wolfram Language code: MatrixExp[m]//MatrixForm

This is not simply the exponential of each entry in the matrix:

Wolfram Language code: Exp[m]//MatrixForm

Exponential of a 2×2 symbolic matrix:

Wolfram Language code:

MatrixExp[(⁠|    |   |
| -- | - |
| 0  | 1 |
| -1 | 0 |⁠) t]//MatrixForm

Exponential applied to a vector:

Wolfram Language code: MatrixExp[{{1.2, 5.6}, {3, 4}}, {1, 2}]

Scope (12)

Basic Uses (7)

Exponentiate a machine-precision matrix:

Wolfram Language code: MatrixExp[{{1.2, 2.5, -3.2}, {0.7, -9.4, 5.8}, {-0.2, 0.3, 6.4}}]

Exponentiate a complex matrix:

Wolfram Language code: MatrixExp[{{1. + I, 2, 3 - 2 I}, {0, 4 π, 5I}, {E, 0, 6}}]

Compute the exponential of an exact matrix:

Wolfram Language code: MatrixExp[{{2, 3, 0}, {4, 9, 0}, {0, 0, 4}}]

The exponential of an arbitrary-precision matrix:

Wolfram Language code: MatrixExp[RandomReal[1, {2, 2}, WorkingPrecision -> 20]]

Exponential of a symbolic matrix:

Wolfram Language code: MatrixExp[{{a, b}, {0, c}}]

Computing the exponential of large machine-precision matrices is efficient:

Wolfram Language code: m = RandomReal[{0, 1}, {800, 800}];

Wolfram Language code: MatrixExp[m]; //AbsoluteTiming

Directly applying the exponential to a single vector is even more efficient:

Wolfram Language code: MatrixExp[m, Range[800]]; //AbsoluteTiming

The exponential of a CenteredInterval matrix:

Wolfram Language code: (m = Map[CenteredInterval, RandomReal[{-10, 10}, {3, 3}, WorkingPrecision -> 10], {2}])//MatrixForm

Wolfram Language code: (mexp = MatrixExp[m])//MatrixForm

Find a random representative mrep of m:

Wolfram Language code:

ranrep[e_CenteredInterval] := e["Center"] + RandomInteger[{-1000, 1000}] / 1000 e["Radius"]
(mrep = Map[ranrep, m, {2}])//MatrixForm

Verify that mexp contains the exponential of mrep:

Wolfram Language code: MapThread[IntervalMemberQ, {mexp, MatrixExp[mrep]}, 2]//MatrixForm

Special Matrices (5)

The exponential of an exact sparse matrix is typically returned as a normal matrix:

Wolfram Language code: mat = SparseArray[{{1, 3} -> 1, {2, 2} -> 2, {3, 1} -> 3}, {3, 3}]

Wolfram Language code: MatrixExp[mat]

Format the result:

Wolfram Language code: %//MatrixForm

If the sparse matrix contains machine-precision elements, the result is typically sparse:

Wolfram Language code: MatrixExp[N[mat]]

The two results are equal:

Wolfram Language code: % == %%

Directly apply the matrix exponential of a sparse matrix to a sparse vector:

Wolfram Language code: m = SparseArray[Band[{1, 2}] -> 2, {1000, 1000}]

Wolfram Language code: v = SparseArray[{{1} -> 1, {-1} -> -1.5}, {1000}]

Wolfram Language code: MatrixExp[m, v]//Short

Compute the exponential of a structured array:

Wolfram Language code: SymmetrizedArray[{{1, 1} -> 3, {2, 2} -> 1, {3, 1} -> -5}, {3, 3}, Symmetric[All]]

Wolfram Language code: MatrixExp[%]

Exponentiate IdentityMatrix:

Wolfram Language code: MatrixExp[IdentityMatrix[3]]

More generally, the exponential of any diagonal matrix is the exponential of its diagonal elements:

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

Exponentiate HilbertMatrix:

Wolfram Language code: MatrixExp[HilbertMatrix[2]]//MatrixForm

Options (3)

Method (2)

When it is applicable, "SpectralBasis" can be orders of magnitude faster than "BlockDecomposition":

Wolfram Language code:

mat = {{8, 4, 8, -4, -8, -4}, {2, 6, 14, -4, 2, -8}, {4, 2, 4, -2, -4, -2}, {1, -2, 5, 5, 2, 4}, {1, -2, -5, 1, -3, 3}, {0, 0, 1, -4, 1, -3}};

Wolfram Language code: AbsoluteTiming[mexp1 = MatrixExp[mat, Method -> "SpectralBasis"];]

Wolfram Language code: AbsoluteTiming[mexp2 = MatrixExp[mat, Method -> "BlockDecomposition"];]

It can also produce much simpler results:

Wolfram Language code: AbsoluteTiming[LeafCount[mexp1]]

Wolfram Language code: AbsoluteTiming[LeafCount[mexp2]]

The two results are equal, however:

Wolfram Language code: AbsoluteTiming[Chop[N[mexp1 - mexp2], 10^-8]]

The method is chosen automatically for matrices of exact numbers, where it excels:

Wolfram Language code: MatrixQ[mat, NumberQ] && Precision[mat] == Infinity && mexp1 === MatrixExp[mat]

"BlockDecomposition" is generally faster than "Jordan", often much faster as matrix size grows:

Wolfram Language code:

mat = RandomInteger[{-8, 8}, {6, 6}];
AbsoluteTiming[mexp1 = MatrixExp[mat, Method -> "BlockDecomposition"];]

Wolfram Language code: AbsoluteTiming[mexp2 = MatrixExp[mat, Method -> "Jordan"];]

It can also produce much simpler results:

Wolfram Language code: LeafCount /@ {mexp1, mexp2}

However, there are exceptions:

Wolfram Language code:

mat = {{8, 4, 8, -4, -8, -4}, {2, 6, 14, -4, 2, -8}, {4, 2, 4, -2, -4, -2}, {1, -2, 5, 5, 2, 4}, {1, -2, -5, 1, -3, 3}, {0, 0, 1, -4, 1, -3}};
AbsoluteTiming[mexp1 = MatrixExp[mat, Method -> "BlockDecomposition"];]

Wolfram Language code: AbsoluteTiming[mexp2 = MatrixExp[mat, Method -> "Jordan"];]

Even though "Jordan" was faster in this case, it did not produce a simpler result:

Wolfram Language code: LeafCount /@ {mexp1, mexp2}

For matrices of exact numbers, "SpectralBasis" will produce the simplest result and be of comparable or much greater speed than either Jordan-based method:

Wolfram Language code: AbsoluteTiming[LeafCount[MatrixExp[mat, Method -> "SpectralBasis"]]]

Parameter (1)

MatrixExp[m,…,Parametert] effectively computes MatrixExp[m t,…]:

Wolfram Language code: With[{m = {{1, 2}, {3, 4}}}, MatrixExp[m, Parameter -> t] == MatrixExp[m t]]

Applications (5)

Suppose a particle is moving in a planar force field and its position vector satisfies and , where and are as follows. Solve this initial problem for :

Wolfram Language code:

a = (|    |    |
| -- | -- |
| 4  | -5 |
| -2 | 1  |);

Wolfram Language code:

Subscript[x, 0] = (⁠|     |
| --- |
| 1.9 |
| 3.6 |⁠);

The solution to this differential equation is :

Wolfram Language code: x[t_] = MatrixExp[a t, Subscript[x, 0]]

Verify the solution using DSolveValue:

Wolfram Language code:

x[t] == DSolveValue[{{u1'[t], u2'[t]} == a.{u1[t], u2[t]}, {u1[0], u2[0]} == Subscript[x, 0]}, {u1[t], u2[t]}, t] //Simplify

A system of first-order linear differential equations:

Wolfram Language code:

system = |                     |
| :------------------ |
| x'[t] == z[t]        |
| y'[t] == y[t] - z[t] |
| z'[t] == -x[t]       |;

Write the system in the form with :

Wolfram Language code:

a = (⁠|    |   |    |
| :- | :- | :- |
| 0  | 0 | 1  |
| 0  | 1 | -1 |
| -1 | 0 | 0  |⁠);

The matrix exponential gives the basis for the general solution:

Wolfram Language code: MatrixExp[a t]//MatrixForm

Wolfram Language code: DSolve[system, {x[t], y[t], z[t]}, t]

The matrix exponential applied to a vector gives a particular solution:

Wolfram Language code: MatrixExp[a t, {1, 0, 0}]//MatrixForm

Wolfram Language code: % == DSolveValue[{system, {x[0], y[0], z[0]} == {1, 0, 0}}, {x[t], y[t], z[t]}, t]//Simplify

In quantum mechanics, the energy operator is called the Hamiltonian . Given the Hamiltonian for a spin-1 particle in constant magnetic field in the direction, find the state at time of a particle that is initially in the state representing :

Wolfram Language code:

ℋ = (Subscript[ω, 0]ℏ/Sqrt[2]) (|   |    |    |
| - | -- | -- |
| 0 | -I | 0  |
| I | 0  | -I |
| 0 | I  | 0  |);Subscript[ψ, 0] = {1, 0, 0};

The system evolves according to the Schrödinger equation :

Wolfram Language code: MatrixExp[-(I ℋ t/ℏ), Subscript[ψ, 0]]//FullSimplify

Cross products with respect to fixed three-dimensional vectors can be represented by matrix multiplication, which is useful in studying rotational motion. Construct the antisymmetric matrix representing the linear operator , where is an angular velocity about the axis:

Wolfram Language code: Overscript[ω, ⇀] = {0, 0, 2};

Wolfram Language code: (Subscript[ℒ, L] = Map[Cross[#, Overscript[ω, ⇀]]&, IdentityMatrix[3]])//MatrixForm

Verify that the action of is the same as doing a cross product with :

Wolfram Language code: Subscript[ℒ, L]. {x, y, z} == Overscript[ω, ⇀]⨯{x, y, z}

The rotation matrix at time is the matrix exponential of times the previous matrix:

Wolfram Language code: (rot[t_] = MatrixExp[t Subscript[ℒ, L]])//MatrixForm

Verify using RotationMatrix:

Wolfram Language code: rot[t] == RotationMatrix[Norm[Overscript[ω, ⇀]]t, Overscript[ω, ⇀]]

The point at time zero will be at time :

Wolfram Language code: Overscript[r, ⇀] = rot[t].{x, y, z}

The velocity of will be given by :

Wolfram Language code: Overscript[v, ⇀] = Overscript[ω, ⇀]⨯Overscript[r, ⇀]

And the vector from the axis of rotation to is $(v(t)xomega)/(TemplateBox[{omega}, Norm]^2)$ :

Wolfram Language code: (Overscript[v, ⇀]⨯Overscript[ω, ⇀]/Overscript[ω, ⇀].Overscript[ω, ⇀])//Expand

Visualize this motion and the associated vectors:

Wolfram Language code:

With[{w = Overscript[ω, ⇀], x = rot[s].{1, 1, 1}}, Animate[Legended[Graphics3D[{AbsoluteThickness[3], StandardRed, Arrow[{{0, 0, 0}, w}], StandardBlue, Arrow[{{0, 0, 0}, x}], StandardCyan, Arrow[{{0, 0, 1}, x}], StandardPurple, Translate[Arrow[{{0, 0, 0}, w⨯x}], x]}, PlotRange -> {{-3, 3}, {-3, 3}, {0, 2}}], SwatchLegend[{StandardRed, StandardBlue, StandardPurple, StandardCyan}, {ω, r[t], v[t] == ω⨯r[t], Subscript[r, "⟂"] == (v[t]⨯ω/ω.ω)}]], {{s, 0, t}, 0, 2π}]]

The matrix s approximates the second derivative periodic on on the grid x:

Wolfram Language code:

L = 10;
n = 500;
x = L * (2N[Range[n]] / n - 1);
s = N[Block[{h = 2. L / n}, (1/h^2)SparseArray[{{i_, i_} -> -2, {i_, j_} /; Abs[i - j] == 1 -> 1, {1, n} -> 1, {n, 1} -> 1}, {n, n}]]]

A vector representing a soliton on the grid x:

Wolfram Language code:

u = Sech[x  + Pi ] Exp[Pi I x];
ListPlot[Transpose[{x, Abs[u]}]]

Propagate the solution of using a splitting :

Wolfram Language code:

Timing[Module[{Δt = 0.05, m}, 
	m = Δt (0. + 1. I) s;
	Do[
	u = Exp[Δt I u Conjugate[u]] u;
	u = MatrixExp[m, u];
	u = Exp[Δt I u Conjugate[u]] u, 
	{1 / Δt}]]]

Plot the solution and 10 times the error from the solution of the cubic Schrödinger equation:

Wolfram Language code:

ListPlot[{Transpose[{x, Abs[u]}], Transpose[{x, 10Abs[u - Sech[x - Pi]Exp[I(Pi  x + (1 - Pi ^ 2))]]}]}, PlotRange -> All]

Properties & Relations (10)

MatrixExp effectively uses the power series for Exp, with Power replaced by MatrixPower:

Wolfram Language code:

a = {{1, 2}, {2, 1}};
MatrixExp[a] == Sum[ (MatrixPower[a, k]/k!), {k, 0, ∞}]

Equivalently, MatrixExp is MatrixFunction applied to Exp:

Wolfram Language code: MatrixExp[a] == MatrixFunction[Exp, a]

The matrix exponential of a diagonal matrix is a diagonal matrix with the diagonal entries exponentiated:

Wolfram Language code: d = {1, 2, 3, 4};

Wolfram Language code: MatrixExp[DiagonalMatrix[d t]]

Wolfram Language code: DiagonalMatrix[Exp[d t]]

If m is diagonalizable with , then :

Wolfram Language code: m = RandomReal[1, {3, 3}];

Wolfram Language code: {d, vt} = Eigensystem[m]

Wolfram Language code:

v = Transpose[vt];
v.DiagonalMatrix[Exp[d]].Inverse[v] - MatrixExp[m]//Chop

MatrixExp[m] is always invertible, and the inverse is given by MatrixExp[-m]:

Wolfram Language code: m = KroneckerProduct[RandomReal[1, 3], RandomReal[1, 3]];

Wolfram Language code: {MatrixRank[m], MatrixRank[MatrixExp[m]]}

Wolfram Language code: MatrixExp[m].MatrixExp[-m]//Chop

MatrixExp of a real, antisymmetric matrix is orthogonal:

Wolfram Language code: a = {{0, 1, 2}, {-1, 0, 3}, {-2, -3, 0}};

Wolfram Language code: AntisymmetricMatrixQ[a]

Wolfram Language code: OrthogonalMatrixQ[MatrixExp[a]]

MatrixExp of an antihermitian matrix is unitary:

Wolfram Language code: a = {{0, 1 + 4I, 2 - 5I}, {-1 + 4I, 0, 3 + 6I}, {-2 - 5I, -3 + 6I, 0}};

Wolfram Language code: AntihermitianMatrixQ[a]

Wolfram Language code: UnitaryMatrixQ[MatrixExp[a]]

MatrixExp of a Hermitian matrix is positive-definite:

Wolfram Language code: h = {{1, 2 + 3I}, {2 - 3I, -4}};

Wolfram Language code: HermitianMatrixQ[h]

Wolfram Language code: PositiveDefiniteMatrixQ[MatrixExp[h]]

MatrixExp satisfies :

Wolfram Language code: m = {{1, 2}, {3, 4}};

Wolfram Language code: D[MatrixExp[m t], t] == m . MatrixExp[m t]//FullSimplify

The matrix exponential of a nilpotent matrix is a polynomial in the exponentiation parameter:

Wolfram Language code: n = {{0, 2, 3, 4}, {0, 0, 5, 6}, {0, 0, 0, 7}, {0, 0, 0, 0}};

Wolfram Language code: MatrixExp[n t]//MatrixForm

Confirm that is nilpotent ( for some ):

Wolfram Language code: MatrixPower[n, 4]

can be computed from the JordanDecomposition as

Wolfram Language code:

m = {{2, 0, 0, 0}, {0, 1, 0, 0}, {1, -1, 1, 0}, {1, -1, 1, 1}};
{s, j} = JordanDecomposition[m];
MatrixExp[m] == s.MatrixExp[j].Inverse[s]

Moreover, is zero except in upper triangular blocks delineated by s in the superdiagonal:

Wolfram Language code: MatrixForm /@ {j, MatrixExp[j]}

Possible Issues (1)

For a large sparse matrix, computing the matrix exponential may take a long time:

Wolfram Language code:

Block[{n = 1000}, 
	v = RandomComplex[1 + I, 1000];
	s = N[SparseArray[{{i_, i_} -> -2 I, {i_, j_} /; Abs[i - j] == 1 -> I, {1, n} -> I, {n, 1} -> I}, {n, n}, (0. + 0. I)]]]

Wolfram Language code: Timing[m = MatrixExp[s];]

Computing the application of it to a vector uses less memory and is much faster:

Wolfram Language code: Timing[ev = MatrixExp[s, v];]

The results are essentially the same:

Wolfram Language code: Max[Abs[ev - m.v]]

Neat Examples (1)

Construct a cross from the reversed identity matrix:

Wolfram Language code:

m = Reverse@IdentityMatrix[20];
FullSimplify[MatrixExp[m t]]

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

MatrixExp

Details and Options

Examples

Basic Examples (3)

Scope (12)

Basic Uses (7)

Special Matrices (5)

Options (3)

Method (2)

Parameter (1)

Applications (5)

Properties & Relations (10)

Possible Issues (1)

Neat Examples (1)

Text

CMS

APA

BibTeX

BibLaTeX

MatrixExp

Details and Options

Examples

Basic Examples (3)

Scope (12)

Basic Uses (7)

Special Matrices (5)

Options (3)

Method (2)

Parameter (1)

Applications (5)

Properties & Relations (10)

Possible Issues (1)

Neat Examples (1)

See Also

Tech Notes

Related Guides

History

Text

CMS

APA

BibTeX

BibLaTeX