cgssv.c File Reference

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

`#include "slu_cdefs.h"`
Include dependency graph for cgssv.c:

## Functions

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

## Detailed Description

Copyright (c) 2003, The Regents of the University of California, through Lawrence Berkeley National Laboratory (subject to receipt of any required approvals from U.S. Dept. of Energy)

All rights reserved.

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

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

## Function Documentation

## cgssv()

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

    Purpose
    =======

    CGSSV solves the system of linear equations A*X=B, using the
    LU factorization from CGSTRF. 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_C; 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_C, 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_C, Mtype = SLU_TRU.

    B       (input/output) SuperMatrix*
            B has types: Stype = SLU_DN, Dtype = SLU_C, 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: