|
fortran-lapack
|
Extra-precise refinement helpers: condition numbers and pivot growth. More...
Functions/Subroutines | |
| pure real(sp) function, public | la_sla_gerpvgrw (n, ncols, a, lda, af, ldaf) |
| SLA_GERPVGRW: computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable. | |
| pure real(dp) function, public | la_dla_gerpvgrw (n, ncols, a, lda, af, ldaf) |
| DLA_GERPVGRW: computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable. | |
| pure subroutine, public | la_sla_syamv (uplo, n, alpha, a, lda, x, incx, beta, y, incy) |
| SLA_SYAMV: performs the matrix-vector operation y := alpha*abs(A)*abs(x) + beta*abs(y), where alpha and beta are scalars, x and y are vectors and A is an n by n symmetric matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand. | |
| pure subroutine, public | la_dla_syamv (uplo, n, alpha, a, lda, x, incx, beta, y, incy) |
| DLA_SYAMV: performs the matrix-vector operation y := alpha*abs(A)*abs(x) + beta*abs(y), where alpha and beta are scalars, x and y are vectors and A is an n by n symmetric matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand. | |
| real(sp) function, public | la_sla_syrcond (uplo, n, a, lda, af, ldaf, ipiv, cmode, c, info, work, iwork) |
| SLA_SYRCOND: estimates the Skeel condition number of op(A) * op2(C) where op2 is determined by CMODE as follows CMODE = 1 op2(C) = C CMODE = 0 op2(C) = I CMODE = -1 op2(C) = inv(C) The Skeel condition number cond(A) = norminf( |inv(A)||A| ) is computed by computing scaling factors R such that diag(R)*A*op2(C) is row equilibrated and computing the standard infinity-norm condition number. | |
| pure subroutine, public | la_sla_syrcond_sub (uplo, n, a, lda, af, ldaf, ipiv, cmode, c, info, work, iwork, res) |
| Pure subroutine form of SLA_SYRCOND: the same arguments, followed by RES, which returns the value of the function. | |
| real(dp) function, public | la_dla_syrcond (uplo, n, a, lda, af, ldaf, ipiv, cmode, c, info, work, iwork) |
| DLA_SYRCOND: estimates the Skeel condition number of op(A) * op2(C) where op2 is determined by CMODE as follows CMODE = 1 op2(C) = C CMODE = 0 op2(C) = I CMODE = -1 op2(C) = inv(C) The Skeel condition number cond(A) = norminf( |inv(A)||A| ) is computed by computing scaling factors R such that diag(R)*A*op2(C) is row equilibrated and computing the standard infinity-norm condition number. | |
| pure subroutine, public | la_dla_syrcond_sub (uplo, n, a, lda, af, ldaf, ipiv, cmode, c, info, work, iwork, res) |
| Pure subroutine form of DLA_SYRCOND: the same arguments, followed by RES, which returns the value of the function. | |
| real(sp) function, public | la_sla_syrpvgrw (uplo, n, info, a, lda, af, ldaf, ipiv, work) |
| SLA_SYRPVGRW: computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable. | |
| pure subroutine, public | la_sla_syrpvgrw_sub (uplo, n, info, a, lda, af, ldaf, ipiv, work, res) |
| Pure subroutine form of SLA_SYRPVGRW: the same arguments, followed by RES, which returns the value of the function. | |
| real(dp) function, public | la_dla_syrpvgrw (uplo, n, info, a, lda, af, ldaf, ipiv, work) |
| DLA_SYRPVGRW: computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable. | |
| pure subroutine, public | la_dla_syrpvgrw_sub (uplo, n, info, a, lda, af, ldaf, ipiv, work, res) |
| Pure subroutine form of DLA_SYRPVGRW: the same arguments, followed by RES, which returns the value of the function. | |
| pure real(sp) function, public | la_cla_gerpvgrw (n, ncols, a, lda, af, ldaf) |
| CLA_GERPVGRW: computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable. | |
| pure real(dp) function, public | la_zla_gerpvgrw (n, ncols, a, lda, af, ldaf) |
| ZLA_GERPVGRW: computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable. | |
| pure subroutine, public | la_cla_syamv (uplo, n, alpha, a, lda, x, incx, beta, y, incy) |
| CLA_SYAMV: performs the matrix-vector operation y := alpha*abs(A)*abs(x) + beta*abs(y), where alpha and beta are scalars, x and y are vectors and A is an n by n symmetric matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand. | |
| pure subroutine, public | la_zla_syamv (uplo, n, alpha, a, lda, x, incx, beta, y, incy) |
| ZLA_SYAMV: performs the matrix-vector operation y := alpha*abs(A)*abs(x) + beta*abs(y), where alpha and beta are scalars, x and y are vectors and A is an n by n symmetric matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand. | |
| real(sp) function, public | la_cla_gbrcond_c (trans, n, kl, ku, ab, ldab, afb, ldafb, ipiv, c, capply, info, work, rwork) |
| CLA_GBRCOND_C: Computes the infinity norm condition number of op(A) * inv(diag(C)) where C is a REAL vector. | |
| pure subroutine, public | la_cla_gbrcond_c_sub (trans, n, kl, ku, ab, ldab, afb, ldafb, ipiv, c, capply, info, work, rwork, res) |
| Pure subroutine form of CLA_GBRCOND_C: the same arguments, followed by RES, which returns the value of the function. | |
| real(dp) function, public | la_zla_gbrcond_c (trans, n, kl, ku, ab, ldab, afb, ldafb, ipiv, c, capply, info, work, rwork) |
| ZLA_GBRCOND_C: Computes the infinity norm condition number of op(A) * inv(diag(C)) where C is a DOUBLE PRECISION vector. | |
| pure subroutine, public | la_zla_gbrcond_c_sub (trans, n, kl, ku, ab, ldab, afb, ldafb, ipiv, c, capply, info, work, rwork, res) |
| Pure subroutine form of ZLA_GBRCOND_C: the same arguments, followed by RES, which returns the value of the function. | |
| real(sp) function, public | la_cla_gercond_c (trans, n, a, lda, af, ldaf, ipiv, c, capply, info, work, rwork) |
| CLA_GERCOND_C: computes the infinity norm condition number of op(A) * inv(diag(C)) where C is a REAL vector. | |
| pure subroutine, public | la_cla_gercond_c_sub (trans, n, a, lda, af, ldaf, ipiv, c, capply, info, work, rwork, res) |
| Pure subroutine form of CLA_GERCOND_C: the same arguments, followed by RES, which returns the value of the function. | |
| real(dp) function, public | la_zla_gercond_c (trans, n, a, lda, af, ldaf, ipiv, c, capply, info, work, rwork) |
| ZLA_GERCOND_C: computes the infinity norm condition number of op(A) * inv(diag(C)) where C is a DOUBLE PRECISION vector. | |
| pure subroutine, public | la_zla_gercond_c_sub (trans, n, a, lda, af, ldaf, ipiv, c, capply, info, work, rwork, res) |
| Pure subroutine form of ZLA_GERCOND_C: the same arguments, followed by RES, which returns the value of the function. | |
| real(sp) function, public | la_cla_hercond_c (uplo, n, a, lda, af, ldaf, ipiv, c, capply, info, work, rwork) |
| CLA_HERCOND_C: computes the infinity norm condition number of op(A) * inv(diag(C)) where C is a REAL vector. | |
| pure subroutine, public | la_cla_hercond_c_sub (uplo, n, a, lda, af, ldaf, ipiv, c, capply, info, work, rwork, res) |
| Pure subroutine form of CLA_HERCOND_C: the same arguments, followed by RES, which returns the value of the function. | |
| real(dp) function, public | la_zla_hercond_c (uplo, n, a, lda, af, ldaf, ipiv, c, capply, info, work, rwork) |
| ZLA_HERCOND_C: computes the infinity norm condition number of op(A) * inv(diag(C)) where C is a DOUBLE PRECISION vector. | |
| pure subroutine, public | la_zla_hercond_c_sub (uplo, n, a, lda, af, ldaf, ipiv, c, capply, info, work, rwork, res) |
| Pure subroutine form of ZLA_HERCOND_C: the same arguments, followed by RES, which returns the value of the function. | |
| real(sp) function, public | la_cla_porcond_c (uplo, n, a, lda, af, ldaf, c, capply, info, work, rwork) |
| CLA_PORCOND_C: Computes the infinity norm condition number of op(A) * inv(diag(C)) where C is a REAL vector. | |
| pure subroutine, public | la_cla_porcond_c_sub (uplo, n, a, lda, af, ldaf, c, capply, info, work, rwork, res) |
| Pure subroutine form of CLA_PORCOND_C: the same arguments, followed by RES, which returns the value of the function. | |
| real(dp) function, public | la_zla_porcond_c (uplo, n, a, lda, af, ldaf, c, capply, info, work, rwork) |
| ZLA_PORCOND_C: Computes the infinity norm condition number of op(A) * inv(diag(C)) where C is a DOUBLE PRECISION vector. | |
| pure subroutine, public | la_zla_porcond_c_sub (uplo, n, a, lda, af, ldaf, c, capply, info, work, rwork, res) |
| Pure subroutine form of ZLA_PORCOND_C: the same arguments, followed by RES, which returns the value of the function. | |
| real(sp) function, public | la_cla_syrcond_c (uplo, n, a, lda, af, ldaf, ipiv, c, capply, info, work, rwork) |
| CLA_SYRCOND_C: Computes the infinity norm condition number of op(A) * inv(diag(C)) where C is a REAL vector. | |
| pure subroutine, public | la_cla_syrcond_c_sub (uplo, n, a, lda, af, ldaf, ipiv, c, capply, info, work, rwork, res) |
| Pure subroutine form of CLA_SYRCOND_C: the same arguments, followed by RES, which returns the value of the function. | |
| real(dp) function, public | la_zla_syrcond_c (uplo, n, a, lda, af, ldaf, ipiv, c, capply, info, work, rwork) |
| ZLA_SYRCOND_C: Computes the infinity norm condition number of op(A) * inv(diag(C)) where C is a DOUBLE PRECISION vector. | |
| pure subroutine, public | la_zla_syrcond_c_sub (uplo, n, a, lda, af, ldaf, ipiv, c, capply, info, work, rwork, res) |
| Pure subroutine form of ZLA_SYRCOND_C: the same arguments, followed by RES, which returns the value of the function. | |
| real(sp) function, public | la_cla_syrpvgrw (uplo, n, info, a, lda, af, ldaf, ipiv, work) |
| CLA_SYRPVGRW: computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable. | |
| pure subroutine, public | la_cla_syrpvgrw_sub (uplo, n, info, a, lda, af, ldaf, ipiv, work, res) |
| Pure subroutine form of CLA_SYRPVGRW: the same arguments, followed by RES, which returns the value of the function. | |
| real(dp) function, public | la_zla_syrpvgrw (uplo, n, info, a, lda, af, ldaf, ipiv, work) |
| ZLA_SYRPVGRW: computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable. | |
| pure subroutine, public | la_zla_syrpvgrw_sub (uplo, n, info, a, lda, af, ldaf, ipiv, work, res) |
| Pure subroutine form of ZLA_SYRPVGRW: the same arguments, followed by RES, which returns the value of the function. | |
Extra-precise refinement helpers: condition numbers and pivot growth.
| real(sp) function, public la_lapack_others_sm::la_cla_gbrcond_c | ( | character, intent(in) | trans, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| complex(sp), dimension(ldab,*), intent(in) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| complex(sp), dimension(ldafb,*), intent(in) | afb, | ||
| integer(ilp), intent(in) | ldafb, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(sp), dimension(*), intent(in) | c, | ||
| logical(lk), intent(in) | capply, | ||
| integer(ilp), intent(out) | info, | ||
| complex(sp), dimension(*), intent(out) | work, | ||
| real(sp), dimension(*), intent(out) | rwork ) |
CLA_GBRCOND_C: Computes the infinity norm condition number of op(A) * inv(diag(C)) where C is a REAL vector.

| pure subroutine, public la_lapack_others_sm::la_cla_gbrcond_c_sub | ( | character, intent(in) | trans, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| complex(sp), dimension(ldab,*), intent(in) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| complex(sp), dimension(ldafb,*), intent(in) | afb, | ||
| integer(ilp), intent(in) | ldafb, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(sp), dimension(*), intent(in) | c, | ||
| logical(lk), intent(in) | capply, | ||
| integer(ilp), intent(out) | info, | ||
| complex(sp), dimension(*), intent(out) | work, | ||
| real(sp), dimension(*), intent(out) | rwork, | ||
| real(sp), intent(out) | res ) |
Pure subroutine form of CLA_GBRCOND_C: the same arguments, followed by RES, which returns the value of the function.
| real(sp) function, public la_lapack_others_sm::la_cla_gercond_c | ( | character, intent(in) | trans, |
| integer(ilp), intent(in) | n, | ||
| complex(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(sp), dimension(ldaf,*), intent(in) | af, | ||
| integer(ilp), intent(in) | ldaf, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(sp), dimension(*), intent(in) | c, | ||
| logical(lk), intent(in) | capply, | ||
| integer(ilp), intent(out) | info, | ||
| complex(sp), dimension(*), intent(out) | work, | ||
| real(sp), dimension(*), intent(out) | rwork ) |
CLA_GERCOND_C: computes the infinity norm condition number of op(A) * inv(diag(C)) where C is a REAL vector.

| pure subroutine, public la_lapack_others_sm::la_cla_gercond_c_sub | ( | character, intent(in) | trans, |
| integer(ilp), intent(in) | n, | ||
| complex(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(sp), dimension(ldaf,*), intent(in) | af, | ||
| integer(ilp), intent(in) | ldaf, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(sp), dimension(*), intent(in) | c, | ||
| logical(lk), intent(in) | capply, | ||
| integer(ilp), intent(out) | info, | ||
| complex(sp), dimension(*), intent(out) | work, | ||
| real(sp), dimension(*), intent(out) | rwork, | ||
| real(sp), intent(out) | res ) |
Pure subroutine form of CLA_GERCOND_C: the same arguments, followed by RES, which returns the value of the function.
| pure real(sp) function, public la_lapack_others_sm::la_cla_gerpvgrw | ( | integer(ilp), intent(in) | n, |
| integer(ilp), intent(in) | ncols, | ||
| complex(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(sp), dimension(ldaf,*), intent(in) | af, | ||
| integer(ilp), intent(in) | ldaf ) |
CLA_GERPVGRW: computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.

| real(sp) function, public la_lapack_others_sm::la_cla_hercond_c | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(sp), dimension(ldaf,*), intent(in) | af, | ||
| integer(ilp), intent(in) | ldaf, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(sp), dimension(*), intent(in) | c, | ||
| logical(lk), intent(in) | capply, | ||
| integer(ilp), intent(out) | info, | ||
| complex(sp), dimension(*), intent(out) | work, | ||
| real(sp), dimension(*), intent(out) | rwork ) |
CLA_HERCOND_C: computes the infinity norm condition number of op(A) * inv(diag(C)) where C is a REAL vector.

| pure subroutine, public la_lapack_others_sm::la_cla_hercond_c_sub | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(sp), dimension(ldaf,*), intent(in) | af, | ||
| integer(ilp), intent(in) | ldaf, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(sp), dimension(*), intent(in) | c, | ||
| logical(lk), intent(in) | capply, | ||
| integer(ilp), intent(out) | info, | ||
| complex(sp), dimension(*), intent(out) | work, | ||
| real(sp), dimension(*), intent(out) | rwork, | ||
| real(sp), intent(out) | res ) |
Pure subroutine form of CLA_HERCOND_C: the same arguments, followed by RES, which returns the value of the function.
| real(sp) function, public la_lapack_others_sm::la_cla_porcond_c | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(sp), dimension(ldaf,*), intent(in) | af, | ||
| integer(ilp), intent(in) | ldaf, | ||
| real(sp), dimension(*), intent(in) | c, | ||
| logical(lk), intent(in) | capply, | ||
| integer(ilp), intent(out) | info, | ||
| complex(sp), dimension(*), intent(out) | work, | ||
| real(sp), dimension(*), intent(out) | rwork ) |
CLA_PORCOND_C: Computes the infinity norm condition number of op(A) * inv(diag(C)) where C is a REAL vector.

| pure subroutine, public la_lapack_others_sm::la_cla_porcond_c_sub | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(sp), dimension(ldaf,*), intent(in) | af, | ||
| integer(ilp), intent(in) | ldaf, | ||
| real(sp), dimension(*), intent(in) | c, | ||
| logical(lk), intent(in) | capply, | ||
| integer(ilp), intent(out) | info, | ||
| complex(sp), dimension(*), intent(out) | work, | ||
| real(sp), dimension(*), intent(out) | rwork, | ||
| real(sp), intent(out) | res ) |
Pure subroutine form of CLA_PORCOND_C: the same arguments, followed by RES, which returns the value of the function.
| pure subroutine, public la_lapack_others_sm::la_cla_syamv | ( | integer(ilp), intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(sp), intent(in) | alpha, | ||
| complex(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(sp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| real(sp), intent(in) | beta, | ||
| real(sp), dimension(*), intent(inout) | y, | ||
| integer(ilp), intent(in) | incy ) |
CLA_SYAMV: performs the matrix-vector operation y := alpha*abs(A)*abs(x) + beta*abs(y), where alpha and beta are scalars, x and y are vectors and A is an n by n symmetric matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand.
| real(sp) function, public la_lapack_others_sm::la_cla_syrcond_c | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(sp), dimension(ldaf,*), intent(in) | af, | ||
| integer(ilp), intent(in) | ldaf, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(sp), dimension(*), intent(in) | c, | ||
| logical(lk), intent(in) | capply, | ||
| integer(ilp), intent(out) | info, | ||
| complex(sp), dimension(*), intent(out) | work, | ||
| real(sp), dimension(*), intent(out) | rwork ) |
CLA_SYRCOND_C: Computes the infinity norm condition number of op(A) * inv(diag(C)) where C is a REAL vector.

| pure subroutine, public la_lapack_others_sm::la_cla_syrcond_c_sub | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(sp), dimension(ldaf,*), intent(in) | af, | ||
| integer(ilp), intent(in) | ldaf, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(sp), dimension(*), intent(in) | c, | ||
| logical(lk), intent(in) | capply, | ||
| integer(ilp), intent(out) | info, | ||
| complex(sp), dimension(*), intent(out) | work, | ||
| real(sp), dimension(*), intent(out) | rwork, | ||
| real(sp), intent(out) | res ) |
Pure subroutine form of CLA_SYRCOND_C: the same arguments, followed by RES, which returns the value of the function.
| real(sp) function, public la_lapack_others_sm::la_cla_syrpvgrw | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | info, | ||
| complex(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(sp), dimension(ldaf,*), intent(in) | af, | ||
| integer(ilp), intent(in) | ldaf, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(sp), dimension(*), intent(out) | work ) |
CLA_SYRPVGRW: computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.

| pure subroutine, public la_lapack_others_sm::la_cla_syrpvgrw_sub | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | info, | ||
| complex(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(sp), dimension(ldaf,*), intent(in) | af, | ||
| integer(ilp), intent(in) | ldaf, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(sp), dimension(*), intent(out) | work, | ||
| real(sp), intent(out) | res ) |
Pure subroutine form of CLA_SYRPVGRW: the same arguments, followed by RES, which returns the value of the function.
| pure real(dp) function, public la_lapack_others_sm::la_dla_gerpvgrw | ( | integer(ilp), intent(in) | n, |
| integer(ilp), intent(in) | ncols, | ||
| real(dp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(dp), dimension(ldaf,*), intent(in) | af, | ||
| integer(ilp), intent(in) | ldaf ) |
DLA_GERPVGRW: computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.

| pure subroutine, public la_lapack_others_sm::la_dla_syamv | ( | integer(ilp), intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(dp), intent(in) | alpha, | ||
| real(dp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(dp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| real(dp), intent(in) | beta, | ||
| real(dp), dimension(*), intent(inout) | y, | ||
| integer(ilp), intent(in) | incy ) |
DLA_SYAMV: performs the matrix-vector operation y := alpha*abs(A)*abs(x) + beta*abs(y), where alpha and beta are scalars, x and y are vectors and A is an n by n symmetric matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand.

| real(dp) function, public la_lapack_others_sm::la_dla_syrcond | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(dp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(dp), dimension(ldaf,*), intent(in) | af, | ||
| integer(ilp), intent(in) | ldaf, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| integer(ilp), intent(in) | cmode, | ||
| real(dp), dimension(*), intent(in) | c, | ||
| integer(ilp), intent(out) | info, | ||
| real(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), dimension(*), intent(out) | iwork ) |
DLA_SYRCOND: estimates the Skeel condition number of op(A) * op2(C) where op2 is determined by CMODE as follows CMODE = 1 op2(C) = C CMODE = 0 op2(C) = I CMODE = -1 op2(C) = inv(C) The Skeel condition number cond(A) = norminf( |inv(A)||A| ) is computed by computing scaling factors R such that diag(R)*A*op2(C) is row equilibrated and computing the standard infinity-norm condition number.

| pure subroutine, public la_lapack_others_sm::la_dla_syrcond_sub | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(dp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(dp), dimension(ldaf,*), intent(in) | af, | ||
| integer(ilp), intent(in) | ldaf, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| integer(ilp), intent(in) | cmode, | ||
| real(dp), dimension(*), intent(in) | c, | ||
| integer(ilp), intent(out) | info, | ||
| real(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| real(dp), intent(out) | res ) |
Pure subroutine form of DLA_SYRCOND: the same arguments, followed by RES, which returns the value of the function.
| real(dp) function, public la_lapack_others_sm::la_dla_syrpvgrw | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | info, | ||
| real(dp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(dp), dimension(ldaf,*), intent(in) | af, | ||
| integer(ilp), intent(in) | ldaf, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(dp), dimension(*), intent(out) | work ) |
DLA_SYRPVGRW: computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.

| pure subroutine, public la_lapack_others_sm::la_dla_syrpvgrw_sub | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | info, | ||
| real(dp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(dp), dimension(ldaf,*), intent(in) | af, | ||
| integer(ilp), intent(in) | ldaf, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(dp), dimension(*), intent(out) | work, | ||
| real(dp), intent(out) | res ) |
Pure subroutine form of DLA_SYRPVGRW: the same arguments, followed by RES, which returns the value of the function.
| pure real(sp) function, public la_lapack_others_sm::la_sla_gerpvgrw | ( | integer(ilp), intent(in) | n, |
| integer(ilp), intent(in) | ncols, | ||
| real(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(ldaf,*), intent(in) | af, | ||
| integer(ilp), intent(in) | ldaf ) |
SLA_GERPVGRW: computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.

| pure subroutine, public la_lapack_others_sm::la_sla_syamv | ( | integer(ilp), intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(sp), intent(in) | alpha, | ||
| real(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| real(sp), intent(in) | beta, | ||
| real(sp), dimension(*), intent(inout) | y, | ||
| integer(ilp), intent(in) | incy ) |
SLA_SYAMV: performs the matrix-vector operation y := alpha*abs(A)*abs(x) + beta*abs(y), where alpha and beta are scalars, x and y are vectors and A is an n by n symmetric matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand.

| real(sp) function, public la_lapack_others_sm::la_sla_syrcond | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(ldaf,*), intent(in) | af, | ||
| integer(ilp), intent(in) | ldaf, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| integer(ilp), intent(in) | cmode, | ||
| real(sp), dimension(*), intent(in) | c, | ||
| integer(ilp), intent(out) | info, | ||
| real(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), dimension(*), intent(out) | iwork ) |
SLA_SYRCOND: estimates the Skeel condition number of op(A) * op2(C) where op2 is determined by CMODE as follows CMODE = 1 op2(C) = C CMODE = 0 op2(C) = I CMODE = -1 op2(C) = inv(C) The Skeel condition number cond(A) = norminf( |inv(A)||A| ) is computed by computing scaling factors R such that diag(R)*A*op2(C) is row equilibrated and computing the standard infinity-norm condition number.

| pure subroutine, public la_lapack_others_sm::la_sla_syrcond_sub | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(ldaf,*), intent(in) | af, | ||
| integer(ilp), intent(in) | ldaf, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| integer(ilp), intent(in) | cmode, | ||
| real(sp), dimension(*), intent(in) | c, | ||
| integer(ilp), intent(out) | info, | ||
| real(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), dimension(*), intent(out) | iwork, | ||
| real(sp), intent(out) | res ) |
Pure subroutine form of SLA_SYRCOND: the same arguments, followed by RES, which returns the value of the function.
| real(sp) function, public la_lapack_others_sm::la_sla_syrpvgrw | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | info, | ||
| real(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(ldaf,*), intent(in) | af, | ||
| integer(ilp), intent(in) | ldaf, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(sp), dimension(*), intent(out) | work ) |
SLA_SYRPVGRW: computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.

| pure subroutine, public la_lapack_others_sm::la_sla_syrpvgrw_sub | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | info, | ||
| real(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(ldaf,*), intent(in) | af, | ||
| integer(ilp), intent(in) | ldaf, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(sp), dimension(*), intent(out) | work, | ||
| real(sp), intent(out) | res ) |
Pure subroutine form of SLA_SYRPVGRW: the same arguments, followed by RES, which returns the value of the function.
| real(dp) function, public la_lapack_others_sm::la_zla_gbrcond_c | ( | character, intent(in) | trans, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| complex(dp), dimension(ldab,*), intent(in) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| complex(dp), dimension(ldafb,*), intent(in) | afb, | ||
| integer(ilp), intent(in) | ldafb, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(dp), dimension(*), intent(in) | c, | ||
| logical(lk), intent(in) | capply, | ||
| integer(ilp), intent(out) | info, | ||
| complex(dp), dimension(*), intent(out) | work, | ||
| real(dp), dimension(*), intent(out) | rwork ) |
ZLA_GBRCOND_C: Computes the infinity norm condition number of op(A) * inv(diag(C)) where C is a DOUBLE PRECISION vector.

| pure subroutine, public la_lapack_others_sm::la_zla_gbrcond_c_sub | ( | character, intent(in) | trans, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| complex(dp), dimension(ldab,*), intent(in) | ab, | ||
| integer(ilp), intent(in) | ldab, | ||
| complex(dp), dimension(ldafb,*), intent(in) | afb, | ||
| integer(ilp), intent(in) | ldafb, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(dp), dimension(*), intent(in) | c, | ||
| logical(lk), intent(in) | capply, | ||
| integer(ilp), intent(out) | info, | ||
| complex(dp), dimension(*), intent(out) | work, | ||
| real(dp), dimension(*), intent(out) | rwork, | ||
| real(dp), intent(out) | res ) |
Pure subroutine form of ZLA_GBRCOND_C: the same arguments, followed by RES, which returns the value of the function.
| real(dp) function, public la_lapack_others_sm::la_zla_gercond_c | ( | character, intent(in) | trans, |
| integer(ilp), intent(in) | n, | ||
| complex(dp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(dp), dimension(ldaf,*), intent(in) | af, | ||
| integer(ilp), intent(in) | ldaf, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(dp), dimension(*), intent(in) | c, | ||
| logical(lk), intent(in) | capply, | ||
| integer(ilp), intent(out) | info, | ||
| complex(dp), dimension(*), intent(out) | work, | ||
| real(dp), dimension(*), intent(out) | rwork ) |
ZLA_GERCOND_C: computes the infinity norm condition number of op(A) * inv(diag(C)) where C is a DOUBLE PRECISION vector.

| pure subroutine, public la_lapack_others_sm::la_zla_gercond_c_sub | ( | character, intent(in) | trans, |
| integer(ilp), intent(in) | n, | ||
| complex(dp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(dp), dimension(ldaf,*), intent(in) | af, | ||
| integer(ilp), intent(in) | ldaf, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(dp), dimension(*), intent(in) | c, | ||
| logical(lk), intent(in) | capply, | ||
| integer(ilp), intent(out) | info, | ||
| complex(dp), dimension(*), intent(out) | work, | ||
| real(dp), dimension(*), intent(out) | rwork, | ||
| real(dp), intent(out) | res ) |
Pure subroutine form of ZLA_GERCOND_C: the same arguments, followed by RES, which returns the value of the function.
| pure real(dp) function, public la_lapack_others_sm::la_zla_gerpvgrw | ( | integer(ilp), intent(in) | n, |
| integer(ilp), intent(in) | ncols, | ||
| complex(dp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(dp), dimension(ldaf,*), intent(in) | af, | ||
| integer(ilp), intent(in) | ldaf ) |
ZLA_GERPVGRW: computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.

| real(dp) function, public la_lapack_others_sm::la_zla_hercond_c | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(dp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(dp), dimension(ldaf,*), intent(in) | af, | ||
| integer(ilp), intent(in) | ldaf, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(dp), dimension(*), intent(in) | c, | ||
| logical(lk), intent(in) | capply, | ||
| integer(ilp), intent(out) | info, | ||
| complex(dp), dimension(*), intent(out) | work, | ||
| real(dp), dimension(*), intent(out) | rwork ) |
ZLA_HERCOND_C: computes the infinity norm condition number of op(A) * inv(diag(C)) where C is a DOUBLE PRECISION vector.

| pure subroutine, public la_lapack_others_sm::la_zla_hercond_c_sub | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(dp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(dp), dimension(ldaf,*), intent(in) | af, | ||
| integer(ilp), intent(in) | ldaf, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(dp), dimension(*), intent(in) | c, | ||
| logical(lk), intent(in) | capply, | ||
| integer(ilp), intent(out) | info, | ||
| complex(dp), dimension(*), intent(out) | work, | ||
| real(dp), dimension(*), intent(out) | rwork, | ||
| real(dp), intent(out) | res ) |
Pure subroutine form of ZLA_HERCOND_C: the same arguments, followed by RES, which returns the value of the function.
| real(dp) function, public la_lapack_others_sm::la_zla_porcond_c | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(dp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(dp), dimension(ldaf,*), intent(in) | af, | ||
| integer(ilp), intent(in) | ldaf, | ||
| real(dp), dimension(*), intent(in) | c, | ||
| logical(lk), intent(in) | capply, | ||
| integer(ilp), intent(out) | info, | ||
| complex(dp), dimension(*), intent(out) | work, | ||
| real(dp), dimension(*), intent(out) | rwork ) |
ZLA_PORCOND_C: Computes the infinity norm condition number of op(A) * inv(diag(C)) where C is a DOUBLE PRECISION vector.

| pure subroutine, public la_lapack_others_sm::la_zla_porcond_c_sub | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(dp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(dp), dimension(ldaf,*), intent(in) | af, | ||
| integer(ilp), intent(in) | ldaf, | ||
| real(dp), dimension(*), intent(in) | c, | ||
| logical(lk), intent(in) | capply, | ||
| integer(ilp), intent(out) | info, | ||
| complex(dp), dimension(*), intent(out) | work, | ||
| real(dp), dimension(*), intent(out) | rwork, | ||
| real(dp), intent(out) | res ) |
Pure subroutine form of ZLA_PORCOND_C: the same arguments, followed by RES, which returns the value of the function.
| pure subroutine, public la_lapack_others_sm::la_zla_syamv | ( | integer(ilp), intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(dp), intent(in) | alpha, | ||
| complex(dp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(dp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| real(dp), intent(in) | beta, | ||
| real(dp), dimension(*), intent(inout) | y, | ||
| integer(ilp), intent(in) | incy ) |
ZLA_SYAMV: performs the matrix-vector operation y := alpha*abs(A)*abs(x) + beta*abs(y), where alpha and beta are scalars, x and y are vectors and A is an n by n symmetric matrix. This function is primarily used in calculating error bounds. To protect against underflow during evaluation, components in the resulting vector are perturbed away from zero by (N+1) times the underflow threshold. To prevent unnecessarily large errors for block-structure embedded in general matrices, "symbolically" zero components are not perturbed. A zero entry is considered "symbolic" if all multiplications involved in computing that entry have at least one zero multiplicand.
| real(dp) function, public la_lapack_others_sm::la_zla_syrcond_c | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(dp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(dp), dimension(ldaf,*), intent(in) | af, | ||
| integer(ilp), intent(in) | ldaf, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(dp), dimension(*), intent(in) | c, | ||
| logical(lk), intent(in) | capply, | ||
| integer(ilp), intent(out) | info, | ||
| complex(dp), dimension(*), intent(out) | work, | ||
| real(dp), dimension(*), intent(out) | rwork ) |
ZLA_SYRCOND_C: Computes the infinity norm condition number of op(A) * inv(diag(C)) where C is a DOUBLE PRECISION vector.

| pure subroutine, public la_lapack_others_sm::la_zla_syrcond_c_sub | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| complex(dp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(dp), dimension(ldaf,*), intent(in) | af, | ||
| integer(ilp), intent(in) | ldaf, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(dp), dimension(*), intent(in) | c, | ||
| logical(lk), intent(in) | capply, | ||
| integer(ilp), intent(out) | info, | ||
| complex(dp), dimension(*), intent(out) | work, | ||
| real(dp), dimension(*), intent(out) | rwork, | ||
| real(dp), intent(out) | res ) |
Pure subroutine form of ZLA_SYRCOND_C: the same arguments, followed by RES, which returns the value of the function.
| real(dp) function, public la_lapack_others_sm::la_zla_syrpvgrw | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | info, | ||
| complex(dp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(dp), dimension(ldaf,*), intent(in) | af, | ||
| integer(ilp), intent(in) | ldaf, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(dp), dimension(*), intent(out) | work ) |
ZLA_SYRPVGRW: computes the reciprocal pivot growth factor norm(A)/norm(U). The "max absolute element" norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix A could be poor. This also means that the solution X, estimated condition numbers, and error bounds could be unreliable.

| pure subroutine, public la_lapack_others_sm::la_zla_syrpvgrw_sub | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | info, | ||
| complex(dp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(dp), dimension(ldaf,*), intent(in) | af, | ||
| integer(ilp), intent(in) | ldaf, | ||
| integer(ilp), dimension(*), intent(in) | ipiv, | ||
| real(dp), dimension(*), intent(out) | work, | ||
| real(dp), intent(out) | res ) |
Pure subroutine form of ZLA_SYRPVGRW: the same arguments, followed by RES, which returns the value of the function.