CXML

dsskys 


FORMAT

  DSSKYS
   (n, au, iaudiag, nau, bx, ldbx, nbx, iparam, rparam, iwrk, rwrk, ierror)

Arguments

  n                   integer*4
                      On entry, the order of the matrix A.
                      On exit, n is unchanged.

  au                  real*8
                      On entry, an array of length at least nau, containing
                      the transp(U)*D*U factorization of the matrix A stored
                      in the skyline storage scheme, using either the
                      profile-in or the diagonal-out storage mode. The
                      factorization has been obtained by a prior call to the
                      routine DSSKYF.  au must remain unchanged between calls
                      to the routines DSSKYF and DSSKYS.
                      On exit,  au is unchanged.

  iaudiag             integer*4
                      On entry, an array of length at least n for the
                      profile-in storage mode and (n+1) for the diagonal-out
                      storage mode, containing the pointers to the locations
                      of the diagonal elements in array AU.
                      On exit,  iaudiag is unchanged.

  nau                 integer*4
                      On entry, the number of elements in array AU. nau is
                      also the envelope size of the symmetric part of the
                      matrix A. For the profile-in storage mode, nau =
                      IAUDIAG(n).  For the diagonal-out storage mode, nau =
                      IAUDIAG(n+1) - 1.
                      On exit,  nau is unchanged.

  bx                  real*8
                      On entry, a two dimensional array BX of order ldbx by
                      at least nbx, containing the nbx right sides.
                      On exit, bx contains the solutions for the nbx systems.

  ldbx                integer*4
                      On entry, the leading dimensional of array BX. ldbx >=
                      n.
                      On exit, ldbx is unchanged.

  nbx                 integer*4
                      On entry, the number of right sides.
                      On exit, nbx is unchanged.

  iparam              integer*4
                      An array of length at least 100, containing the integer
                      parameters for the matrix solve operation.

  iparam(1): niparam
                      On entry, defines the length of the array IPARAM.
                      niparam >= 100.
                      On exit, iparam(1) is unchanged.

  iparam(2): nrparam
                      On entry, defines the length of the array RPARAM. As
                      the real parameter array is not used at present,
                      nrparam can be unspecified.
                      On exit,  iparam(2) is unchanged.

  iparam(3): niwrk
                      On entry, defines the size of the integer work array,
                      IWRK.  niwrk >=2n.
                      On exit,  iparam(3) is unchanged.

  iparam(4): nrwrk
                      On entry, defines the size of the real work array,
                      RWRK.  As the real work array is not used at present,
                      nrwrk can be unspecified.
                      On exit,  iparam(4) is unchanged.

  iparam(5): iounit
                      On entry, defines the I/O unit number for printing
                      error messages and information from the routine DSSKYS.
                      The I/O unit must be opened in the calling subprogram.
                      If iounit <= 0, no output is generated.
                      On exit,  iparam(5) is unchanged.

  iparam(6): iolevel
                      On entry, defines the message level that determines the
                      amount of information printed out to iounit, when
                      iounit > 0.

                      iolevel = 0 : fatal error messages only

                      iolevel = 1 : error messages and minimal information

                      iolevel = 2 : error messages and detailed information

                      On exit,  iparam(6) is unchanged.

  iparam(7): idefault
                      On entry, defines if the default values should be used
                      in arrays IPARAM and RPARAM. If idefault = 0, then the
                      following default values are assigned:

                      IPARAM(1) = niparam = 100

                      IPARAM(6) = iolevel = 0

                      IPARAM(8) = istore = 1

                      If idefault = 1, then you must assign values to the
                      above variables before the call to the DSSKYS routine.
                      On exit,  iparam(7) is unchanged.

  iparam(8): istore
                      On entry, defines the type of storage scheme used for
                      the skyline matrix.  If  istore = 1, the matrix A is
                      stored using the profile-in storage mode; if  istore =
                      2, the matrix A is stored using the diagonal-out
                      storage mode.  The storage scheme used in the routines
                      DSSKYF and DSSKYS must be identical.  Default:  istore
                      = 1.
                      On exit,  iparam(8) is unchanged.

   rparam             real*8
                      An array of length at least 100, containing the real
                      parameters for the solution.
                      On exit, rparam is unchanged.  rparam is not used by
                      the routine DSSKYS at present, but is reserved for
                      future use.  It can be a dummy variable.

  iwrk                integer*4
                      On entry, an array of length at least 2n used for
                      integer workspace. The first 2n elements of  the array
                      IWRK, generated by the routine DSSKYF, should be passed
                      unchanged to the routine DSSKYS.
                      On exit,  the first 2n elements of iwrk are unchanged.

   rwrk                real*8
                      On entry, an array used for real workspace.
                      On exit,  rwrk is unchanged.  Presently, rwrk is not
                      used by the routine DSSKYS, but is reserved for future
                      use.  It can be a dummy variable.

  ierror              integer*4
                      On entry, an unspecified variable.
                      On exit,  ierror contains the error flag. A value of
                      zero indicates a normal exit from the routine DSSKYS.

Description

  DSSKYS solves the system

       A X = B

  where A is a symmetric matrix stored in a skyline form, using either the
  profile-in storage mode or the diagonal-out storage mode; B is a matrix of
  nbx right sides and X is the matrix of the corresponding nbx solution
  vectors. On entry to the routine DSSKYS, the array BX contains the  nbx
  right sides; on exit, these are overwritten by the solution vectors.

  The matrix A has been factorized as A = transp(U)*D*U by a prior call to
  the routine DSSKYF. U is a unit upper triangular matrix and D is a diagonal
  matrix.  The first 2n elements of the integer workspace array IWRK,
  generated by DSSKYF, contain information for use by DSSKYS and therefore
  must remain unchanged between the calls to the routines DSSKYF and DSSKYS.

  The real work array, RWRK, is not used at present.  The storage scheme used
  in the routines DSSKYF and DSSKYS must be identical.

  Once the factorization has been obtained, the routine DSSKYS can be used to
  solve a system with multiple right hand sides, by setting nbx > 1.  The
  routine can also be called repeatedly, provided the first 2n elements of
  the work array IWRK remain unchanged between calls.

CXML Home Page

Index of CXML Routines