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

◆ sposvx()

subroutine sposvx ( character fact,
character uplo,
integer n,
integer nrhs,
real, dimension( lda, * ) a,
integer lda,
real, dimension( ldaf, * ) af,
integer ldaf,
character equed,
real, dimension( * ) s,
real, dimension( ldb, * ) b,
integer ldb,
real, dimension( ldx, * ) x,
integer ldx,
real rcond,
real, dimension( * ) ferr,
real, dimension( * ) berr,
real, dimension( * ) work,
integer, dimension( * ) iwork,
integer info )

SPOSVX computes the solution to system of linear equations A * X = B for PO matrices

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

Purpose:
!>
!> SPOSVX uses the Cholesky factorization A = U**T*U or A = L*L**T to
!> compute the solution to a real system of linear equations
!>    A * X = B,
!> where A is an N-by-N symmetric positive definite matrix and X and B
!> are N-by-NRHS matrices.
!>
!> Error bounds on the solution and a condition estimate are also
!> provided.
!>
Description:
!>
!> The following steps are performed:
!>
!> 1. If FACT = 'E', real scaling factors are computed to equilibrate
!>    the system:
!>       diag(S) * A * diag(S) * inv(diag(S)) * X = diag(S) * B
!>    Whether or not the system will be equilibrated depends on the
!>    scaling of the matrix A, but if equilibration is used, A is
!>    overwritten by diag(S)*A*diag(S) and B by diag(S)*B.
!>
!> 2. If FACT = 'N' or 'E', the Cholesky decomposition is used to
!>    factor the matrix A (after equilibration if FACT = 'E') as
!>       A = U**T* U,  if UPLO = 'U', or
!>       A = L * L**T,  if UPLO = 'L',
!>    where U is an upper triangular matrix and L is a lower triangular
!>    matrix.
!>
!> 3. If the leading principal minor of order i is not positive,
!>    then the routine returns with INFO = i. Otherwise, the factored
!>    form of A is used to estimate the condition number of the matrix
!>    A.  If the reciprocal of the condition number is less than machine
!>    precision, INFO = N+1 is returned as a warning, but the routine
!>    still goes on to solve for X and compute error bounds as
!>    described below.
!>
!> 4. The system of equations is solved for X using the factored form
!>    of A.
!>
!> 5. Iterative refinement is applied to improve the computed solution
!>    matrix and calculate error bounds and backward error estimates
!>    for it.
!>
!> 6. If equilibration was used, the matrix X is premultiplied by
!>    diag(S) so that it solves the original system before
!>    equilibration.
!>
Parameters
[in]FACT
!>          FACT is CHARACTER*1
!>          Specifies whether or not the factored form of the matrix A is
!>          supplied on entry, and if not, whether the matrix A should be
!>          equilibrated before it is factored.
!>          = 'F':  On entry, AF contains the factored form of A.
!>                  If EQUED = 'Y', the matrix A has been equilibrated
!>                  with scaling factors given by S.  A and AF will not
!>                  be modified.
!>          = 'N':  The matrix A will be copied to AF and factored.
!>          = 'E':  The matrix A will be equilibrated if necessary, then
!>                  copied to AF and factored.
!>
[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 number of linear equations, i.e., 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 matrices B and X.  NRHS >= 0.
!>
[in,out]A
!>          A is REAL array, dimension (LDA,N)
!>          On entry, the symmetric matrix A, except if FACT = 'F' and
!>          EQUED = 'Y', then A must contain the equilibrated matrix
!>          diag(S)*A*diag(S).  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.  A is not modified if
!>          FACT = 'F' or 'N', or if FACT = 'E' and EQUED = 'N' on exit.
!>
!>          On exit, if FACT = 'E' and EQUED = 'Y', A is overwritten by
!>          diag(S)*A*diag(S).
!>
[in]LDA
!>          LDA is INTEGER
!>          The leading dimension of the array A.  LDA >= max(1,N).
!>
[in,out]AF
!>          AF is REAL array, dimension (LDAF,N)
!>          If FACT = 'F', then AF is an input argument and on entry
!>          contains the triangular factor U or L from the Cholesky
!>          factorization A = U**T*U or A = L*L**T, in the same storage
!>          format as A.  If EQUED .ne. 'N', then AF is the factored form
!>          of the equilibrated matrix diag(S)*A*diag(S).
!>
!>          If FACT = 'N', then AF is an output argument and on exit
!>          returns the triangular factor U or L from the Cholesky
!>          factorization A = U**T*U or A = L*L**T of the original
!>          matrix A.
!>
!>          If FACT = 'E', then AF is an output argument and on exit
!>          returns the triangular factor U or L from the Cholesky
!>          factorization A = U**T*U or A = L*L**T of the equilibrated
!>          matrix A (see the description of A for the form of the
!>          equilibrated matrix).
!>
[in]LDAF
!>          LDAF is INTEGER
!>          The leading dimension of the array AF.  LDAF >= max(1,N).
!>
[in,out]EQUED
!>          EQUED is CHARACTER*1
!>          Specifies the form of equilibration that was done.
!>          = 'N':  No equilibration (always true if FACT = 'N').
!>          = 'Y':  Equilibration was done, i.e., A has been replaced by
!>                  diag(S) * A * diag(S).
!>          EQUED is an input argument if FACT = 'F'; otherwise, it is an
!>          output argument.
!>
[in,out]S
!>          S is REAL array, dimension (N)
!>          The scale factors for A; not accessed if EQUED = 'N'.  S is
!>          an input argument if FACT = 'F'; otherwise, S is an output
!>          argument.  If FACT = 'F' and EQUED = 'Y', each element of S
!>          must be positive.
!>
[in,out]B
!>          B is REAL array, dimension (LDB,NRHS)
!>          On entry, the N-by-NRHS right hand side matrix B.
!>          On exit, if EQUED = 'N', B is not modified; if EQUED = 'Y',
!>          B is overwritten by diag(S) * B.
!>
[in]LDB
!>          LDB is INTEGER
!>          The leading dimension of the array B.  LDB >= max(1,N).
!>
[out]X
!>          X is REAL array, dimension (LDX,NRHS)
!>          If INFO = 0 or INFO = N+1, the N-by-NRHS solution matrix X to
!>          the original system of equations.  Note that if EQUED = 'Y',
!>          A and B are modified on exit, and the solution to the
!>          equilibrated system is inv(diag(S))*X.
!>
[in]LDX
!>          LDX is INTEGER
!>          The leading dimension of the array X.  LDX >= max(1,N).
!>
[out]RCOND
!>          RCOND is REAL
!>          The estimate of the reciprocal condition number of the matrix
!>          A after equilibration (if done).  If RCOND is less than the
!>          machine precision (in particular, if RCOND = 0), the matrix
!>          is singular to working precision.  This condition is
!>          indicated by a return code of INFO > 0.
!>
[out]FERR
!>          FERR is REAL array, dimension (NRHS)
!>          The estimated forward error bound for each solution vector
!>          X(j) (the j-th column of the solution matrix X).
!>          If XTRUE is the true solution corresponding to X(j), FERR(j)
!>          is an estimated upper bound for the magnitude of the largest
!>          element in (X(j) - XTRUE) divided by the magnitude of the
!>          largest element in X(j).  The estimate is as reliable as
!>          the estimate for RCOND, and is almost always a slight
!>          overestimate of the true error.
!>
[out]BERR
!>          BERR is REAL array, dimension (NRHS)
!>          The componentwise relative backward error of each solution
!>          vector X(j) (i.e., the smallest relative change in
!>          any element of A or B that makes X(j) an exact solution).
!>
[out]WORK
!>          WORK is REAL array, dimension (3*N)
!>
[out]IWORK
!>          IWORK is INTEGER array, dimension (N)
!>
[out]INFO
!>          INFO is INTEGER
!>          = 0: successful exit
!>          < 0: if INFO = -i, the i-th argument had an illegal value
!>          > 0: if INFO = i, and i is
!>                <= N:  the leading principal minor of order i of A
!>                       is not positive, so the factorization could not
!>                       be completed, and the solution has not been
!>                       computed. RCOND = 0 is returned.
!>                = N+1: U is nonsingular, but RCOND is less than machine
!>                       precision, meaning that the matrix is singular
!>                       to working precision.  Nevertheless, the
!>                       solution and error bounds are computed because
!>                       there are a number of situations where the
!>                       computed solution can be more accurate than the
!>                       value of RCOND would suggest.
!>
Author
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.

Definition at line 302 of file sposvx.f.

306*
307* -- LAPACK driver routine --
308* -- LAPACK is a software package provided by Univ. of Tennessee, --
309* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
310*
311* .. Scalar Arguments ..
312 CHARACTER EQUED, FACT, UPLO
313 INTEGER INFO, LDA, LDAF, LDB, LDX, N, NRHS
314 REAL RCOND
315* ..
316* .. Array Arguments ..
317 INTEGER IWORK( * )
318 REAL A( LDA, * ), AF( LDAF, * ), B( LDB, * ),
319 $ BERR( * ), FERR( * ), S( * ), WORK( * ),
320 $ X( LDX, * )
321* ..
322*
323* =====================================================================
324*
325* .. Parameters ..
326 REAL ZERO, ONE
327 parameter( zero = 0.0e+0, one = 1.0e+0 )
328* ..
329* .. Local Scalars ..
330 LOGICAL EQUIL, NOFACT, RCEQU
331 INTEGER I, INFEQU, J
332 REAL AMAX, ANORM, BIGNUM, SCOND, SMAX, SMIN, SMLNUM
333* ..
334* .. External Functions ..
335 LOGICAL LSAME
336 REAL SLAMCH, SLANSY
337 EXTERNAL lsame, slamch, slansy
338* ..
339* .. External Subroutines ..
340 EXTERNAL slacpy, slaqsy, spocon, spoequ, sporfs,
341 $ spotrf,
342 $ spotrs, xerbla
343* ..
344* .. Intrinsic Functions ..
345 INTRINSIC max, min
346* ..
347* .. Executable Statements ..
348*
349 info = 0
350 nofact = lsame( fact, 'N' )
351 equil = lsame( fact, 'E' )
352 IF( nofact .OR. equil ) THEN
353 equed = 'N'
354 rcequ = .false.
355 ELSE
356 rcequ = lsame( equed, 'Y' )
357 smlnum = slamch( 'Safe minimum' )
358 bignum = one / smlnum
359 END IF
360*
361* Test the input parameters.
362*
363 IF( .NOT.nofact .AND.
364 $ .NOT.equil .AND.
365 $ .NOT.lsame( fact, 'F' ) )
366 $ THEN
367 info = -1
368 ELSE IF( .NOT.lsame( uplo, 'U' ) .AND.
369 $ .NOT.lsame( uplo, 'L' ) )
370 $ THEN
371 info = -2
372 ELSE IF( n.LT.0 ) THEN
373 info = -3
374 ELSE IF( nrhs.LT.0 ) THEN
375 info = -4
376 ELSE IF( lda.LT.max( 1, n ) ) THEN
377 info = -6
378 ELSE IF( ldaf.LT.max( 1, n ) ) THEN
379 info = -8
380 ELSE IF( lsame( fact, 'F' ) .AND. .NOT.
381 $ ( rcequ .OR. lsame( equed, 'N' ) ) ) THEN
382 info = -9
383 ELSE
384 IF( rcequ ) THEN
385 smin = bignum
386 smax = zero
387 DO 10 j = 1, n
388 smin = min( smin, s( j ) )
389 smax = max( smax, s( j ) )
390 10 CONTINUE
391 IF( smin.LE.zero ) THEN
392 info = -10
393 ELSE IF( n.GT.0 ) THEN
394 scond = max( smin, smlnum ) / min( smax, bignum )
395 ELSE
396 scond = one
397 END IF
398 END IF
399 IF( info.EQ.0 ) THEN
400 IF( ldb.LT.max( 1, n ) ) THEN
401 info = -12
402 ELSE IF( ldx.LT.max( 1, n ) ) THEN
403 info = -14
404 END IF
405 END IF
406 END IF
407*
408 IF( info.NE.0 ) THEN
409 CALL xerbla( 'SPOSVX', -info )
410 RETURN
411 END IF
412*
413 IF( equil ) THEN
414*
415* Compute row and column scalings to equilibrate the matrix A.
416*
417 CALL spoequ( n, a, lda, s, scond, amax, infequ )
418 IF( infequ.EQ.0 ) THEN
419*
420* Equilibrate the matrix.
421*
422 CALL slaqsy( uplo, n, a, lda, s, scond, amax, equed )
423 rcequ = lsame( equed, 'Y' )
424 END IF
425 END IF
426*
427* Scale the right hand side.
428*
429 IF( rcequ ) THEN
430 DO 30 j = 1, nrhs
431 DO 20 i = 1, n
432 b( i, j ) = s( i )*b( i, j )
433 20 CONTINUE
434 30 CONTINUE
435 END IF
436*
437 IF( nofact .OR. equil ) THEN
438*
439* Compute the Cholesky factorization A = U**T *U or A = L*L**T.
440*
441 CALL slacpy( uplo, n, n, a, lda, af, ldaf )
442 CALL spotrf( uplo, n, af, ldaf, info )
443*
444* Return if INFO is non-zero.
445*
446 IF( info.GT.0 )THEN
447 rcond = zero
448 RETURN
449 END IF
450 END IF
451*
452* Compute the norm of the matrix A.
453*
454 anorm = slansy( '1', uplo, n, a, lda, work )
455*
456* Compute the reciprocal of the condition number of A.
457*
458 CALL spocon( uplo, n, af, ldaf, anorm, rcond, work, iwork,
459 $ info )
460*
461* Compute the solution matrix X.
462*
463 CALL slacpy( 'Full', n, nrhs, b, ldb, x, ldx )
464 CALL spotrs( uplo, n, nrhs, af, ldaf, x, ldx, info )
465*
466* Use iterative refinement to improve the computed solution and
467* compute error bounds and backward error estimates for it.
468*
469 CALL sporfs( uplo, n, nrhs, a, lda, af, ldaf, b, ldb, x, ldx,
470 $ ferr, berr, work, iwork, info )
471*
472* Transform the solution matrix X to a solution of the original
473* system.
474*
475 IF( rcequ ) THEN
476 DO 50 j = 1, nrhs
477 DO 40 i = 1, n
478 x( i, j ) = s( i )*x( i, j )
479 40 CONTINUE
480 50 CONTINUE
481 DO 60 j = 1, nrhs
482 ferr( j ) = ferr( j ) / scond
483 60 CONTINUE
484 END IF
485*
486* Set INFO = N+1 if the matrix is singular to working precision.
487*
488 IF( rcond.LT.slamch( 'Epsilon' ) )
489 $ info = n + 1
490*
491 RETURN
492*
493* End of SPOSVX
494*
xerbla
subroutine xerbla(srname, info)
Definition cblat2.f:3285
slacpy
subroutine slacpy(uplo, m, n, a, lda, b, ldb)
SLACPY copies all or part of one two-dimensional array to another.
Definition slacpy.f:101
slamch
real function slamch(cmach)
SLAMCH
Definition slamch.f:68
slansy
real function slansy(norm, uplo, n, a, lda, work)
SLANSY returns the value of the 1-norm, or the Frobenius norm, or the infinity norm,...
Definition slansy.f:120
slaqsy
subroutine slaqsy(uplo, n, a, lda, s, scond, amax, equed)
SLAQSY scales a symmetric/Hermitian matrix, using scaling factors computed by spoequ.
Definition slaqsy.f:131
lsame
logical function lsame(ca, cb)
LSAME
Definition lsame.f:48
spocon
subroutine spocon(uplo, n, a, lda, anorm, rcond, work, iwork, info)
SPOCON
Definition spocon.f:119
spoequ
subroutine spoequ(n, a, lda, s, scond, amax, info)
SPOEQU
Definition spoequ.f:110
sporfs
subroutine sporfs(uplo, n, nrhs, a, lda, af, ldaf, b, ldb, x, ldx, ferr, berr, work, iwork, info)
SPORFS
Definition sporfs.f:181
spotrf
subroutine spotrf(uplo, n, a, lda, info)
SPOTRF
Definition spotrf.f:105
spotrs
subroutine spotrs(uplo, n, nrhs, a, lda, b, ldb, info)
SPOTRS
Definition spotrs.f:108
Here is the call graph for this function:
Here is the caller graph for this function: