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

◆ ssysv_aa_2stage()

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

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

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

Purpose:
!>
!> SSYSV_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 REAL 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 REAL 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 REAL 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 REAL 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 183 of file ssysv_aa_2stage.f.

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