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_sparse_complex_gen_matvec (f11xn)

Purpose

nag_sparse_complex_gen_matvec (f11xn) computes a matrix-vector or conjugate transposed matrix-vector product involving a complex sparse non-Hermitian matrix stored in coordinate storage format.

Syntax

[y, ifail] = f11xn(trans, a, irow, icol, check, x, 'n', n, 'nz', nz)
[y, ifail] = nag_sparse_complex_gen_matvec(trans, a, irow, icol, check, x, 'n', n, 'nz', nz)

Description

nag_sparse_complex_gen_matvec (f11xn) computes either the matrix-vector product $y=Ax$, or the conjugate transposed matrix-vector product $y={A}^{\mathrm{H}}x$, according to the value of the argument trans, where $A$ is a complex $n$ by $n$ sparse non-Hermitian matrix, of arbitrary sparsity pattern. The matrix $A$ is stored in coordinate storage (CS) format (see Coordinate storage (CS) format in the F11 Chapter Introduction). The array a stores all the nonzero elements of $A$, while arrays irow and icol store the corresponding row and column indices respectively.
It is envisaged that a common use of nag_sparse_complex_gen_matvec (f11xn) will be to compute the matrix-vector product required in the application of nag_sparse_complex_gen_basic_solver (f11bs) to sparse complex linear systems. This is illustrated in Example in nag_sparse_complex_gen_precon_ssor_solve (f11dr).

None.

Parameters

Compulsory Input Parameters

1:     $\mathrm{trans}$ – string (length ≥ 1)
Specifies whether or not the matrix $A$ is conjugate transposed.
${\mathbf{trans}}=\text{'N'}$
$y=Ax$ is computed.
${\mathbf{trans}}=\text{'T'}$
$y={A}^{\mathrm{H}}x$ is computed.
Constraint: ${\mathbf{trans}}=\text{'N'}$ or $\text{'T'}$.
2:     $\mathrm{a}\left({\mathbf{nz}}\right)$ – complex array
The nonzero elements in the matrix $A$, ordered by increasing row index, and by increasing column index within each row. Multiple entries for the same row and column indices are not permitted. The function nag_sparse_complex_gen_sort (f11zn) may be used to order the elements in this way.
3:     $\mathrm{irow}\left({\mathbf{nz}}\right)$int64int32nag_int array
4:     $\mathrm{icol}\left({\mathbf{nz}}\right)$int64int32nag_int array
The row and column indices of the nonzero elements supplied in array a.
Constraints:
• $1\le {\mathbf{irow}}\left(\mathit{i}\right)\le {\mathbf{n}}$ and $1\le {\mathbf{icol}}\left(\mathit{i}\right)\le {\mathbf{n}}$, for $\mathit{i}=1,2,\dots ,{\mathbf{nz}}$;
• ${\mathbf{irow}}\left(\mathit{i}-1\right)<{\mathbf{irow}}\left(\mathit{i}\right)$ or ${\mathbf{irow}}\left(\mathit{i}-1\right)={\mathbf{irow}}\left(\mathit{i}\right)$ and ${\mathbf{icol}}\left(\mathit{i}-1\right)<{\mathbf{icol}}\left(\mathit{i}\right)$, for $\mathit{i}=2,3,\dots ,{\mathbf{nz}}$.
5:     $\mathrm{check}$ – string (length ≥ 1)
Specifies whether or not the CS representation of the matrix $A$, values of n, nz, irow and icol should be checked.
${\mathbf{check}}=\text{'C'}$
Checks are carried on the values of n, nz, irow and icol.
${\mathbf{check}}=\text{'N'}$
None of these checks are carried out.
Constraint: ${\mathbf{check}}=\text{'C'}$ or $\text{'N'}$.
6:     $\mathrm{x}\left({\mathbf{n}}\right)$ – complex array
The vector $x$.

Optional Input Parameters

1:     $\mathrm{n}$int64int32nag_int scalar
Default: the dimension of the array x.
$n$, the order of the matrix $A$.
Constraint: ${\mathbf{n}}\ge 1$.
2:     $\mathrm{nz}$int64int32nag_int scalar
Default: the dimension of the arrays a, irow, icol. (An error is raised if these dimensions are not equal.)
The number of nonzero elements in the matrix $A$.
Constraint: $1\le {\mathbf{nz}}\le {{\mathbf{n}}}^{2}$.

Output Parameters

1:     $\mathrm{y}\left({\mathbf{n}}\right)$ – complex array
The vector $y$.
2:     $\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:
${\mathbf{ifail}}=1$
 On entry, ${\mathbf{trans}}\ne \text{'N'}$ or $\text{'T'}$, or ${\mathbf{check}}\ne \text{'C'}$ or $\text{'N'}$.
${\mathbf{ifail}}=2$
 On entry, ${\mathbf{n}}<1$, or ${\mathbf{nz}}<1$, or ${\mathbf{nz}}>{{\mathbf{n}}}^{2}$.
${\mathbf{ifail}}=3$
On entry, the arrays irow and icol fail to satisfy the following constraints:
• $1\le {\mathbf{irow}}\left(i\right)\le {\mathbf{n}}$ and $1\le {\mathbf{icol}}\left(i\right)\le {\mathbf{n}}$, for $i=1,2,\dots ,{\mathbf{nz}}$;
• ${\mathbf{irow}}\left(i-1\right)<{\mathbf{irow}}\left(i\right)$, or ${\mathbf{irow}}\left(i-1\right)={\mathbf{irow}}\left(i\right)$ and ${\mathbf{icol}}\left(i-1\right)<{\mathbf{icol}}\left(i\right)$, for $i=2,3,\dots ,{\mathbf{nz}}$.
Therefore a nonzero element has been supplied which does not lie within the matrix $A$, is out of order, or has duplicate row and column indices. Call nag_sparse_complex_gen_sort (f11zn) to reorder and sum or remove duplicates.
${\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

The computed vector $y$ satisfies the error bound:
• ${‖y-Ax‖}_{\infty }\le c\left(n\right)\epsilon {‖A‖}_{\infty }{‖x‖}_{\infty }$, if ${\mathbf{trans}}=\text{'N'}$, or
• ${‖y-{A}^{\mathrm{H}}x‖}_{\infty }\le c\left(n\right)\epsilon {‖{A}^{\mathrm{H}}‖}_{\infty }{‖x‖}_{\infty }$, if ${\mathbf{trans}}=\text{'T'}$,
where $c\left(n\right)$ is a modest linear function of $n$, and $\epsilon$ is the machine precision

Timing

The time taken for a call to nag_sparse_complex_gen_matvec (f11xn) is proportional to nz.

Use of check

It is expected that a common use of nag_sparse_complex_gen_matvec (f11xn) will be to compute the matrix-vector product required in the application of nag_sparse_complex_gen_basic_solver (f11bs) to sparse complex linear systems. In this situation nag_sparse_complex_gen_matvec (f11xn) is likely to be called many times with the same matrix $A$. In the interests of both reliability and efficiency you are recommended to set ${\mathbf{check}}=\text{'C'}$ for the first of such calls, and to set ${\mathbf{check}}=\text{'N'}$ for all subsequent calls.

Example

This example reads in a complex sparse matrix $A$ and a vector $x$. It then calls nag_sparse_complex_gen_matvec (f11xn) to compute the matrix-vector product $y=Ax$ and the conjugate transposed matrix-vector product $y={A}^{\mathrm{H}}x$.
```function f11xn_example

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

a = [ 2 + 3i   1 - 4i                             ...
1 + 0i  -1 - 2i           ...
4 + 1i            0 + 1i             1 + 3i ...
0 - 1i    2 - 6i ...
-2 + 0i                      3 + 1i];
irow = [int64(1) 1   2 2   3 3 3   4 4   5 5];
icol = [int64(1) 2   3 4   1 3 5   4 5   2 5];
x = [ 0.70 + 0.21i;
0.16 - 0.43i;
0.52 + 0.97i;
0.77 + 0.00i;
0.28 - 0.64i];

% Calculate matrix-vector product
trans = 'N';
check = 'C';
[y, ifail] = f11xn( ...
trans, a, irow, icol, check, x);
fprintf('\nMatrix-vector product\n');
disp(y);

% Calculate conjugate transposed matrix-vector product
trans = 'T';
check = 'N';
[y, ifail] = f11xn( ...
trans, a, irow, icol, check, x);
fprintf('\nConjugate transposed matrix-vector product\n');
disp(y);

```
```f11xn example results

Matrix-vector product
-0.7900 + 1.4500i
-0.2500 - 0.5700i
3.8200 + 2.2600i
-3.2800 - 3.7300i
1.1600 - 0.7800i

Conjugate transposed matrix-vector product
5.0800 + 1.6800i
-0.7000 + 4.2900i
1.1300 - 0.9500i
0.7000 + 1.5200i
5.1700 + 1.8300i

```