hide long namesshow long names

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

PDF version (NAG web site, 64-bit version, 64-bit version)

Chapter Contents

Chapter Introduction

NAG Toolbox

NAG Toolbox: nag_sparse_direct_real_gen_solve (f11mf)

▸▿ Contents

1 Purpose

2 Syntax

3 Description

4 References

▸▿ 5 Parameters

5.1 Compulsory Input Parameters

5.2 Optional Input Parameters

5.3 Output Parameters

6 Error Indicators and Warnings

7 Accuracy

8 Further Comments

9 Example

Purpose

nag_sparse_direct_real_gen_solve (f11mf) solves a real sparse system of linear equations with multiple right-hand sides given an

L U

factorization of the sparse matrix computed by nag_sparse_direct_real_gen_lu (f11me).

Syntax

[b, ifail] = f11mf(trans, iprm, il, lval, iu, uval, b, 'n', n, 'nrhs_p', nrhs_p)

[b, ifail] = nag_sparse_direct_real_gen_solve(trans, iprm, il, lval, iu, uval, b, 'n', n, 'nrhs_p', nrhs_p)

Description

nag_sparse_direct_real_gen_solve (f11mf) solves a real system of linear equations with multiple right-hand sides

A X = B

A^{T} X = B

, according to the value of the argument trans, where the matrix factorization

P_{r} A P_{c} = L U

corresponds to an

L U

decomposition of a sparse matrix stored in compressed column (Harwell–Boeing) format, as computed by nag_sparse_direct_real_gen_lu (f11me).

In the above decomposition

L

is a lower triangular sparse matrix with unit diagonal elements and

U

is an upper triangular sparse matrix;

P_{r}

and

P_{c}

are permutation matrices.

References

None.

Parameters

Compulsory Input Parameters

1: $trans$ – string (length ≥ 1)

Specifies whether

A X = B

A^{T} X = B

is solved.

$trans ='N'$: $A X = B$ is solved.
$trans ='T'$: $A^{T} X = B$ is solved.

Constraint:

trans ='N'

'T'

2: $iprm (7 \times n)$ – int64int32nag_int array

The column permutation which defines

P_{c}

, the row permutation which defines

P_{r}

, plus associated data structures as computed by nag_sparse_direct_real_gen_lu (f11me).

3: $il (:)$ – int64int32nag_int array

The dimension of the array il must be at least as large as the dimension of the array of the same name in nag_sparse_direct_real_gen_lu (f11me)

Records the sparsity pattern of matrix

L

as computed by nag_sparse_direct_real_gen_lu (f11me).

4: $lval (:)$ – double array

The dimension of the array lval must be at least as large as the dimension of the array of the same name in nag_sparse_direct_real_gen_lu (f11me)

Records the nonzero values of matrix

L

and some nonzero values of matrix

U

as computed by nag_sparse_direct_real_gen_lu (f11me).

5: $iu (:)$ – int64int32nag_int array

The dimension of the array iu must be at least as large as the dimension of the array of the same name in nag_sparse_direct_real_gen_lu (f11me)

Records the sparsity pattern of matrix

U

as computed by nag_sparse_direct_real_gen_lu (f11me).

6: $uval (:)$ – double array

The dimension of the array uval must be at least as large as the dimension of the array of the same name in nag_sparse_direct_real_gen_lu (f11me)

Records some nonzero values of matrix

U

as computed by nag_sparse_direct_real_gen_lu (f11me).

7: $b (ldb :)$ – double array

The first dimension of the array b must be at least

\max (1, n)

The second dimension of the array b must be at least

\max (1, nrhs_p)

The

n

nrhs_p

right-hand side matrix

B

Optional Input Parameters

1: $n$ – int64int32nag_int scalar: Default: the first dimension of the array b.
$n$ , the order of the matrix $A$ .

Constraint: $n \geq 0$ .
2: $nrhs_p$ – int64int32nag_int scalar: Default: the second dimension of the array b.
$nrhs$ , the number of right-hand sides in $B$ .

Constraint: $nrhs_p \geq 0$ .

Output Parameters

1: $b (ldb :)$ – double array: The first dimension of the array b will be $\max (1, n)$ .
The second dimension of the array b will be $\max (1, nrhs_p)$ .

The $n$ by $nrhs_p$ solution matrix $X$ .
2: $ifail$ – int64int32nag_int scalar: $ifail = 0$ unless the function detects an error (see Error Indicators and Warnings).

Error Indicators and Warnings

Errors or warnings detected by the function:

$ifail = 1$: Constraint: $ldb \geq \max (1, n)$ .

Constraint: $n \geq 0$ .

Constraint: $nrhs_p \geq 0$ .

On entry, $trans =_$ .
Constraint: $trans ='N'$ or $'T'$ .

$ifail = 2$: Incorrect row permutations in array iprm.

$ifail = 3$: Incorrect column permutations in array iprm.

$ifail = - 99$: An unexpected error has been triggered by this routine. Please contact NAG.

$ifail = - 399$: Your licence key may have expired or may not have been installed correctly.

$ifail = - 999$: Dynamic memory allocation failed.

Accuracy

For each right-hand side vector

b

, the computed solution

x

is the exact solution of a perturbed system of equations

(A + E) x = b

, where

|E| \leq c (n) ε |L| |U|,

c (n)

is a modest linear function of

n

, and

ε

is the machine precision, when partial pivoting is used.

\hat{x}

is the true solution, then the computed solution

x

satisfies a forward error bound of the form

\frac{{‖x - \hat{x}‖}_{\infty}}{{‖x‖}_{\infty}} \leq c (n) cond (A, x) ε

where

cond (A, x) = {‖|A^{- 1}| |A| |x|‖}_{\infty} / {‖x‖}_{\infty} \leq cond (A) = {‖|A^{- 1}| |A|‖}_{\infty} \leq κ_{\infty} (A)

. Note that

cond (A, x)

can be much smaller than

cond (A)

, and

cond (A^{T})

can be much larger (or smaller) than

cond (A)

Forward and backward error bounds can be computed by calling nag_sparse_direct_real_gen_refine (f11mh), and an estimate for

κ_{\infty} (A)

can be obtained by calling nag_sparse_direct_real_gen_cond (f11mg).

Further Comments

nag_sparse_direct_real_gen_solve (f11mf) may be followed by a call to nag_sparse_direct_real_gen_refine (f11mh) to refine the solution and return an error estimate.

Example

This example solves the system of equations

A X = B

, where

A = (\begin{matrix} 2.00 & 1.00 & 0 & 0 & 0 \\ 0 & 0 & 1.00 & - 1.00 & 0 \\ 4.00 & 0 & 1.00 & 0 & 1.00 \\ 0 & 0 & 0 & 1.00 & 2.00 \\ 0 & - 2.00 & 0 & 0 & 3.00 \end{matrix}) and B = (\begin{matrix} 1.56 & 3.12 \\ - 0.25 & - 0.50 \\ 3.60 & 7.20 \\ 1.33 & 2.66 \\ 0.52 & 1.04 \end{matrix}) .

Here

A

is nonsymmetric and must first be factorized by nag_sparse_direct_real_gen_lu (f11me).

Open in the MATLAB editor: f11mf_example

function f11mf_example


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

% A and b
n = int64(5);
nz = int64(11);
icolzp = [int64(1); 3; 5; 7; 9; 12];
irowix = [int64(1); 3; 1; 5; 2; 3; 2; 4; 3; 4; 5];
a = [2; 4; 1; -2; 1; 1; -1; 1; 1; 2; 3];
b = [  1.56,  3.12;
      -0.25, -0.50;
       3.60,  7.20;
       1.33,  2.66;
       0.52,  1.04];


% Calculate COLAMD permutation
spec = 'M';
iprm = zeros(1, 7*n, 'int64');

[iprm, ifail] = f11md( ...
                       spec, n, icolzp, irowix, iprm);

% Factorise
thresh = 1;
nzlmx = int64(8*nz);
nzlumx = int64(8*nz);
nzumx = int64(8*nz);

[iprm, nzlumx, il, lval, iu, uval, nnzl, nnzu, flop, ifail] = ...
  f11me( ...
         n, irowix, a, iprm, thresh, nzlmx, nzlumx, nzumx);

% Solve
trans = 'N';
[x, ifail] = f11mf( ...
                    trans, iprm, il, lval, iu, uval, b);
disp('Solutions');
disp(x);

f11mf example results

Solutions
    0.7000    1.4000
    0.1600    0.3200
    0.5200    1.0400
    0.7700    1.5400
    0.2800    0.5600

PDF version (NAG web site, 64-bit version, 64-bit version)

Chapter Contents

Chapter Introduction

NAG Toolbox