dlasy2.f

Go to the documentation of this file.

*> \brief \b DLASY2 solves the Sylvester matrix equation where the matrices are of order 1 or 2.
*
*  =========== DOCUMENTATION ===========
*
* Online html documentation available at 
*            http://www.netlib.org/lapack/explore-html/ 
*
*> \htmlonly
*> Download DLASY2 + dependencies 
*> <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/dlasy2.f"> 
*> [TGZ]</a> 
*> <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/dlasy2.f"> 
*> [ZIP]</a> 
*> <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/dlasy2.f"> 
*> [TXT]</a>
*> \endhtmlonly 
*
*  Definition:
*  ===========
*
*       SUBROUTINE DLASY2( LTRANL, LTRANR, ISGN, N1, N2, TL, LDTL, TR,
*                          LDTR, B, LDB, SCALE, X, LDX, XNORM, INFO )
* 
*       .. Scalar Arguments ..
*       LOGICAL            LTRANL, LTRANR
*       INTEGER            INFO, ISGN, LDB, LDTL, LDTR, LDX, N1, N2
*       DOUBLE PRECISION   SCALE, XNORM
*       ..
*       .. Array Arguments ..
*       DOUBLE PRECISION   B( LDB, * ), TL( LDTL, * ), TR( LDTR, * ),
*      $                   X( LDX, * )
*       ..
*  
*
*> \par Purpose:
*  =============
*>
*> \verbatim
*>
*> DLASY2 solves for the N1 by N2 matrix X, 1 <= N1,N2 <= 2, in
*>
*>        op(TL)*X + ISGN*X*op(TR) = SCALE*B,
*>
*> where TL is N1 by N1, TR is N2 by N2, B is N1 by N2, and ISGN = 1 or
*> -1.  op(T) = T or T**T, where T**T denotes the transpose of T.
*> \endverbatim
*
*  Arguments:
*  ==========
*
*> \param[in] LTRANL
*> \verbatim
*>          LTRANL is LOGICAL
*>          On entry, LTRANL specifies the op(TL):
*>             = .FALSE., op(TL) = TL,
*>             = .TRUE., op(TL) = TL**T.
*> \endverbatim
*>
*> \param[in] LTRANR
*> \verbatim
*>          LTRANR is LOGICAL
*>          On entry, LTRANR specifies the op(TR):
*>            = .FALSE., op(TR) = TR,
*>            = .TRUE., op(TR) = TR**T.
*> \endverbatim
*>
*> \param[in] ISGN
*> \verbatim
*>          ISGN is INTEGER
*>          On entry, ISGN specifies the sign of the equation
*>          as described before. ISGN may only be 1 or -1.
*> \endverbatim
*>
*> \param[in] N1
*> \verbatim
*>          N1 is INTEGER
*>          On entry, N1 specifies the order of matrix TL.
*>          N1 may only be 0, 1 or 2.
*> \endverbatim
*>
*> \param[in] N2
*> \verbatim
*>          N2 is INTEGER
*>          On entry, N2 specifies the order of matrix TR.
*>          N2 may only be 0, 1 or 2.
*> \endverbatim
*>
*> \param[in] TL
*> \verbatim
*>          TL is DOUBLE PRECISION array, dimension (LDTL,2)
*>          On entry, TL contains an N1 by N1 matrix.
*> \endverbatim
*>
*> \param[in] LDTL
*> \verbatim
*>          LDTL is INTEGER
*>          The leading dimension of the matrix TL. LDTL >= max(1,N1).
*> \endverbatim
*>
*> \param[in] TR
*> \verbatim
*>          TR is DOUBLE PRECISION array, dimension (LDTR,2)
*>          On entry, TR contains an N2 by N2 matrix.
*> \endverbatim
*>
*> \param[in] LDTR
*> \verbatim
*>          LDTR is INTEGER
*>          The leading dimension of the matrix TR. LDTR >= max(1,N2).
*> \endverbatim
*>
*> \param[in] B
*> \verbatim
*>          B is DOUBLE PRECISION array, dimension (LDB,2)
*>          On entry, the N1 by N2 matrix B contains the right-hand
*>          side of the equation.
*> \endverbatim
*>
*> \param[in] LDB
*> \verbatim
*>          LDB is INTEGER
*>          The leading dimension of the matrix B. LDB >= max(1,N1).
*> \endverbatim
*>
*> \param[out] SCALE
*> \verbatim
*>          SCALE is DOUBLE PRECISION
*>          On exit, SCALE contains the scale factor. SCALE is chosen
*>          less than or equal to 1 to prevent the solution overflowing.
*> \endverbatim
*>
*> \param[out] X
*> \verbatim
*>          X is DOUBLE PRECISION array, dimension (LDX,2)
*>          On exit, X contains the N1 by N2 solution.
*> \endverbatim
*>
*> \param[in] LDX
*> \verbatim
*>          LDX is INTEGER
*>          The leading dimension of the matrix X. LDX >= max(1,N1).
*> \endverbatim
*>
*> \param[out] XNORM
*> \verbatim
*>          XNORM is DOUBLE PRECISION
*>          On exit, XNORM is the infinity-norm of the solution.
*> \endverbatim
*>
*> \param[out] INFO
*> \verbatim
*>          INFO is INTEGER
*>          On exit, INFO is set to
*>             0: successful exit.
*>             1: TL and TR have too close eigenvalues, so TL or
*>                TR is perturbed to get a nonsingular equation.
*>          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. 
*
*> \date September 2012
*
*> \ingroup doubleSYauxiliary
*
*  =====================================================================
      SUBROUTINE dlasy2( LTRANL, LTRANR, ISGN, N1, N2, TL, LDTL, TR,
     $                   ldtr, b, ldb, scale, x, ldx, xnorm, info )
*
*  -- LAPACK auxiliary routine (version 3.4.2) --
*  -- LAPACK is a software package provided by Univ. of Tennessee,    --
*  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
*     September 2012
*
*     .. Scalar Arguments ..
      LOGICAL            ltranl, ltranr
      INTEGER            info, isgn, ldb, ldtl, ldtr, ldx, n1, n2
      DOUBLE PRECISION   scale, xnorm
*     ..
*     .. Array Arguments ..
      DOUBLE PRECISION   b( ldb, * ), tl( ldtl, * ), tr( ldtr, * ),
     $                   x( ldx, * )
*     ..
*
* =====================================================================
*
*     .. Parameters ..
      DOUBLE PRECISION   zero, one
      parameter( zero = 0.0d+0, one = 1.0d+0 )
      DOUBLE PRECISION   two, half, eight
      parameter( two = 2.0d+0, half = 0.5d+0, eight = 8.0d+0 )
*     ..
*     .. Local Scalars ..
      LOGICAL            bswap, xswap
      INTEGER            i, ip, ipiv, ipsv, j, jp, jpsv, k
      DOUBLE PRECISION   bet, eps, gam, l21, sgn, smin, smlnum, tau1,
     $                   temp, u11, u12, u22, xmax
*     ..
*     .. Local Arrays ..
      LOGICAL            bswpiv( 4 ), xswpiv( 4 )
      INTEGER            jpiv( 4 ), locl21( 4 ), locu12( 4 ),
     $                   locu22( 4 )
      DOUBLE PRECISION   btmp( 4 ), t16( 4, 4 ), tmp( 4 ), x2( 2 )
*     ..
*     .. External Functions ..
      INTEGER            idamax
      DOUBLE PRECISION   dlamch
      EXTERNAL           idamax, dlamch
*     ..
*     .. External Subroutines ..
      EXTERNAL           dcopy, dswap
*     ..
*     .. Intrinsic Functions ..
      INTRINSIC          abs, max
*     ..
*     .. Data statements ..
      DATA               locu12 / 3, 4, 1, 2 / , locl21 / 2, 1, 4, 3 / ,
     $                   locu22 / 4, 3, 2, 1 /
      DATA               xswpiv / .false., .false., .true., .true. /
      DATA               bswpiv / .false., .true., .false., .true. /
*     ..
*     .. Executable Statements ..
*
*     Do not check the input parameters for errors
*
      info = 0
*
*     Quick return if possible
*
      IF( n1.EQ.0 .OR. n2.EQ.0 )
     $   return
*
*     Set constants to control overflow
*
      eps = dlamch( 'P' )
      smlnum = dlamch( 'S' ) / eps
      sgn = isgn
*
      k = n1 + n1 + n2 - 2
      go to( 10, 20, 30, 50 )k
*
*     1 by 1: TL11*X + SGN*X*TR11 = B11
*
   10 continue
      tau1 = tl( 1, 1 ) + sgn*tr( 1, 1 )
      bet = abs( tau1 )
      IF( bet.LE.smlnum ) THEN
         tau1 = smlnum
         bet = smlnum
         info = 1
      END IF
*
      scale = one
      gam = abs( b( 1, 1 ) )
      IF( smlnum*gam.GT.bet )
     $   scale = one / gam
*
      x( 1, 1 ) = ( b( 1, 1 )*scale ) / tau1
      xnorm = abs( x( 1, 1 ) )
      return
*
*     1 by 2:
*     TL11*[X11 X12] + ISGN*[X11 X12]*op[TR11 TR12]  = [B11 B12]
*                                       [TR21 TR22]
*
   20 continue
*
      smin = max( eps*max( abs( tl( 1, 1 ) ), abs( tr( 1, 1 ) ),
     $       abs( tr( 1, 2 ) ), abs( tr( 2, 1 ) ), abs( tr( 2, 2 ) ) ),
     $       smlnum )
      tmp( 1 ) = tl( 1, 1 ) + sgn*tr( 1, 1 )
      tmp( 4 ) = tl( 1, 1 ) + sgn*tr( 2, 2 )
      IF( ltranr ) THEN
         tmp( 2 ) = sgn*tr( 2, 1 )
         tmp( 3 ) = sgn*tr( 1, 2 )
      ELSE
         tmp( 2 ) = sgn*tr( 1, 2 )
         tmp( 3 ) = sgn*tr( 2, 1 )
      END IF
      btmp( 1 ) = b( 1, 1 )
      btmp( 2 ) = b( 1, 2 )
      go to 40
*
*     2 by 1:
*          op[TL11 TL12]*[X11] + ISGN* [X11]*TR11  = [B11]
*            [TL21 TL22] [X21]         [X21]         [B21]
*
   30 continue
      smin = max( eps*max( abs( tr( 1, 1 ) ), abs( tl( 1, 1 ) ),
     $       abs( tl( 1, 2 ) ), abs( tl( 2, 1 ) ), abs( tl( 2, 2 ) ) ),
     $       smlnum )
      tmp( 1 ) = tl( 1, 1 ) + sgn*tr( 1, 1 )
      tmp( 4 ) = tl( 2, 2 ) + sgn*tr( 1, 1 )
      IF( ltranl ) THEN
         tmp( 2 ) = tl( 1, 2 )
         tmp( 3 ) = tl( 2, 1 )
      ELSE
         tmp( 2 ) = tl( 2, 1 )
         tmp( 3 ) = tl( 1, 2 )
      END IF
      btmp( 1 ) = b( 1, 1 )
      btmp( 2 ) = b( 2, 1 )
   40 continue
*
*     Solve 2 by 2 system using complete pivoting.
*     Set pivots less than SMIN to SMIN.
*
      ipiv = idamax( 4, tmp, 1 )
      u11 = tmp( ipiv )
      IF( abs( u11 ).LE.smin ) THEN
         info = 1
         u11 = smin
      END IF
      u12 = tmp( locu12( ipiv ) )
      l21 = tmp( locl21( ipiv ) ) / u11
      u22 = tmp( locu22( ipiv ) ) - u12*l21
      xswap = xswpiv( ipiv )
      bswap = bswpiv( ipiv )
      IF( abs( u22 ).LE.smin ) THEN
         info = 1
         u22 = smin
      END IF
      IF( bswap ) THEN
         temp = btmp( 2 )
         btmp( 2 ) = btmp( 1 ) - l21*temp
         btmp( 1 ) = temp
      ELSE
         btmp( 2 ) = btmp( 2 ) - l21*btmp( 1 )
      END IF
      scale = one
      IF( ( two*smlnum )*abs( btmp( 2 ) ).GT.abs( u22 ) .OR.
     $    ( two*smlnum )*abs( btmp( 1 ) ).GT.abs( u11 ) ) THEN
         scale = half / max( abs( btmp( 1 ) ), abs( btmp( 2 ) ) )
         btmp( 1 ) = btmp( 1 )*scale
         btmp( 2 ) = btmp( 2 )*scale
      END IF
      x2( 2 ) = btmp( 2 ) / u22
      x2( 1 ) = btmp( 1 ) / u11 - ( u12 / u11 )*x2( 2 )
      IF( xswap ) THEN
         temp = x2( 2 )
         x2( 2 ) = x2( 1 )
         x2( 1 ) = temp
      END IF
      x( 1, 1 ) = x2( 1 )
      IF( n1.EQ.1 ) THEN
         x( 1, 2 ) = x2( 2 )
         xnorm = abs( x( 1, 1 ) ) + abs( x( 1, 2 ) )
      ELSE
         x( 2, 1 ) = x2( 2 )
         xnorm = max( abs( x( 1, 1 ) ), abs( x( 2, 1 ) ) )
      END IF
      return
*
*     2 by 2:
*     op[TL11 TL12]*[X11 X12] +ISGN* [X11 X12]*op[TR11 TR12] = [B11 B12]
*       [TL21 TL22] [X21 X22]        [X21 X22]   [TR21 TR22]   [B21 B22]
*
*     Solve equivalent 4 by 4 system using complete pivoting.
*     Set pivots less than SMIN to SMIN.
*
   50 continue
      smin = max( abs( tr( 1, 1 ) ), abs( tr( 1, 2 ) ),
     $       abs( tr( 2, 1 ) ), abs( tr( 2, 2 ) ) )
      smin = max( smin, abs( tl( 1, 1 ) ), abs( tl( 1, 2 ) ),
     $       abs( tl( 2, 1 ) ), abs( tl( 2, 2 ) ) )
      smin = max( eps*smin, smlnum )
      btmp( 1 ) = zero
      CALL dcopy( 16, btmp, 0, t16, 1 )
      t16( 1, 1 ) = tl( 1, 1 ) + sgn*tr( 1, 1 )
      t16( 2, 2 ) = tl( 2, 2 ) + sgn*tr( 1, 1 )
      t16( 3, 3 ) = tl( 1, 1 ) + sgn*tr( 2, 2 )
      t16( 4, 4 ) = tl( 2, 2 ) + sgn*tr( 2, 2 )
      IF( ltranl ) THEN
         t16( 1, 2 ) = tl( 2, 1 )
         t16( 2, 1 ) = tl( 1, 2 )
         t16( 3, 4 ) = tl( 2, 1 )
         t16( 4, 3 ) = tl( 1, 2 )
      ELSE
         t16( 1, 2 ) = tl( 1, 2 )
         t16( 2, 1 ) = tl( 2, 1 )
         t16( 3, 4 ) = tl( 1, 2 )
         t16( 4, 3 ) = tl( 2, 1 )
      END IF
      IF( ltranr ) THEN
         t16( 1, 3 ) = sgn*tr( 1, 2 )
         t16( 2, 4 ) = sgn*tr( 1, 2 )
         t16( 3, 1 ) = sgn*tr( 2, 1 )
         t16( 4, 2 ) = sgn*tr( 2, 1 )
      ELSE
         t16( 1, 3 ) = sgn*tr( 2, 1 )
         t16( 2, 4 ) = sgn*tr( 2, 1 )
         t16( 3, 1 ) = sgn*tr( 1, 2 )
         t16( 4, 2 ) = sgn*tr( 1, 2 )
      END IF
      btmp( 1 ) = b( 1, 1 )
      btmp( 2 ) = b( 2, 1 )
      btmp( 3 ) = b( 1, 2 )
      btmp( 4 ) = b( 2, 2 )
*
*     Perform elimination
*
      DO 100 i = 1, 3
         xmax = zero
         DO 70 ip = i, 4
            DO 60 jp = i, 4
               IF( abs( t16( ip, jp ) ).GE.xmax ) THEN
                  xmax = abs( t16( ip, jp ) )
                  ipsv = ip
                  jpsv = jp
               END IF
   60       continue
   70    continue
         IF( ipsv.NE.i ) THEN
            CALL dswap( 4, t16( ipsv, 1 ), 4, t16( i, 1 ), 4 )
            temp = btmp( i )
            btmp( i ) = btmp( ipsv )
            btmp( ipsv ) = temp
         END IF
         IF( jpsv.NE.i )
     $      CALL dswap( 4, t16( 1, jpsv ), 1, t16( 1, i ), 1 )
         jpiv( i ) = jpsv
         IF( abs( t16( i, i ) ).LT.smin ) THEN
            info = 1
            t16( i, i ) = smin
         END IF
         DO 90 j = i + 1, 4
            t16( j, i ) = t16( j, i ) / t16( i, i )
            btmp( j ) = btmp( j ) - t16( j, i )*btmp( i )
            DO 80 k = i + 1, 4
               t16( j, k ) = t16( j, k ) - t16( j, i )*t16( i, k )
   80       continue
   90    continue
  100 continue
      IF( abs( t16( 4, 4 ) ).LT.smin )
     $   t16( 4, 4 ) = smin
      scale = one
      IF( ( eight*smlnum )*abs( btmp( 1 ) ).GT.abs( t16( 1, 1 ) ) .OR.
     $    ( eight*smlnum )*abs( btmp( 2 ) ).GT.abs( t16( 2, 2 ) ) .OR.
     $    ( eight*smlnum )*abs( btmp( 3 ) ).GT.abs( t16( 3, 3 ) ) .OR.
     $    ( eight*smlnum )*abs( btmp( 4 ) ).GT.abs( t16( 4, 4 ) ) ) THEN
         scale = ( one / eight ) / max( abs( btmp( 1 ) ),
     $           abs( btmp( 2 ) ), abs( btmp( 3 ) ), abs( btmp( 4 ) ) )
         btmp( 1 ) = btmp( 1 )*scale
         btmp( 2 ) = btmp( 2 )*scale
         btmp( 3 ) = btmp( 3 )*scale
         btmp( 4 ) = btmp( 4 )*scale
      END IF
      DO 120 i = 1, 4
         k = 5 - i
         temp = one / t16( k, k )
         tmp( k ) = btmp( k )*temp
         DO 110 j = k + 1, 4
            tmp( k ) = tmp( k ) - ( temp*t16( k, j ) )*tmp( j )
  110    continue
  120 continue
      DO 130 i = 1, 3
         IF( jpiv( 4-i ).NE.4-i ) THEN
            temp = tmp( 4-i )
            tmp( 4-i ) = tmp( jpiv( 4-i ) )
            tmp( jpiv( 4-i ) ) = temp
         END IF
  130 continue
      x( 1, 1 ) = tmp( 1 )
      x( 2, 1 ) = tmp( 2 )
      x( 1, 2 ) = tmp( 3 )
      x( 2, 2 ) = tmp( 4 )
      xnorm = max( abs( tmp( 1 ) )+abs( tmp( 3 ) ),
     $        abs( tmp( 2 ) )+abs( tmp( 4 ) ) )
      return
*
*     End of DLASY2
*
      END