Integer type:  int32  int64  nag_int  show int32  show int32  show int64  show int64  show nag_int  show nag_int

Chapter Contents
Chapter Introduction
NAG Toolbox

# NAG Toolbox: nag_matop_real_gen_matrix_actexp (f01ga)

## Purpose

nag_matop_real_gen_matrix_actexp (f01ga) 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.

## Syntax

[a, b, ifail] = f01ga(m, a, b, t, 'n', n)
[a, b, ifail] = nag_matop_real_gen_matrix_actexp(m, a, b, t, 'n', n)
Note: the interface to this routine has changed since earlier releases of the toolbox:
 At Mark 25: m was made optional

## 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}$.

## 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) 488-511
Higham N J (2008) Functions of Matrices: Theory and Computation SIAM, Philadelphia, PA, USA

## Parameters

### Compulsory Input Parameters

1:     $\mathrm{m}$int64int32nag_int scalar
$m$, the number of columns of the matrix $B$.
Constraint: ${\mathbf{m}}\ge 0$.
2:     $\mathrm{a}\left(\mathit{lda},:\right)$ – double array
The first dimension of the array a must be at least ${\mathbf{n}}$.
The second dimension of the array a must be at least ${\mathbf{n}}$.
The $n$ by $n$ matrix $A$.
3:     $\mathrm{b}\left(\mathit{ldb},:\right)$ – double array
The first dimension of the array b must be at least ${\mathbf{n}}$.
The second dimension of the array b must be at least ${\mathbf{m}}$.
The $n$ by $m$ matrix $B$.
4:     $\mathrm{t}$ – double scalar
The scalar $t$.

### Optional Input Parameters

1:     $\mathrm{n}$int64int32nag_int scalar
Default: the first dimension of the arrays a, b. (An error is raised if these dimensions are not equal.)
$n$, the order of the matrix $A$.
Constraint: ${\mathbf{n}}\ge 0$.

### Output Parameters

1:     $\mathrm{a}\left(\mathit{lda},:\right)$ – double array
The first dimension of the array a will be ${\mathbf{n}}$.
The second dimension of the array a will be ${\mathbf{n}}$.
$A$ is overwritten during the computation.
2:     $\mathrm{b}\left(\mathit{ldb},:\right)$ – double array
The first dimension of the array b will be ${\mathbf{n}}$.
The second dimension of the array b will be ${\mathbf{m}}$.
The $n$ by $m$ matrix ${e}^{tA}B$.
3:     $\mathrm{ifail}$int64int32nag_int scalar
${\mathbf{ifail}}={\mathbf{0}}$ unless the function detects an error (see Error Indicators and Warnings).

## Error Indicators and Warnings

Errors or warnings detected by the function:

Cases prefixed with W are classified as warnings and do not generate an error of type NAG:error_n. See nag_issue_warnings.

W  ${\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$
Constraint: ${\mathbf{n}}\ge 0$.
${\mathbf{ifail}}=-2$
Constraint: ${\mathbf{m}}\ge 0$.
${\mathbf{ifail}}=-4$
Constraint: $\mathit{lda}\ge {\mathbf{n}}$.
${\mathbf{ifail}}=-6$
Constraint: $\mathit{ldb}\ge {\mathbf{n}}$.
${\mathbf{ifail}}=-99$
${\mathbf{ifail}}=-399$
Your licence key may have expired or may not have been installed correctly.
${\mathbf{ifail}}=-999$
Dynamic memory allocation failed.

## 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 non-symmetric matrices. See Section 4 of Al–Mohy and Higham (2011) for details and further discussion.

The matrix ${e}^{tA}B$ could be computed by explicitly forming ${e}^{tA}$ using nag_matop_real_gen_matrix_exp (f01ec) and multiplying $B$ by the result. However, experiments show that it is usually both more accurate and quicker to use nag_matop_real_gen_matrix_actexp (f01ga).
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 nag_matop_real_gen_matrix_actexp (f01ga).
nag_matop_complex_gen_matrix_actexp (f01ha) can be used to compute ${e}^{tA}B$ for complex $A$, $B$, and $t$. nag_matop_real_gen_matrix_actexp_rcomm (f01gb) 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.

## Example

This example computes ${e}^{tA}B$, where
 $A = 0.7 -0.2 1.0 0.3 0.3 0.7 1.2 1.0 0.9 0.0 0.2 0.7 2.4 0.1 0.0 0.2 ,$
 $B = 0.1 1.2 1.3 0.2 0.0 1.0 0.4 -0.9$
and
 $t=1.2 .$
```function f01ga_example

fprintf('f01ga example results\n\n');

a = [0.7,-0.2, 1.0, 0.3;
0.3, 0.7, 1.2, 1.0;
0.9, 0.0, 0.2, 0.7;
2.4, 0.1, 0.0, 0.2];
b = [0.1, 1.2;
1.3, 0.2;
0.0, 1.0;
0.4,-0.9];

t = 1.2;

% Compute exp(ta)b
[a, exptab, ifail] = f01ga(a, b, t);

disp('exp(tA)B');
disp(exptab);

```
```f01ga example results

exp(tA)B
0.2138    7.6756
4.9980   11.6051
0.8307    7.5468
1.2406    9.7261

```