[BACK]Return to dlaqtr.f CVS log [TXT] [DIR] Up to [local] / rpl / lapack / lapack

Diff for /rpl/lapack/lapack/dlaqtr.f between versions 1.3 and 1.19

version 1.3, 2010/08/06 15:28:41 version 1.19, 2023/08/07 08:38:56
Line 1 Line 1
   *> \brief \b DLAQTR solves a real quasi-triangular system of equations, or a complex quasi-triangular system of special form, in real arithmetic.
   *
   *  =========== DOCUMENTATION ===========
   *
   * Online html documentation available at
   *            http://www.netlib.org/lapack/explore-html/
   *
   *> \htmlonly
   *> Download DLAQTR + dependencies
   *> <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/dlaqtr.f">
   *> [TGZ]</a>
   *> <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/dlaqtr.f">
   *> [ZIP]</a>
   *> <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/dlaqtr.f">
   *> [TXT]</a>
   *> \endhtmlonly
   *
   *  Definition:
   *  ===========
   *
   *       SUBROUTINE DLAQTR( LTRAN, LREAL, N, T, LDT, B, W, SCALE, X, WORK,
   *                          INFO )
   *
   *       .. Scalar Arguments ..
   *       LOGICAL            LREAL, LTRAN
   *       INTEGER            INFO, LDT, N
   *       DOUBLE PRECISION   SCALE, W
   *       ..
   *       .. Array Arguments ..
   *       DOUBLE PRECISION   B( * ), T( LDT, * ), WORK( * ), X( * )
   *       ..
   *
   *
   *> \par Purpose:
   *  =============
   *>
   *> \verbatim
   *>
   *> DLAQTR solves the real quasi-triangular system
   *>
   *>              op(T)*p = scale*c,               if LREAL = .TRUE.
   *>
   *> or the complex quasi-triangular systems
   *>
   *>            op(T + iB)*(p+iq) = scale*(c+id),  if LREAL = .FALSE.
   *>
   *> in real arithmetic, where T is upper quasi-triangular.
   *> If LREAL = .FALSE., then the first diagonal block of T must be
   *> 1 by 1, B is the specially structured matrix
   *>
   *>                B = [ b(1) b(2) ... b(n) ]
   *>                    [       w            ]
   *>                    [           w        ]
   *>                    [              .     ]
   *>                    [                 w  ]
   *>
   *> op(A) = A or A**T, A**T denotes the transpose of
   *> matrix A.
   *>
   *> On input, X = [ c ].  On output, X = [ p ].
   *>               [ d ]                  [ q ]
   *>
   *> This subroutine is designed for the condition number estimation
   *> in routine DTRSNA.
   *> \endverbatim
   *
   *  Arguments:
   *  ==========
   *
   *> \param[in] LTRAN
   *> \verbatim
   *>          LTRAN is LOGICAL
   *>          On entry, LTRAN specifies the option of conjugate transpose:
   *>             = .FALSE.,    op(T+i*B) = T+i*B,
   *>             = .TRUE.,     op(T+i*B) = (T+i*B)**T.
   *> \endverbatim
   *>
   *> \param[in] LREAL
   *> \verbatim
   *>          LREAL is LOGICAL
   *>          On entry, LREAL specifies the input matrix structure:
   *>             = .FALSE.,    the input is complex
   *>             = .TRUE.,     the input is real
   *> \endverbatim
   *>
   *> \param[in] N
   *> \verbatim
   *>          N is INTEGER
   *>          On entry, N specifies the order of T+i*B. N >= 0.
   *> \endverbatim
   *>
   *> \param[in] T
   *> \verbatim
   *>          T is DOUBLE PRECISION array, dimension (LDT,N)
   *>          On entry, T contains a matrix in Schur canonical form.
   *>          If LREAL = .FALSE., then the first diagonal block of T mu
   *>          be 1 by 1.
   *> \endverbatim
   *>
   *> \param[in] LDT
   *> \verbatim
   *>          LDT is INTEGER
   *>          The leading dimension of the matrix T. LDT >= max(1,N).
   *> \endverbatim
   *>
   *> \param[in] B
   *> \verbatim
   *>          B is DOUBLE PRECISION array, dimension (N)
   *>          On entry, B contains the elements to form the matrix
   *>          B as described above.
   *>          If LREAL = .TRUE., B is not referenced.
   *> \endverbatim
   *>
   *> \param[in] W
   *> \verbatim
   *>          W is DOUBLE PRECISION
   *>          On entry, W is the diagonal element of the matrix B.
   *>          If LREAL = .TRUE., W is not referenced.
   *> \endverbatim
   *>
   *> \param[out] SCALE
   *> \verbatim
   *>          SCALE is DOUBLE PRECISION
   *>          On exit, SCALE is the scale factor.
   *> \endverbatim
   *>
   *> \param[in,out] X
   *> \verbatim
   *>          X is DOUBLE PRECISION array, dimension (2*N)
   *>          On entry, X contains the right hand side of the system.
   *>          On exit, X is overwritten by the solution.
   *> \endverbatim
   *>
   *> \param[out] WORK
   *> \verbatim
   *>          WORK is DOUBLE PRECISION array, dimension (N)
   *> \endverbatim
   *>
   *> \param[out] INFO
   *> \verbatim
   *>          INFO is INTEGER
   *>          On exit, INFO is set to
   *>             0: successful exit.
   *>               1: the some diagonal 1 by 1 block has been perturbed by
   *>                  a small number SMIN to keep nonsingularity.
   *>               2: the some diagonal 2 by 2 block has been perturbed by
   *>                  a small number in DLALN2 to keep nonsingularity.
   *>          NOTE: In the interests of speed, this routine does not
   *>                check the inputs for errors.
   *> \endverbatim
   *
   *  Authors:
   *  ========
   *
   *> \author Univ. of Tennessee
   *> \author Univ. of California Berkeley
   *> \author Univ. of Colorado Denver
   *> \author NAG Ltd.
   *
   *> \ingroup doubleOTHERauxiliary
   *
   *  =====================================================================
       SUBROUTINE DLAQTR( LTRAN, LREAL, N, T, LDT, B, W, SCALE, X, WORK,        SUBROUTINE DLAQTR( LTRAN, LREAL, N, T, LDT, B, W, SCALE, X, WORK,
      $                   INFO )       $                   INFO )
 *  *
 *  -- LAPACK auxiliary routine (version 3.2) --  *  -- LAPACK auxiliary routine --
 *  -- LAPACK is a software package provided by Univ. of Tennessee,    --  *  -- LAPACK is a software package provided by Univ. of Tennessee,    --
 *  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--  *  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
 *     November 2006  
 *  *
 *     .. Scalar Arguments ..  *     .. Scalar Arguments ..
       LOGICAL            LREAL, LTRAN        LOGICAL            LREAL, LTRAN
Line 15 Line 176
       DOUBLE PRECISION   B( * ), T( LDT, * ), WORK( * ), X( * )        DOUBLE PRECISION   B( * ), T( LDT, * ), WORK( * ), X( * )
 *     ..  *     ..
 *  *
 *  Purpose  
 *  =======  
 *  
 *  DLAQTR solves the real quasi-triangular system  
 *  
 *               op(T)*p = scale*c,               if LREAL = .TRUE.  
 *  
 *  or the complex quasi-triangular systems  
 *  
 *             op(T + iB)*(p+iq) = scale*(c+id),  if LREAL = .FALSE.  
 *  
 *  in real arithmetic, where T is upper quasi-triangular.  
 *  If LREAL = .FALSE., then the first diagonal block of T must be  
 *  1 by 1, B is the specially structured matrix  
 *  
 *                 B = [ b(1) b(2) ... b(n) ]  
 *                     [       w            ]  
 *                     [           w        ]  
 *                     [              .     ]  
 *                     [                 w  ]  
 *  
 *  op(A) = A or A', A' denotes the conjugate transpose of  
 *  matrix A.  
 *  
 *  On input, X = [ c ].  On output, X = [ p ].  
 *                [ d ]                  [ q ]  
 *  
 *  This subroutine is designed for the condition number estimation  
 *  in routine DTRSNA.  
 *  
 *  Arguments  
 *  =========  
 *  
 *  LTRAN   (input) LOGICAL  
 *          On entry, LTRAN specifies the option of conjugate transpose:  
 *             = .FALSE.,    op(T+i*B) = T+i*B,  
 *             = .TRUE.,     op(T+i*B) = (T+i*B)'.  
 *  
 *  LREAL   (input) LOGICAL  
 *          On entry, LREAL specifies the input matrix structure:  
 *             = .FALSE.,    the input is complex  
 *             = .TRUE.,     the input is real  
 *  
 *  N       (input) INTEGER  
 *          On entry, N specifies the order of T+i*B. N >= 0.  
 *  
 *  T       (input) DOUBLE PRECISION array, dimension (LDT,N)  
 *          On entry, T contains a matrix in Schur canonical form.  
 *          If LREAL = .FALSE., then the first diagonal block of T mu  
 *          be 1 by 1.  
 *  
 *  LDT     (input) INTEGER  
 *          The leading dimension of the matrix T. LDT >= max(1,N).  
 *  
 *  B       (input) DOUBLE PRECISION array, dimension (N)  
 *          On entry, B contains the elements to form the matrix  
 *          B as described above.  
 *          If LREAL = .TRUE., B is not referenced.  
 *  
 *  W       (input) DOUBLE PRECISION  
 *          On entry, W is the diagonal element of the matrix B.  
 *          If LREAL = .TRUE., W is not referenced.  
 *  
 *  SCALE   (output) DOUBLE PRECISION  
 *          On exit, SCALE is the scale factor.  
 *  
 *  X       (input/output) DOUBLE PRECISION array, dimension (2*N)  
 *          On entry, X contains the right hand side of the system.  
 *          On exit, X is overwritten by the solution.  
 *  
 *  WORK    (workspace) DOUBLE PRECISION array, dimension (N)  
 *  
 *  INFO    (output) INTEGER  
 *          On exit, INFO is set to  
 *             0: successful exit.  
 *               1: the some diagonal 1 by 1 block has been perturbed by  
 *                  a small number SMIN to keep nonsingularity.  
 *               2: the some diagonal 2 by 2 block has been perturbed by  
 *                  a small number in DLALN2 to keep nonsingularity.  
 *          NOTE: In the interests of speed, this routine does not  
 *                check the inputs for errors.  
 *  
 * =====================================================================  * =====================================================================
 *  *
 *     .. Parameters ..  *     .. Parameters ..
Line 290 Line 369
 *  *
          ELSE           ELSE
 *  *
 *           Solve T'*p = scale*c  *           Solve T**T*p = scale*c
 *  *
             JNEXT = 1              JNEXT = 1
             DO 40 J = 1, N              DO 40 J = 1, N
Line 532 Line 611
 *  *
          ELSE           ELSE
 *  *
 *           Solve (T + iB)'*(p+iq) = c+id  *           Solve (T + iB)**T*(p+iq) = c+id
 *  *
             JNEXT = 1              JNEXT = 1
             DO 80 J = 1, N              DO 80 J = 1, N
Removed from v.1.3  
changed lines
  Added in v.1.19

CVSweb interface <joel.bertrand@systella.fr>