1        2        3        4        5        6        7        8        9       10       11       12       13       14       15       16       17       18       19       20       21       22       23       24       25       26       27       28       29       30       31       32       33       34       35       36       37       38       39       40       41       42       43       44       45       46       47       48       49       50       51       52       53       54       55       56       57       58       59       60       61       62       63       64       65       66       67       68       69       70       71       72       73       74       75       76       77       78       79       80       81       82       83       84       85       86       87       88       89       90       91       92       93       94       95       96       97       98       99      100      101      102      103      104      105      106      107      108 SUBROUTINE DGESV( N, NRHS, A, LDA, IPIV, B, LDB, INFO ) * *  -- LAPACK driver routine (version 3.2) -- *  -- LAPACK is a software package provided by Univ. of Tennessee,    -- *  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..-- *     November 2006 * *     .. Scalar Arguments ..       INTEGER            INFO, LDA, LDB, N, NRHS *     .. *     .. Array Arguments ..       INTEGER            IPIV( * )       DOUBLE PRECISION   A( LDA, * ), B( LDB, * ) *     .. * *  Purpose *  ======= * *  DGESV computes the solution to a real system of linear equations *     A * X = B, *  where A is an N-by-N matrix and X and B are N-by-NRHS matrices. * *  The LU decomposition with partial pivoting and row interchanges is *  used to factor A as *     A = P * L * U, *  where P is a permutation matrix, L is unit lower triangular, and U is *  upper triangular.  The factored form of A is then used to solve the *  system of equations A * X = B. * *  Arguments *  ========= * *  N       (input) INTEGER *          The number of linear equations, i.e., the order of the *          matrix A.  N >= 0. * *  NRHS    (input) INTEGER *          The number of right hand sides, i.e., the number of columns *          of the matrix B.  NRHS >= 0. * *  A       (input/output) DOUBLE PRECISION array, dimension (LDA,N) *          On entry, the N-by-N coefficient matrix A. *          On exit, the factors L and U from the factorization *          A = P*L*U; the unit diagonal elements of L are not stored. * *  LDA     (input) INTEGER *          The leading dimension of the array A.  LDA >= max(1,N). * *  IPIV    (output) INTEGER array, dimension (N) *          The pivot indices that define the permutation matrix P; *          row i of the matrix was interchanged with row IPIV(i). * *  B       (input/output) DOUBLE PRECISION array, dimension (LDB,NRHS) *          On entry, the N-by-NRHS matrix of right hand side matrix B. *          On exit, if INFO = 0, the N-by-NRHS solution matrix X. * *  LDB     (input) INTEGER *          The leading dimension of the array B.  LDB >= max(1,N). * *  INFO    (output) INTEGER *          = 0:  successful exit *          < 0:  if INFO = -i, the i-th argument had an illegal value *          > 0:  if INFO = i, U(i,i) is exactly zero.  The factorization *                has been completed, but the factor U is exactly *                singular, so the solution could not be computed. * *  ===================================================================== * *     .. External Subroutines ..       EXTERNAL           DGETRF, DGETRS, XERBLA *     .. *     .. Intrinsic Functions ..       INTRINSIC          MAX *     .. *     .. Executable Statements .. * *     Test the input parameters. *       INFO = 0       IF( N.LT.0 ) THEN          INFO = -1       ELSE IF( NRHS.LT.0 ) THEN          INFO = -2       ELSE IF( LDA.LT.MAX( 1, N ) ) THEN          INFO = -4       ELSE IF( LDB.LT.MAX( 1, N ) ) THEN          INFO = -7       END IF       IF( INFO.NE.0 ) THEN          CALL XERBLA( 'DGESV ', -INFO )          RETURN       END IF * *     Compute the LU factorization of A. *       CALL DGETRF( N, N, A, LDA, IPIV, INFO )       IF( INFO.EQ.0 ) THEN * *        Solve the system A*X = B, overwriting B with X. *          CALL DGETRS( 'No transpose', N, NRHS, A, LDA, IPIV, B, LDB,      \$                INFO )       END IF       RETURN * *     End of DGESV *       END