LAPACK 3.12.1
LAPACK: Linear Algebra PACKage
Loading...
Searching...
No Matches

◆ dsysv_aa_2stage()

subroutine dsysv_aa_2stage ( character uplo,
integer n,
integer nrhs,
double precision, dimension( lda, * ) a,
integer lda,
double precision, dimension( * ) tb,
integer ltb,
integer, dimension( * ) ipiv,
integer, dimension( * ) ipiv2,
double precision, dimension( ldb, * ) b,
integer ldb,
double precision, dimension( * ) work,
integer lwork,
integer info )

DSYSV_AA_2STAGE computes the solution to system of linear equations A * X = B for SY matrices

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

Purpose:
!>
!> DSYSV_AA_2STAGE computes the solution to a real system of
!> linear equations
!>    A * X = B,
!> where A is an N-by-N symmetric matrix and X and B are N-by-NRHS
!> matrices.
!>
!> Aasen's 2-stage algorithm is used to factor A as
!>    A = U**T * T * U,  if UPLO = 'U', or
!>    A = L * T * L**T,  if UPLO = 'L',
!> where U (or L) is a product of permutation and unit upper (lower)
!> triangular matrices, and T is symmetric and band. The matrix T is
!> then LU-factored with partial pivoting. The factored form of A
!> is then used to solve the system of equations A * X = B.
!>
!> This is the blocked version of the algorithm, calling Level 3 BLAS.
!>
Parameters
[in]UPLO
!>          UPLO is CHARACTER*1
!>          = 'U':  Upper triangle of A is stored;
!>          = 'L':  Lower triangle of A is stored.
!>
[in]N
!>          N is INTEGER
!>          The order of the matrix A.  N >= 0.
!>
[in]NRHS
!>          NRHS is INTEGER
!>          The number of right hand sides, i.e., the number of columns
!>          of the matrix B.  NRHS >= 0.
!>
[in,out]A
!>          A is DOUBLE PRECISION array, dimension (LDA,N)
!>          On entry, the symmetric matrix A.  If UPLO = 'U', the leading
!>          N-by-N upper triangular part of A contains the upper
!>          triangular part of the matrix A, and the strictly lower
!>          triangular part of A is not referenced.  If UPLO = 'L', the
!>          leading N-by-N lower triangular part of A contains the lower
!>          triangular part of the matrix A, and the strictly upper
!>          triangular part of A is not referenced.
!>
!>          On exit, L is stored below (or above) the subdiagonal blocks,
!>          when UPLO  is 'L' (or 'U').
!>
[in]LDA
!>          LDA is INTEGER
!>          The leading dimension of the array A.  LDA >= max(1,N).
!>
[out]TB
!>          TB is DOUBLE PRECISION array, dimension (MAX(1,LTB))
!>          On exit, details of the LU factorization of the band matrix.
!>
[in]LTB
!>          LTB is INTEGER
!>          The size of the array TB. LTB >= MAX(1,4*N), internally
!>          used to select NB such that LTB >= (3*NB+1)*N.
!>
!>          If LTB = -1, then a workspace query is assumed; the
!>          routine only calculates the optimal size of LTB, 
!>          returns this value as the first entry of TB, and
!>          no error message related to LTB is issued by XERBLA.
!>
[out]IPIV
!>          IPIV is INTEGER array, dimension (N)
!>          On exit, it contains the details of the interchanges, i.e.,
!>          the row and column k of A were interchanged with the
!>          row and column IPIV(k).
!>
[out]IPIV2
!>          IPIV2 is INTEGER array, dimension (N)
!>          On exit, it contains the details of the interchanges, i.e.,
!>          the row and column k of T were interchanged with the
!>          row and column IPIV(k).
!>
[in,out]B
!>          B is DOUBLE PRECISION array, dimension (LDB,NRHS)
!>          On entry, the right hand side matrix B.
!>          On exit, the solution matrix X.
!>
[in]LDB
!>          LDB is INTEGER
!>          The leading dimension of the array B.  LDB >= max(1,N).
!>
[out]WORK
!>          WORK is DOUBLE PRECISION workspace of size (MAX(1,LWORK))
!>          On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
!>
[in]LWORK
!>          LWORK is INTEGER
!>          The size of WORK. LWORK >= MAX(1,N), internally used to
!>          select NB such that LWORK >= N*NB.
!>
!>          If LWORK = -1, then a workspace query is assumed; the
!>          routine only calculates the optimal size of the WORK array,
!>          returns this value as the first entry of the WORK array, and
!>          no error message related to LWORK is issued by XERBLA.
!>
[out]INFO
!>          INFO is INTEGER
!>          = 0:  successful exit
!>          < 0:  if INFO = -i, the i-th argument had an illegal value.
!>          > 0:  if INFO = i, band LU factorization failed on i-th column
!>
Author
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.

Definition at line 184 of file dsysv_aa_2stage.f.

187*
188* -- LAPACK computational routine --
189* -- LAPACK is a software package provided by Univ. of Tennessee, --
190* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
191*
192 IMPLICIT NONE
193*
194* .. Scalar Arguments ..
195 CHARACTER UPLO
196 INTEGER N, NRHS, LDA, LDB, LTB, LWORK, INFO
197* ..
198* .. Array Arguments ..
199 INTEGER IPIV( * ), IPIV2( * )
200 DOUBLE PRECISION A( LDA, * ), B( LDB, * ), TB( * ), WORK( * )
201* ..
202*
203* =====================================================================
204*
205* .. Local Scalars ..
206 LOGICAL UPPER, TQUERY, WQUERY
207 INTEGER LWKMIN, LWKOPT
208* ..
209* .. External Functions ..
210 LOGICAL LSAME
211 EXTERNAL lsame
212* ..
213* .. External Subroutines ..
214 EXTERNAL dsytrf_aa_2stage, dsytrs_aa_2stage,
215 $ xerbla
216* ..
217* .. Intrinsic Functions ..
218 INTRINSIC max
219* ..
220* .. Executable Statements ..
221*
222* Test the input parameters.
223*
224 info = 0
225 upper = lsame( uplo, 'U' )
226 wquery = ( lwork.EQ.-1 )
227 tquery = ( ltb.EQ.-1 )
228 lwkmin = max( 1, n )
229 IF( .NOT.upper .AND. .NOT.lsame( uplo, 'L' ) ) THEN
230 info = -1
231 ELSE IF( n.LT.0 ) THEN
232 info = -2
233 ELSE IF( nrhs.LT.0 ) THEN
234 info = -3
235 ELSE IF( lda.LT.max( 1, n ) ) THEN
236 info = -5
237 ELSE IF( ltb.LT.max( 1, 4*n ) .AND. .NOT.tquery ) THEN
238 info = -7
239 ELSE IF( ldb.LT.max( 1, n ) ) THEN
240 info = -11
241 ELSE IF( lwork.LT.lwkmin .AND. .NOT.wquery ) THEN
242 info = -13
243 END IF
244*
245 IF( info.EQ.0 ) THEN
246 CALL dsytrf_aa_2stage( uplo, n, a, lda, tb, -1, ipiv,
247 $ ipiv2, work, -1, info )
248 lwkopt = max( lwkmin, int( work( 1 ) ) )
249 work( 1 ) = lwkopt
250 END IF
251*
252 IF( info.NE.0 ) THEN
253 CALL xerbla( 'DSYSV_AA_2STAGE', -info )
254 RETURN
255 ELSE IF( wquery .OR. tquery ) THEN
256 RETURN
257 END IF
258*
259* Compute the factorization A = U**T*T*U or A = L*T*L**T.
260*
261 CALL dsytrf_aa_2stage( uplo, n, a, lda, tb, ltb, ipiv, ipiv2,
262 $ work, lwork, info )
263 IF( info.EQ.0 ) THEN
264*
265* Solve the system A*X = B, overwriting B with X.
266*
267 CALL dsytrs_aa_2stage( uplo, n, nrhs, a, lda, tb, ltb, ipiv,
268 $ ipiv2, b, ldb, info )
269*
270 END IF
271*
272 work( 1 ) = lwkopt
273*
274 RETURN
275*
276* End of DSYSV_AA_2STAGE
277*
xerbla
subroutine xerbla(srname, info)
Definition cblat2.f:3285
dsytrf_aa_2stage
subroutine dsytrf_aa_2stage(uplo, n, a, lda, tb, ltb, ipiv, ipiv2, work, lwork, info)
DSYTRF_AA_2STAGE
Definition dsytrf_aa_2stage.f:158
dsytrs_aa_2stage
subroutine dsytrs_aa_2stage(uplo, n, nrhs, a, lda, tb, ltb, ipiv, ipiv2, b, ldb, info)
DSYTRS_AA_2STAGE
Definition dsytrs_aa_2stage.f:137
lsame
logical function lsame(ca, cb)
LSAME
Definition lsame.f:48
Here is the call graph for this function:
Here is the caller graph for this function: