NF01BU

Computation of the matrix J' J + c I, for the Jacobian J given in a compressed form

Purpose

  To compute the matrix J'*J + c*I, for the Jacobian J as received
  from SLICOT Library routine NF01BD:

       /  dy(1)/dwb(1)  |  dy(1)/dtheta  \
  Jc = |       :        |       :        | .
       \  dy(L)/dwb(L)  |  dy(L)/dtheta  /

  This is a compressed representation of the actual structure

      /   J_1    0    ..   0   |  L_1  \
      |    0    J_2   ..   0   |  L_2  |
  J = |    :     :    ..   :   |   :   | .
      |    :     :    ..   :   |   :   |
      \    0     0    ..  J_L  |  L_L  /

      SUBROUTINE NF01BU( STOR, UPLO, N, IPAR, LIPAR, DPAR, LDPAR, J,
     $                   LDJ, JTJ, LDJTJ, DWORK, LDWORK, INFO )
C     .. Scalar Arguments ..
      CHARACTER         STOR, UPLO
      INTEGER           INFO, LDJ, LDJTJ, LDPAR, LDWORK, LIPAR, N
C     .. Array Arguments ..
      DOUBLE PRECISION  DPAR(*), DWORK(*), J(LDJ,*), JTJ(*)
      INTEGER           IPAR(*)

Mode Parameters

  STOR    CHARACTER*1
          Specifies the storage scheme for the symmetric
          matrix J'*J + c*I, as follows:
          = 'F' :  full storage is used;
          = 'P' :  packed storage is used.

  UPLO    CHARACTER*1
          Specifies which part of the matrix J'*J + c*I is stored,
          as follows:
          = 'U' :  the upper triagular part is stored;
          = 'L' :  the lower triagular part is stored.

  N       (input) INTEGER
          The order of the matrix J'*J + c*I.
          N = BN*BSN + ST >= 0.  (See parameter description below.)

  IPAR    (input) INTEGER array, dimension (LIPAR)
          The integer parameters describing the structure of the
          matrix J, as follows:
          IPAR(1) must contain ST, the number of parameters
                  corresponding to the linear part.  ST >= 0.
          IPAR(2) must contain BN, the number of blocks, BN = L,
                  for the parameters corresponding to the nonlinear
                  part.  BN >= 0.
          IPAR(3) must contain BSM, the number of rows of the blocks
                  J_k = dy(k)/dwb(k), k = 1:BN, if BN > 0, or the
                  number of rows of the matrix J, if BN <= 1.
          IPAR(4) must contain BSN, the number of columns of the
                  blocks J_k, k = 1:BN.  BSN >= 0.

  LIPAR   (input) INTEGER
          The length of the array IPAR.  LIPAR >= 4.

  DPAR    (input) DOUBLE PRECISION array, dimension (LDPAR)
          The real parameters needed for solving the problem.
          The entry DPAR(1) must contain the real scalar c.

  LDPAR   (input) INTEGER
          The length of the array DPAR.  LDPAR >= 1.

  J       (input) DOUBLE PRECISION array, dimension (LDJ, NC)
          where NC = N if BN <= 1, and NC = BSN+ST, if BN > 1.
          The leading NR-by-NC part of this array must contain
          the (compressed) representation (Jc) of the Jacobian
          matrix J, where NR = BSM if BN <= 1, and NR = BN*BSM,
          if BN > 1.

  LDJ     (input) INTEGER
          The leading dimension of array J.  LDJ >= MAX(1,NR).

  JTJ     (output) DOUBLE PRECISION array,
                   dimension (LDJTJ,N),    if STOR = 'F',
                   dimension (N*(N+1)/2),  if STOR = 'P'.
          The leading N-by-N (if STOR = 'F'), or N*(N+1)/2 (if
          STOR = 'P') part of this array contains the upper or
          lower triangle of the matrix J'*J + c*I, depending on
          UPLO = 'U', or UPLO = 'L', respectively, stored either as
          a two-dimensional, or one-dimensional array, depending
          on STOR.

  LDJTJ   INTEGER
          The leading dimension of the array JTJ.
          LDJTJ >= MAX(1,N), if STOR = 'F'.
          LDJTJ >= 1,        if STOR = 'P'.

  DWORK   DOUBLE PRECISION array, dimension (LDWORK)
          Currently, this array is not used.

  LDWORK  INTEGER
          The length of the array DWORK.  LDWORK >= 0.

  INFO    INTEGER
          = 0:  successful exit;
          < 0:  if INFO = -i, the i-th argument had an illegal
                value.

  The matrix product is computed columnn-wise, exploiting the
  symmetry. BLAS 3 routines DGEMM and DSYRK are used if STOR = 'F',
  and BLAS 2 routine DGEMV is used if STOR = 'P'.

  None

Program Text

  None

  None

  None