NAG Library Routine Document
f01gaf
(real_gen_matrix_actexp)
1
Purpose
f01gaf computes the action of the matrix exponential ${e}^{tA}$, on the matrix $B$, where $A$ is a real $n$ by $n$ matrix, $B$ is a real $n$ by $m$ matrix and $t$ is a real scalar.
2
Specification
Fortran Interface
Integer, Intent (In)  :: 
n,
m,
lda,
ldb  Integer, Intent (Inout)  :: 
ifail  Real (Kind=nag_wp), Intent (In)  :: 
t  Real (Kind=nag_wp), Intent (Inout)  :: 
a(lda,*),
b(ldb,*) 

C Header Interface
#include nagmk26.h
void 
f01gaf_ (
const Integer *n,
const Integer *m,
double a[],
const Integer *lda,
double b[],
const Integer *ldb,
const double *t,
Integer *ifail) 

3
Description
${e}^{tA}B$ is computed using the algorithm described in
Al–Mohy and Higham (2011) which uses a truncated Taylor series to compute the product
${e}^{tA}B$ without explicitly forming
${e}^{tA}$.
4
References
Al–Mohy A H and Higham N J (2011) Computing the action of the matrix exponential, with an application to exponential integrators SIAM J. Sci. Statist. Comput. 33(2) 488511
Higham N J (2008) Functions of Matrices: Theory and Computation SIAM, Philadelphia, PA, USA
5
Arguments
 1: $\mathbf{n}$ – IntegerInput

On entry: $n$, the order of the matrix $A$.
Constraint:
${\mathbf{n}}\ge 0$.
 2: $\mathbf{m}$ – IntegerInput

On entry: $m$, the number of columns of the matrix $B$.
Constraint:
${\mathbf{m}}\ge 0$.
 3: $\mathbf{a}\left({\mathbf{lda}},*\right)$ – Real (Kind=nag_wp) arrayInput/Output

Note: the second dimension of the array
a
must be at least
${\mathbf{n}}$.
On entry: the $n$ by $n$ matrix $A$.
On exit: $A$ is overwritten during the computation.
 4: $\mathbf{lda}$ – IntegerInput

On entry: the first dimension of the array
a as declared in the (sub)program from which
f01gaf is called.
Constraint:
${\mathbf{lda}}\ge {\mathbf{n}}$.
 5: $\mathbf{b}\left({\mathbf{ldb}},*\right)$ – Real (Kind=nag_wp) arrayInput/Output

Note: the second dimension of the array
b
must be at least
${\mathbf{m}}$.
On entry: the $n$ by $m$ matrix $B$.
On exit: the $n$ by $m$ matrix ${e}^{tA}B$.
 6: $\mathbf{ldb}$ – IntegerInput

On entry: the first dimension of the array
b as declared in the (sub)program from which
f01gaf is called.
Constraint:
${\mathbf{ldb}}\ge {\mathbf{n}}$.
 7: $\mathbf{t}$ – Real (Kind=nag_wp)Input

On entry: the scalar $t$.
 8: $\mathbf{ifail}$ – IntegerInput/Output

On entry:
ifail must be set to
$0$,
$1\text{ or}1$. If you are unfamiliar with this argument you should refer to
Section 3.4 in How to Use the NAG Library and its Documentation for details.
For environments where it might be inappropriate to halt program execution when an error is detected, the value
$1\text{ or}1$ is recommended. If the output of error messages is undesirable, then the value
$1$ is recommended. Otherwise, if you are not familiar with this argument, the recommended value is
$0$.
When the value $\mathbf{1}\text{ or}\mathbf{1}$ is used it is essential to test the value of ifail on exit.
On exit:
${\mathbf{ifail}}={\mathbf{0}}$ unless the routine detects an error or a warning has been flagged (see
Section 6).
6
Error Indicators and Warnings
If on entry
${\mathbf{ifail}}=0$ or
$1$, explanatory error messages are output on the current error message unit (as defined by
x04aaf).
Errors or warnings detected by the routine:
 ${\mathbf{ifail}}=2$

${e}^{tA}B$ has been computed using an IEEE double precision Taylor series, although the arithmetic precision is higher than IEEE double precision.
 ${\mathbf{ifail}}=1$

On entry, ${\mathbf{n}}=\u2329\mathit{\text{value}}\u232a$.
Constraint: ${\mathbf{n}}\ge 0$.
 ${\mathbf{ifail}}=2$

On entry, ${\mathbf{m}}=\u2329\mathit{\text{value}}\u232a$.
Constraint: ${\mathbf{m}}\ge 0$.
 ${\mathbf{ifail}}=4$

On entry, ${\mathbf{lda}}=\u2329\mathit{\text{value}}\u232a$ and ${\mathbf{n}}=\u2329\mathit{\text{value}}\u232a$.
Constraint: ${\mathbf{lda}}\ge {\mathbf{n}}$.
 ${\mathbf{ifail}}=6$

On entry, ${\mathbf{ldb}}=\u2329\mathit{\text{value}}\u232a$ and ${\mathbf{n}}=\u2329\mathit{\text{value}}\u232a$.
Constraint: ${\mathbf{ldb}}\ge {\mathbf{n}}$.
 ${\mathbf{ifail}}=99$
An unexpected error has been triggered by this routine. Please
contact
NAG.
See
Section 3.9 in How to Use the NAG Library and its Documentation for further information.
 ${\mathbf{ifail}}=399$
Your licence key may have expired or may not have been installed correctly.
See
Section 3.8 in How to Use the NAG Library and its Documentation for further information.
 ${\mathbf{ifail}}=999$
Dynamic memory allocation failed.
See
Section 3.7 in How to Use the NAG Library and its Documentation for further information.
7
Accuracy
For a symmetric matrix
$A$ (for which
${A}^{\mathrm{T}}=A$) the computed matrix
${e}^{tA}B$ is guaranteed to be close to the exact matrix, that is, the method is forward stable. No such guarantee can be given for nonsymmetric matrices. See Section 4 of
Al–Mohy and Higham (2011) for details and further discussion.
8
Parallelism and Performance
f01gaf is threaded by NAG for parallel execution in multithreaded implementations of the NAG Library.
f01gaf makes calls to BLAS and/or LAPACK routines, which may be threaded within the vendor library used by this implementation. Consult the documentation for the vendor library for further information.
Please consult the
X06 Chapter Introduction for information on how to control and interrogate the OpenMP environment used within this routine. Please also consult the
Users' Note for your implementation for any additional implementationspecific information.
The matrix
${e}^{tA}B$ could be computed by explicitly forming
${e}^{tA}$ using
f01ecf and multiplying
$B$ by the result. However, experiments show that it is usually both more accurate and quicker to use
f01gaf.
The cost of the algorithm is $\mathit{O}\left({n}^{2}m\right)$. The precise cost depends on $A$ since a combination of balancing, shifting and scaling is used prior to the Taylor series evaluation.
Approximately ${n}^{2}+\left(2m+8\right)n$ of real allocatable memory is required by f01gaf.
f01haf can be used to compute
${e}^{tA}B$ for complex
$A$,
$B$, and
$t$.
f01gbf provides an implementation of the algorithm with a reverse communication interface, which returns control to the user when matrix multiplications are required. This should be used if
$A$ is large and sparse.
10
Example
This example computes
${e}^{tA}B$, where
and
10.1
Program Text
Program Text (f01gafe.f90)
10.2
Program Data
Program Data (f01gafe.d)
10.3
Program Results
Program Results (f01gafe.r)