Solves the system of linear equations A*X=B. More...

#include "slu_sdefs.h"

Include dependency graph for sgssv.c:

Functions
void	sgssv (superlu_options_t options, SuperMatrix A, int perm_c, int perm_r, SuperMatrix L, SuperMatrix U, SuperMatrix B, SuperLUStat_t stat, int *info)
	Driver routines. More...

Detailed Description

The source code is distributed under BSD license, see the file License.txt at the top-level directory.

-- SuperLU routine (version 3.0) --
Univ. of California Berkeley, Xerox Palo Alto Research Center,
and Lawrence Berkeley National Lab.
October 15, 2003

Function Documentation

void sgssv	(	superlu_options_t *	options,
		SuperMatrix *	A,
		int *	perm_c,
		int *	perm_r,
		SuperMatrix *	L,
		SuperMatrix *	U,
		SuperMatrix *	B,
		SuperLUStat_t *	stat,
		int *	info
	)

Purpose

SGSSV solves the system of linear equations A*X=B, using the
LU factorization from SGSTRF. It performs the following steps:

  1. If A is stored column-wise (A->Stype = SLU_NC):

     1.1. Permute the columns of A, forming A*Pc, where Pc
          is a permutation matrix. For more details of this step, 
          see sp_preorder.c.

     1.2. Factor A as Pr*A*Pc=L*U with the permutation Pr determined
          by Gaussian elimination with partial pivoting.
          L is unit lower triangular with offdiagonal entries
          bounded by 1 in magnitude, and U is upper triangular.

     1.3. Solve the system of equations A*X=B using the factored
          form of A.

  2. If A is stored row-wise (A->Stype = SLU_NR), apply the
     above algorithm to the transpose of A:

     2.1. Permute columns of transpose(A) (rows of A),
          forming transpose(A)*Pc, where Pc is a permutation matrix. 
          For more details of this step, see sp_preorder.c.

     2.2. Factor A as Pr*transpose(A)*Pc=L*U with the permutation Pr
          determined by Gaussian elimination with partial pivoting.
          L is unit lower triangular with offdiagonal entries
          bounded by 1 in magnitude, and U is upper triangular.

     2.3. Solve the system of equations A*X=B using the factored
          form of A.

  See supermatrix.h for the definition of 'SuperMatrix' structure.

Arguments

options (input) superlu_options_t*
        The structure defines the input parameters to control
        how the LU decomposition will be performed and how the
        system will be solved.

A       (input) SuperMatrix*
        Matrix A in A*X=B, of dimension (A->nrow, A->ncol). The number
        of linear equations is A->nrow. Currently, the type of A can be:
        Stype = SLU_NC or SLU_NR; Dtype = SLU_S; Mtype = SLU_GE.
        In the future, more general A may be handled.

perm_c  (input/output) int*
        If A->Stype = SLU_NC, column permutation vector of size A->ncol
        which defines the permutation matrix Pc; perm_c[i] = j means 
        column i of A is in position j in A*Pc.
        If A->Stype = SLU_NR, column permutation vector of size A->nrow
        which describes permutation of columns of transpose(A) 
        (rows of A) as described above.

        If options->ColPerm = MY_PERMC or options->Fact = SamePattern or
           options->Fact = SamePattern_SameRowPerm, it is an input argument.
           On exit, perm_c may be overwritten by the product of the input
           perm_c and a permutation that postorders the elimination tree
           of Pc'*A'*A*Pc; perm_c is not changed if the elimination tree
           is already in postorder.
        Otherwise, it is an output argument.

perm_r  (input/output) int*
        If A->Stype = SLU_NC, row permutation vector of size A->nrow, 
        which defines the permutation matrix Pr, and is determined 
        by partial pivoting.  perm_r[i] = j means row i of A is in 
        position j in Pr*A.
        If A->Stype = SLU_NR, permutation vector of size A->ncol, which
        determines permutation of rows of transpose(A)
        (columns of A) as described above.

        If options->RowPerm = MY_PERMR or
           options->Fact = SamePattern_SameRowPerm, perm_r is an
           input argument.
        otherwise it is an output argument.

L       (output) SuperMatrix*
        The factor L from the factorization 
            Pr*A*Pc=L*U              (if A->Stype = SLU_NC) or
            Pr*transpose(A)*Pc=L*U   (if A->Stype = SLU_NR).
        Uses compressed row subscripts storage for supernodes, i.e.,
        L has types: Stype = SLU_SC, Dtype = SLU_S, Mtype = SLU_TRLU.

U       (output) SuperMatrix*
        The factor U from the factorization 
            Pr*A*Pc=L*U              (if A->Stype = SLU_NC) or
            Pr*transpose(A)*Pc=L*U   (if A->Stype = SLU_NR).
        Uses column-wise storage scheme, i.e., U has types:
        Stype = SLU_NC, Dtype = SLU_S, Mtype = SLU_TRU.

B       (input/output) SuperMatrix*
        B has types: Stype = SLU_DN, Dtype = SLU_S, Mtype = SLU_GE.
        On entry, the right hand side matrix.
        On exit, the solution matrix if info = 0;

stat   (output) SuperLUStat_t*
       Record the statistics on runtime and floating-point operation count.
       See util.h for the definition of 'SuperLUStat_t'.

info    (output) int*
        = 0: successful exit
        > 0: if info = i, and i is
            <= A->ncol: U(i,i) is exactly zero. The factorization has
               been completed, but the factor U is exactly singular,
               so the solution could not be computed.
            > A->ncol: number of bytes allocated when memory allocation
               failure occurred, plus A->ncol.

Here is the call graph for this function:

Functions

Detailed Description

Function Documentation

Purpose

Arguments