dsskyn 

Symmetric sparse matrix norm evaluation using skyline storage scheme

FORMAT

  DSSKYN
   (n, au, iaudiag, nau, 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 matrix A stored in the skyline storage scheme,
                      using either the profile-in or the diagonal-out storage
                      mode.
                      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.

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

  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 >= n.
                      On exit,  iparam(3) is unchanged.

  iparam(4): nrwrk
                      On entry, defines the size of the real work array,
                      RWRK.  nrwrk >= n
                      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 DSSKYN.
                      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(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 DSSKYN 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.  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 of A

                       inorm = 2 : Infinity-norm of A

                       inorm = 3 : Frobenius norm of A

                       inorm = 4 : Maximum absolute value of A

                      Default:  inorm = 1.
                      On exit,  iparam(9) is unchanged.

  rparam              real*8
                      An array of length at least 100, containing the real
                      parameters for the norm evaluation.

  rparam(1): anorm
                      On entry, an unspecified variable.
                      On exit,  rparam(1) contains the matrix quantity
                      evaluated, as defined by the value of IPARAM(9) =
                      inorm.

  iwrk                integer*4
                      On entry, an array of length at least n used for
                      integer workspace.
                      On exit,  iwrk contains information used by the routine
                      DSSKYN. This information is not used by any other
                      routine and therefore can be overwritten.

   rwrk                real*8
                      On entry, an array of length at least n used for real
                      workspace.
                      On exit,  rwrk contains information used by the routine
                      DSSKYN. This information is not used by any other
                      routine and therefore can be 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 DSSKYN.

Description

  DSSKYN evaluates the following quantities for the symmetric matrix A:

  •  1-norm of (A)

  •  Infinity-norm of (A)

  •  Frobenius-norm of (A)

  •  Largest absolute value of (A)

  The last quantity in the above list is not a matrix norm. The quantity
  evaluated is determined by the value of  inorm, with the 1-norm and
  Infinity-norm being identical for symmetric matrices.

  The real and integer workspace used by the routine DSSKYN do not contain
  information for use by any other routines, and can therefore be
  overwritten.

  As the routine DSSKYN requires the matrix A, it should be called prior to a
  call to the factorization routine DSSKYF, which overwrites the elements of
  A by its transp(U)*D*U factorization.