CXML

duskyc 


FORMAT

  DUSKYC (n, au, iaudiag, nau, al, ialdiag, nal, 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 containing information on the L*D*U
                      factorization of the matrix A. The factorization has
                      been obtained by a previous call to the routine DUSKYF,
                      and  au must remain unchanged between the calls to
                      DUSKYF and DUSKYC.  If  istore = 1 or 2, then  au
                      contains the upper triangular part, including the
                      diagonal, of the factorization of the matrix A, stored
                      in the profile-in or diagonal-out mode, respectively.
                      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,
                      stored in the structurally symmetric, profile-in
                      storage mode. In this case, array AU is of length at
                      least nau, where nau is the envelope size of the matrix
                      A.
                      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, an array containing information on the L*D*U
                      factorization of the matrix A. The factorization has
                      been obtained by a previous call to the routine DUSKYF
                      and  al must remain unchanged between the calls to the
                      routines DUSKYF and DUSKYC.  If  istore = 1 or 2, then
                      al contains the lower triangular part, including the
                      diagonal, of the L*D*U factorization of the matrix A,
                      stored in the profile-in or diagonal-out mode,
                      respectively. Storage is allocated for the diagonal
                      elements, though the elements themselves are stored as
                      part of au. 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.
                      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 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.

  iparam              integer*4
                      An array of length at least 100, containing the integer
                      parameters for the condition number estimator.

  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.
                      nrparam >= 100.
                      On exit,  iparam(2) is unchanged.

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

  iparam(4):  nrwrk
                      On entry, defines the size of the integer work array,
                      IWRK.  niwrk >= 2n.
                      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 DUSKYC.
                      The I/O unit must be opened in the calling subprogram.
                      If  iounit <= 0, then 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(2) = nrparam = 100

                      IPARAM(6) = iolevel = 0

                      IPARAM(8) = istore = 1

                      IPARAM(9) = inorm = 1

                      If idefault = 1, then you must assign values to the
                      above variables before the call to the DUSKYC 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 storage mode.  Default:  istore
                      = 1.
                      On exit,  iparam(8) is unchanged.

  iparam(9): inorm
                      On entry, defines the matrix quantity to be evaluated:

                       inorm = 1 : 1-norm

                       inorm = 2 : Infinity-norm

                      On exit,  iparam(9) is unchanged.

   rparam             real*8
                      An array of length at least 100, containing the real
                      parameters for the condition number estimator.

  rparam(1): anorm
                      On entry, rparam(1) contains the norm of the matrix A
                      that has been obtained by a prior call to the routine
                      DUSKYN. If  inorm = 1, then  anorm must contain the 1-
                      norm of A. If  inorm = 2, then  anorm must contain the
                      Infinity-norm of A.
                      On exit,  rparam(1) is unchanged.

  rparam(2): ainorm
                      On entry,  rparam(2) is an unspecified variable.
                      On exit,  rparam(2) contains the estimate of the norm
                      of the matrix inverse(A)) that is evaluated by the
                      routine DUSKYC.  If  inorm = 1, then  ainorm contains
                      the estimate of the 1-norm of inverse(A)). If  inorm =
                      2, then  ainorm contains the estimate of the Infinity-
                      norm of inverse(A)).

  rparam(3): rcond
                      On entry,  rparam(3) is an unspecified variable.
                      On exit,  rparam(3) contains the reciprocal of the
                      estimate of the condition number of the matrix A that
                      is evaluated by the routine DUSKYC.  If  inorm = 1,
                      then  rcond contains the reciprocal of the estimate of
                      the 1-norm condition number of A. If  inorm = 2, then
                      rcond contains the reciprocal of the estimate of the
                      Infinity-norm condition number of A.

  iwrk                integer*4
                      On entry, an array of length at least 5n used for
                      integer workspace.  The first 4n elements of the array
                      IWRK generated by the routine DUSKYF must be passed
                      unchanged to the routine DUSKYC.
                      On exit, the first 4n elements of iwrk are unchanged.
                      The next n elements are used as integer workspace by
                      the routine DUSKYC.

   rwrk               real*8
                      On entry, an array of length at least 2n used for real
                      workspace.
                      On exit, the first 2n elements of  rwrk are
                      overwritten.

   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 DUSKYC.

Description

  DUSKYC obtains the reciprocal of the estimate of the condition number of
  the unsymmetric matrix A as:

       rcond(A) = 1 / (||A|| * ||inverse(A)||)

  where either the 1-norm or the Infinity-norm is used.

  The 1-norm of inverse(A) or inv_transp(A) is obtained using the LAPACK
  routine DLACON, that uses Higham's modification [Higham 1988] of Hager's
  method [Hager 1984]. This routine uses reverse communication for the
  evaluation of matrix-vector products.  As the matrix under consideration is
  inverse(A) for the 1-norm case and inv_transp(A) for the Infinity-norm
  case, routine DUSKYC requires calls to the routine DUSKYS. Hence the first
  4n elements of the integer work array, IWRK, which are generated by the
  routine DUSKYF and used by the routine DUSKYS, must remain unchanged
  between the calls to the routines DUSKYF and DUSKYC.  The storage scheme
  used in the routines DUSKYF and DUSKYC must be identical.

CXML Home Page

Index of CXML Routines