AdaptiveExpAndGram{T,A} <: AbstractExpAndGramAlgorithm

Adaptive algorithm for computing the matrix exponential and an associated Gramian.

Constructor:

AdaptiveExpAndGram{T}()

creates an algorithm with coefficients stored in the numeric type T.

ExpAndGram{T,N,A,B,C} <: AbstractExpAndGramAlgorithm

Non-adaptive algorithm of order N for computing the matrix exponential and an associated Gramian.

Constructor:

ExpAndGram{T,N}()

creates an algorithm with coefficients stored in the numeric type T of order N. Current supported values of N are 3, 5, 7, 9, 13.

_dims_if_compatible(A::AbstractMatrix, B::AbstractMatrix)

Throws DimensionMismatch if A is not square or if the number of rows of B does not equal the number of columns of A. Is equivalent to size(B) if no error is thrown.

_exp_and_gram_init(
    A::AbstractMatrix{T},
    B::AbstractMatrix{T},
    method::ExpAndGram{T,q},
    [cache=alloc_mem(A, B, method)],
    )

Computes the matrix exponential exp(A) and the controllability Grammian

\[∫_0^1 e^{A t} B B' e^{A'*t} dt,\]

using a Legendre expansion of the matrix exponential of order q.

_exp_and_gram_double!(eA, U, s, cache)

Computes s iterations of the doubling recursions:

\[Φ_{k+1} = Φ_k^2,\]

and

\[U_{k+1}' U_{k+1} = Φ_k U_k' U_k Φ_k' + U_k' U_k\]

_symmetrize!(A::AbstractMatrix{T}) where {T<:Number}

Discards the skew-Hermitian part of A in-place.

alloc_mem(A, B, ::ExpAndGram{T,q})

Computes a cache for repeated computations with the same input arguments (A, B).

exp_and_gram(
    A::AbstractMatrix{T},
    B::AbstractMatrix{T},
    t::Number,
    method::AbstractExpAndGramAlgorithm,
)

Compute the matrix exponential exp(A) and the controllability Gramian of (A, B) over the interval [0, t], if t is omitted the unit interval is used.

exp_and_gram!(
    eA::AbstractMatrix{T},
    G::AbstractMatrix{T},
    A::AbstractMatrix{T},
    B::AbstractMatrix{T},
    t::Number,
    method::AbstractExpAndGramAlgorithm,
    cache = alloc_mem(A, B, method),
)

Computes the matrix exponential of A * t and the controllability Gramian of (A, B) on the interval [0, t], if t is omitted the unit interval is used. The result is stored in (eA, G), which are returned.

exp_and_gram_chol(
    A::AbstractMatrix{T},
    B::AbstractMatrix{T},
    [t::Number],
    method::AbstractExpAndGramAlgorithm,
)

Computes the matrix exponential of A * t and the controllability Gramian of (A, B) on the interval [0, t], if t is omitted the unit interval is used.

exp_and_gram_chol!(
    eA::AbstractMatrix{T},
    U::AbstractMatrix{T},
    A::AbstractMatrix{T},
    B::AbstractMatrix{T},
    [t::Number],
    method::ExpAndGram{T,q},
    [cache = alloc_mem(A, B, method)],
)

exp_and_gram_chol!(
    eA::AbstractMatrix{T},
    U::AbstractMatrix{T},
    A::AbstractMatrix{T},
    B::AbstractMatrix{T},
    [t::Number],
    method::AdaptiveExpAndGram,
    [cache = nothing],
)

Computes the matrix exponential of A * t and the controllability Gramian of (A, B) on the interval [0, t], if t is omitted the unit interval is used. The result is stored in (eA, U), which are returned.

triu2cholesky_factor!(A::AbstractMatrix{T})

If A is an upper triangular matrix, it computes the product QA in-place, where Q is a unitary transform such that QA is a valid Cholesky factor. If A is not an upper triangular matrix, returns garbage.