IRIX Base Documentation 2002 November/SGI IRIX Base Documentation 2002 November.iso/usr/share/catman/p_man/cat3/SCSL/intro_solvers.z/intro_solvers

Text File | 2002-10-03 | 12.2 KB | 199 lines

IIIINNNNTTTTRRRROOOO____SSSSOOOOLLLLVVVVEEEERRRRSSSS((((3333SSSS))))                                            IIIINNNNTTTTRRRROOOO____SSSSOOOOLLLLVVVVEEEERRRRSSSS((((3333SSSS))))



NNNNAAAAMMMMEEEE
     IIIINNNNTTTTRRRROOOO____SSSSOOOOLLLLVVVVEEEERRRRSSSS - Introduction to SGI-developed linear equation solvers

IIIIMMMMPPPPLLLLEEEEMMMMEEEENNNNTTTTAAAATTTTIIIIOOOONNNN
     See individual man pages for implementation information

DDDDEEEESSSSCCCCRRRRIIIIPPPPTTTTIIIIOOOONNNN
     SCSL provides two direct solvers, PPPPSSSSLLLLDDDDLLLLTTTT and PPPPSSSSLLLLDDDDUUUU, and one iterative
     solver, DDDDIIIItttteeeerrrraaaattttiiiivvvveeee, for sparse linear systems of equations.  These
     solvers are optimized and parallelized for the SGI platforms.  For direct
     solvers for dense linear systems of equations, see the IIIINNNNTTTTRRRROOOO____LLLLAAAAPPPPAAAACCCCKKKK(3S)
     man page.

     The following data types are used in these routines:

     *   Double precision: Fortran "double precision" data type, C/C++
         "double" data type, 64-bit floating point; these routine names begin
         with DDDD.

     *   Double precision complex: Fortran "double complex" data type, C/C++
         "scsl_zomplex" data type (defined in <<<<ssssccccssssllll____ssssppppaaaarrrrsssseeee....hhhh>>>>), C++ STL
         "complex<double>" data type (defined in <<<<ccccoooommmmpppplllleeeexxxx....hhhh>>>>), two 64-bit
         floating point doubles; these routine names begin with ZZZZ.

     By default, the integer arguments are 4 bytes (32 bits) in size; this is
     the size obtained when one links to the SCSL library with ----llllssssccccssss or
     ----llllssssccccssss____mmmmpppp. Another version of SCSL is available, however, in which
     integers are 8 bytes (64 bits).  This version allows the user access to
     larger memory sizes and helps when porting legacy Cray codes.  It can be
     loaded by using either the ----llllssssccccssss____iiii8888 or ----llllssssccccssss____iiii8888____mmmmpppp link option.  Note
     that any program may use only one of the two versions; 4-byte integer and
     8-byte integer library calls cannot be mixed.

     C/C++ function prototypes for sparse solver routines are provided in
     <<<<ssssccccssssllll____ssssppppaaaarrrrsssseeee....hhhh>>>>, when using the default 4-byte integers, and
     <<<<ssssccccssssllll____ssssppppaaaarrrrsssseeee____iiii8888....hhhh>>>>, when using 8-byte integers. These header files define
     the complex types ssssccccssssllll____ccccoooommmmpppplllleeeexxxx and ssssccccssssllll____zzzzoooommmmpppplllleeeexxxx, which are used in the
     prototypes. Alternatively, C++ programs may declare arguments using the
     types ccccoooommmmpppplllleeeexxxx<<<<ffffllllooooaaaatttt>>>> and ccccoooommmmpppplllleeeexxxx<<<<ddddoooouuuubbbblllleeee>>>> from the standard template
     library. But if these types are used, <<<<ccccoooommmmpppplllleeeexxxx....hhhh>>>> must be included before
     <<<<ssssccccssssllll____ssssppppaaaarrrrsssseeee....hhhh>>>> (or <<<<ssssccccssssllll____ssssppppaaaarrrrsssseeee____iiii8888....hhhh>>>>). Note, though, that both complex
     types are equivalent: they simply represent (real, imaginary) pairs of
     floating point numbers stored contiguously in memory. With the proper
     casts, you can simply pass arrays of floating point data to the routines
     where complex arguments are expected.

     Casts, however, can be avoided. The header files <<<<ssssccccssssllll____ssssppppaaaarrrrsssseeee....hhhh>>>> and
     <<<<ssssccccssssllll____ssssppppaaaarrrrsssseeee____iiii8888....hhhh>>>> directly support the use of user-defined complex types
     or disabling prototype checking for complex arguments completely.  By
     defining the symbol SSSSCCCCSSSSLLLL____VVVVOOOOIIIIDDDD____AAAARRRRGGGGSSSS before including <<<<ssssccccssssllll____ssssppppaaaarrrrsssseeee....hhhh>>>> or
     <<<<ssssccccssssllll____ssssppppaaaarrrrsssseeee____iiii8888....hhhh>>>> all complex arguments will be prototyped as vvvvooooiiiidddd ****.
     To define the symbol SSSSCCCCSSSSLLLL____VVVVOOOOIIIIDDDD____AAAARRRRGGGGSSSS at compile time use the ----DDDD compiler



                                                                        PPPPaaaaggggeeee 1111






IIIINNNNTTTTRRRROOOO____SSSSOOOOLLLLVVVVEEEERRRRSSSS((((3333SSSS))))                                            IIIINNNNTTTTRRRROOOO____SSSSOOOOLLLLVVVVEEEERRRRSSSS((((3333SSSS))))



     option (i.e., ----DDDDSSSSCCCCSSSSLLLL____VVVVOOOOIIIIDDDD____AAAARRRRGGGGSSSS) or use an explicit ####ddddeeeeffffiiiinnnneeee SSSSCCCCSSSSLLLL____VVVVOOOOIIIIDDDD____AAAARRRRGGGGSSSS
     in the source code.  This allows the use of any complex data structure
     without warnings from the compiler, provided the structure is as
     described above; that is:

     1.   The real and imaginary components must be contiguous in memory.

     2.   Sequential array elements must also be contiguous in memory.

     While this allows the use of non-standard complex types without
     generating compiler warnings, it has the disadvantage that the compiler
     will not catch type mismatches.

     Strong type checking can be enabled employing user-defined complex types
     instead of SCSL's standard complex types. To do this, define
     SSSSCCCCSSSSLLLL____UUUUSSSSEEEERRRR____CCCCOOOOMMMMPPPPLLLLEEEEXXXX____TTTT====_m_y__c_o_m_p_l_e_x and SSSSCCCCSSSSLLLL____UUUUSSSSEEEERRRR____ZZZZOOOOMMMMPPPPLLLLEEEEXXXX____TTTT====_m_y__z_o_m_p_l_e_x, where
     _m_y__c_o_m_p_l_e_x and _m_y__z_o_m_p_l_e_x are the names of user-defined complex types.
     These complex types must be defined before including the <<<<ssssccccssssllll____ssssppppaaaarrrrsssseeee....hhhh>>>>
     (or <<<<ssssccccssssllll____ssssppppaaaarrrrsssseeee____iiii8888....hhhh>>>>) header file.

     Fortran 90 users on IRIX systems can perform compile-time checking of
     SCSL sparse solver subroutine and function calls by adding UUUUSSSSEEEE
     SSSSCCCCSSSSLLLL____SSSSPPPPAAAARRRRSSSSEEEE (for 4-byte integer arguments) or UUUUSSSSEEEE SSSSCCCCSSSSLLLL____SSSSPPPPAAAARRRRSSSSEEEE____IIII8888 (for 8-
     byte integer arguments) to the source code from which the sparse solver
     calls are made.  Alternatively, the compile-time checking can be invoked
     without any source code modifications by using the ----aaaauuuuttttoooo____uuuusssseeee compiler
     option, e.g.,

          f90 -auto_use SCSL_SPARSE test.f -lscs
          f90 -auto_use SCSL_SPARSE_I8 -i8 test.f -lscs_i8


DDDDiiiirrrreeeecccctttt ssssoooollllvvvveeeerrrr rrrroooouuuuttttiiiinnnneeeessss
     DDDDPPPPSSSSLLLLDDDDLLLLTTTT and ZZZZPPPPSSSSLLLLDDDDLLLLTTTT solve sparse symmetric linear systems of the form _A_x
     = _b where _A is an _n-by-_n symmetric input matrix, _b is an input vector of
     length _n, and _x is a vector of unknowns of length _n.

     The symmetric solver uses a direct method. _A is factored into the
     following form:

          _A = _L _D _L_T

     where _L is a lower triangular matrix with unit diagonal and _D is a
     diagonal matrix.

     The symmetric solver supports both real and complex double precision data
     types and is available in the multi-processing versions of SCSL.  See the
     DDDDPPPPSSSSLLLLDDDDLLLLTTTT(3S) and ZZZZPPPPSSSSLLLLDDDDLLLLTTTT(3S) man pages for details.

     DDDDPPPPSSSSLLLLDDDDUUUU and ZZZZPPPPSSSSLLLLDDDDUUUU solve sparse unsymmetric linear systems of the form _A_x
     = _b where _A is an _n-by-_n input matrix with symmetric non-zero pattern but
     unsymmetric non-zero values, _b is an input vector of length _n, and _x is a



                                                                        PPPPaaaaggggeeee 2222






IIIINNNNTTTTRRRROOOO____SSSSOOOOLLLLVVVVEEEERRRRSSSS((((3333SSSS))))                                            IIIINNNNTTTTRRRROOOO____SSSSOOOOLLLLVVVVEEEERRRRSSSS((((3333SSSS))))



     vector of unknowns of length _n.

     The unsymmetric solver uses a direct method. _A is factored into the
     following form:

          _A = _L _D _U

     where _L is a lower triangular matrix with unit diagonal, _D is a diagonal
     matrix, and _U is an upper triangular matrix with unit diagonal.

     The unsymmetric solver supports both real and complex double precision
     data types and is available in the multi-processing versions of SCSL. See
     the DDDDPPPPSSSSLLLLDDDDUUUU(3S) and ZZZZPPPPSSSSLLLLDDDDUUUU(3S) man pages for details.

IIIItttteeeerrrraaaattttiiiivvvveeee ssssoooollllvvvveeeerrrr rrrroooouuuuttttiiiinnnneeeessss
     DDDDIIIItttteeeerrrraaaattttiiiivvvveeee solves sparse linear systems of the form _A_x = _b where _A is a
     _n-by-_n sparse input matrix in Compressed Sparse Column (CSC) or
     Compressed Sparse Row (CSR) format, _b is an input vector of length _n, and
     _x is a vector of unknowns of length _n.

     The iterative solver uses on of four preconditioned iterative methods:
     conjugate gradient (CG) and conjugate residual (CR) for symmetric
     systems, and conjugate gradient squared (CGS) and BiCGSTAB, a variant of
     of CGS with smoother convergence properties,  for unsymmetric systems.
     Four different types of preconditioners are available: Jacobi, symmetric
     successive over-relaxation (SSOR), ILDLT (incomplete LDLT) by pattern,
     and ILDLT by value. The ILDLT preconditioners are only available for
     symmetric matrices, and ILDLT by value is currently not parallel.

     The iterative solver supports only real double precision data.  See the
     IIIITTTTEEEERRRRAAAATTTTIIIIVVVVEEEE(3S) man page for details.

NNNNOOOOTTTTEEEESSSS
     No pivoting is done in the direct sparse solver routines.

     SCSL does not currently support reshaped arrays.

SSSSEEEEEEEE AAAALLLLSSSSOOOO
     IIIINNNNTTTTRRRROOOO____SSSSCCCCSSSSLLLL(3S), IIIINNNNTTTTRRRROOOO____LLLLAAAAPPPPAAAACCCCKKKK(3S)













                                                                        PPPPaaaaggggeeee 3333