Loading...
Searching...
No Matches

## slals0()

subroutine slals0 | ( | integer | icompq,
|  | integer | nl,
|  | integer | nr,
|  | integer | sqre,
|  | integer | nrhs,
|  | real, dimension( ldb, * ) | b,
|  | integer | ldb,
|  | real, dimension( ldbx, * ) | bx,
|  | integer | ldbx,
|  | integer, dimension( * ) | perm,
|  | integer | givptr,
|  | integer, dimension( ldgcol, * ) | givcol,
|  | integer | ldgcol,
|  | real, dimension( ldgnum, * ) | givnum,
|  | integer | ldgnum,
|  | real, dimension( ldgnum, * ) | poles,
|  | real, dimension( * ) | difl,
|  | real, dimension( ldgnum, * ) | difr,
|  | real, dimension( * ) | z,
|  | integer | k,
|  | real | c,
|  | real | s,
|  | real, dimension( * ) | work,
|  | integer | info )

SLALS0 applies back multiplying factors in solving the least squares problem using divide and conquer SVD approach. Used by sgelsd.

Download SLALS0 + dependencies [TGZ] [ZIP] [TXT]

Purpose:

      !>
      !> SLALS0 applies back the multiplying factors of either the left or the
      !> right singular vector matrix of a diagonal matrix appended by a row
      !> to the right hand side matrix B in solving the least squares problem
      !> using the divide-and-conquer SVD approach.
      !>
      !> For the left singular vector matrix, three types of orthogonal
      !> matrices are involved:
      !>
      !> (1L) Givens rotations: the number of such rotations is GIVPTR; the
      !>      pairs of columns/rows they were applied to are stored in GIVCOL;
      !>      and the C- and S-values of these rotations are stored in GIVNUM.
      !>
      !> (2L) Permutation. The (NL+1)-st row of B is to be moved to the first
      !>      row, and for J=2:N, PERM(J)-th row of B is to be moved to the
      !>      J-th row.
      !>
      !> (3L) The left singular vector matrix of the remaining matrix.
      !>
      !> For the right singular vector matrix, four types of orthogonal
      !> matrices are involved:
      !>
      !> (1R) The right singular vector matrix of the remaining matrix.
      !>
      !> (2R) If SQRE = 1, one extra Givens rotation to generate the right
      !>      null space.
      !>
      !> (3R) The inverse transformation of (2L).
      !>
      !> (4R) The inverse transformation of (1L).
      !>

Parameters

  [in]

  ICOMPQ

      !>          ICOMPQ is INTEGER
      !>         Specifies whether singular vectors are to be computed in
      !>         factored form:
      !>         = 0: Left singular vector matrix.
      !>         = 1: Right singular vector matrix.
      !>

  [in]

  NL

      !>          NL is INTEGER
      !>         The row dimension of the upper block. NL >= 1.
      !>

  [in]

  NR

      !>          NR is INTEGER
      !>         The row dimension of the lower block. NR >= 1.
      !>

  [in]

  SQRE

      !>          SQRE is INTEGER
      !>         = 0: the lower block is an NR-by-NR square matrix.
      !>         = 1: the lower block is an NR-by-(NR+1) rectangular matrix.
      !>
      !>         The bidiagonal matrix has row dimension N = NL + NR + 1,
      !>         and column dimension M = N + SQRE.
      !>

  [in]

  NRHS

      !>          NRHS is INTEGER
      !>         The number of columns of B and BX. NRHS must be at least 1.
      !>

  [in,out]

  B

      !>          B is REAL array, dimension ( LDB, NRHS )
      !>         On input, B contains the right hand sides of the least
      !>         squares problem in rows 1 through M. On output, B contains
      !>         the solution X in rows 1 through N.
      !>

  [in]

  LDB

      !>          LDB is INTEGER
      !>         The leading dimension of B. LDB must be at least
      !>         max(1,MAX( M, N ) ).
      !>

  [out]

  BX

      !>          BX is REAL array, dimension ( LDBX, NRHS )
      !>

  [in]

  LDBX

      !>          LDBX is INTEGER
      !>         The leading dimension of BX.
      !>

  [in]

  PERM

      !>          PERM is INTEGER array, dimension ( N )
      !>         The permutations (from deflation and sorting) applied
      !>         to the two blocks.
      !>

  [in]

  GIVPTR

      !>          GIVPTR is INTEGER
      !>         The number of Givens rotations which took place in this
      !>         subproblem.
      !>

  [in]

  GIVCOL

      !>          GIVCOL is INTEGER array, dimension ( LDGCOL, 2 )
      !>         Each pair of numbers indicates a pair of rows/columns
      !>         involved in a Givens rotation.
      !>

  [in]

  LDGCOL

      !>          LDGCOL is INTEGER
      !>         The leading dimension of GIVCOL, must be at least N.
      !>

  [in]

  GIVNUM

      !>          GIVNUM is REAL array, dimension ( LDGNUM, 2 )
      !>         Each number indicates the C or S value used in the
      !>         corresponding Givens rotation.
      !>

  [in]

  LDGNUM

      !>          LDGNUM is INTEGER
      !>         The leading dimension of arrays DIFR, POLES and
      !>         GIVNUM, must be at least K.
      !>

  [in]

  POLES

      !>          POLES is REAL array, dimension ( LDGNUM, 2 )
      !>         On entry, POLES(1:K, 1) contains the new singular
      !>         values obtained from solving the secular equation, and
      !>         POLES(1:K, 2) is an array containing the poles in the secular
      !>         equation.
      !>

  [in]

  DIFL

      !>          DIFL is REAL array, dimension ( K ).
      !>         On entry, DIFL(I) is the distance between I-th updated
      !>         (undeflated) singular value and the I-th (undeflated) old
      !>         singular value.
      !>

  [in]

  DIFR

      !>          DIFR is REAL array, dimension ( LDGNUM, 2 ).
      !>         On entry, DIFR(I, 1) contains the distances between I-th
      !>         updated (undeflated) singular value and the I+1-th
      !>         (undeflated) old singular value. And DIFR(I, 2) is the
      !>         normalizing factor for the I-th right singular vector.
      !>

  [in]

  Z

      !>          Z is REAL array, dimension ( K )
      !>         Contain the components of the deflation-adjusted updating row
      !>         vector.
      !>

  [in]

  K

      !>          K is INTEGER
      !>         Contains the dimension of the non-deflated matrix,
      !>         This is the order of the related secular equation. 1 <= K <=N.
      !>

  [in]

  C

      !>          C is REAL
      !>         C contains garbage if SQRE =0 and the C-value of a Givens
      !>         rotation related to the right null space if SQRE = 1.
      !>

  [in]

  S

      !>          S is REAL
      !>         S contains garbage if SQRE =0 and the S-value of a Givens
      !>         rotation related to the right null space if SQRE = 1.
      !>

  [out]

  WORK

      !>          WORK is REAL array, dimension ( K )
      !>

  [out]

  INFO

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

Author
  Univ. of Tennessee
  Univ. of California Berkeley
  Univ. of Colorado Denver
  NAG Ltd.

Contributors:
  Ming Gu and Ren-Cang Li, Computer Science Division, University of California at Berkeley, USA
  Osni Marques, LBNL/NERSC, USA