## NF01BW

### Matrix-vector product x <-- (J' J + c I) x, for J in a compressed form

[Specification] [Arguments] [Method] [References] [Comments] [Example]

Purpose

      To compute the matrix-vector product x <-- (J'*J + c*I)*x, 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  /

Specification

          SUBROUTINE NF01BW( N, IPAR, LIPAR, DPAR, LDPAR, J, LDJ, X, INCX,
         $                   DWORK, LDWORK, INFO )
    C     .. Scalar Arguments ..
          INTEGER           INCX, INFO, LDJ, LDPAR, LDWORK, LIPAR, N
    C     .. Array Arguments ..
          DOUBLE PRECISION  DPAR(*), DWORK(*), J(LDJ,*), X(*)
          INTEGER           IPAR(*)

Arguments

Input/Output Parameters

      N       (input) INTEGER
              The dimension of the vector x.
              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).

      X       (input/output) DOUBLE PRECISION array, dimension
              (1+(N-1)*INCX)
              On entry, this incremented array must contain the
              vector x.
              On exit, this incremented array contains the value of the
              matrix-vector product (J'*J + c*I)*x.

      INCX    (input) INTEGER
              The increment for the elements of X.  INCX >= 1.

Workspace

      DWORK   DOUBLE PRECISION array, dimension (LDWORK)

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

Error Indicator

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

Method

      The associativity of matrix multiplications is used; the result
      is obtained as:  x_out = J'*( J*x ) + c*x.

Further Comments

      None

Example

Program Text

      None

Program Data

      None

Program Results

      None

Return to Supporting Routines index