CXML

duskys 


FORMAT

  DUSKYS (n, au, iaudiag, nau, al, ialdiag, nal, 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, if  istore = 1 or 2,  au contains the factors
                      U and D of the L*D*U factorization of the matrix A.
                      Array AU is of length at least nau, where nau is the
                      envelope size of the upper triangular part of A,
                      including the diagonal.  If  istore = 3, then  au
                      contains the L*D*U factorization of the matrix A.  In
                      this case, array AU is of length at least nau, where
                      nau is the envelope size of the matrix A. The L*D*U
                      factorization has been obtained by a prior call to the
                      routine DUSKYF.   au must remain unchanged between
                      calls to the routines DUSKYF and DUSKYS.
                      On exit,  au is unchanged.

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

  nau                 integer*4
                      On entry, the number of elements stored in array AU.
                      If  istore = 1 or 2, then nau is the envelope size of
                      the upper triangular part of the matrix A. If  istore =
                      3, then nau is the envelope size of the matrix A. For
                      the profile-in and the structurally symmetric profile-
                      in storage modes, nau =  IAUDIAG(n).  For the
                      diagonal-out storage mode, nau =  IAUDIAG(n+1) - 1.
                      On exit,  nau is unchanged.

   al                 real*8
                      On entry, if  istore = 1 or 2,  al contains the factor
                      L of the L*D*U factorization of the matrix A. Array AL
                      is of length at least nal, where nal is the envelope
                      size of the lower triangular part of A, including the
                      diagonal.  If  istore = 3, then  al is a dummy
                      argument. The L*D*U factorization is obtained from a
                      prior call to the routine DUSKYF.  al must remain
                      unchanged between calls to the routines DUSKYF and
                      DUSKYS.
                      On exit,   al is unchanged.

   ialdiag            integer*4
                      On entry, an array containing the pointers to the
                      locations of the diagonal elements in array AL.
                      ialdiag is of length at least n for the profile-in
                      storage mode.  ialdiag is of length at least n+1 for
                      the diagonal-out storage mode.  If  istore = 3, then
                      ialdiag is a dummy argument.
                      On exit,  ialdiag is unchanged.

   nal                integer*4
                      On entry, the number of elements stored in array AL.
                      If  istore = 1 or 2, then nal is also the envelope size
                      of the lower triangular part of the matrix A. For the
                      profile-in storage mode, nal = IALDIAG(n).  For the
                      diagonal-out storage mode, nal = IALDIAG(n+1) - 1.  If
                      istore = 3, then nal is a dummy argument.
                      On exit,  nal 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 dimension 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 may be unspecified.
                      On exit,  iparam(2) is unchanged.

  iparam(3): niwrk
                      On entry, defines the size of the integer work array,
                      IWRK.  niwrk >=4n.
                      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 may 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 DUSKYF.
                      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

                      IPARAM(9) = itrans = 0

                      If idefault = 1, then you must assign values to the
                      above variables before the call to the DUSKYF 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 unsymmetric
                      matrix A is stored using the profile-in storage mode;
                      if  istore = 2, the unsymmetric matrix A is stored
                      using the diagonal-out storage mode; if  istore = 3,
                      the unsymmetric matrix A is stored using the
                      structurally symmetric profile-in storage mode.  The
                      storage scheme used in the routines DUSKYF and DUSKYS
                      must be identical.  Default:  istore = 1.
                      On exit,  iparam(8) is unchanged.

  iparam(9): itrans
                      On entry, defines the form of matrix used in the
                      solution.  If  itrans = 0, the system solved is A X =
                      B; if  itrans = 1, the system solved is trans(A) X = B.
                      Default:  itrans = 0.
                      On exit,  iparam(9) is unchanged.

   rparam             real*8
                      On entry, an array containing the real parameters for
                      the solution.
                      On exit, rparam is unchanged.  rparam is not used by
                      the routine DUSKYS at present, but is reserved for
                      future use.

  iwrk                integer*4
                      On entry, an array of length at least 4n used for
                      integer workspace. The first 4n elements of the array
                      IWRK, generated by the routine DUSKYF, should be passed
                      unchanged to the routine DUSKYS.
                      On exit, the first 4n 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 DUSKYS, 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 DUSKYS.

Description

  DUSKYS solves the system

       A * X = B

  or

       trans(A) * X = B

  where A is an unsymmetric matrix stored in a skyline form, using either the
  profile-in storage mode, the diagonal-out storage mode, or the structurally
  symmetric profile-in 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 DUSKYS, the array BX contains the  nbx right sides; on exit, these
  are overwritten by the solution vectors.  The variable itrans determines
  whether the matrix A or trans(A) is used in the solution process.

  The matrix A has been factorized as

       A = L D U

  by a prior call to the routine DUSKYF. L is a unit lower triangular matrix,
  U is a unit upper triangular matrix, and D is a diagonal matrix.  The first
  4n elements of the integer workspace array IWRK, generated by DUSKYF,
  contain information for use by DUSKYS and therefore must remain unchanged
  between the calls to the routines DUSKYF and DUSKYS. The real work array
  RWRK is not used at present.  The storage scheme used in the routines
  DUSKYF and DUSKYS must be identical.

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

CXML Home Page

Index of CXML Routines