linalg
1.4.3
A linear algebra library that provides a user-friendly interface to several BLAS and LAPACK routines.
|
Data Types | |
interface | form_lu |
Extracts the L and U matrices from the condensed [L\U] storage format used by the lu_factor. More... | |
interface | form_qr |
Forms the full M-by-M orthogonal matrix Q from the elementary reflectors returned by the base QR factorization algorithm. More... | |
interface | mult_qr |
Multiplies a general matrix by the orthogonal matrix Q from a QR factorization. More... | |
interface | mult_rz |
Multiplies a general matrix by the orthogonal matrix Z from an RZ factorization. More... | |
interface | qr_factor |
Computes the QR factorization of an M-by-N matrix. More... | |
Functions/Subroutines | |
subroutine, public | lu_factor (a, ipvt, err) |
Computes the LU factorization of an M-by-N matrix. More... | |
subroutine | form_lu_all (lu, ipvt, u, p, err) |
Extracts the L, U, and P matrices from the output of the lu_factor routine. More... | |
subroutine | form_lu_only (lu, u, err) |
Extracts the L, and U matrices from the output of the lu_factor routine. More... | |
subroutine | qr_factor_no_pivot (a, tau, work, olwork, err) |
Computes the QR factorization of an M-by-N matrix without pivoting. More... | |
subroutine | qr_factor_pivot (a, tau, jpvt, work, olwork, err) |
Computes the QR factorization of an M-by-N matrix with column pivoting such that A * P = Q * R. More... | |
subroutine | form_qr_no_pivot (r, tau, q, work, olwork, err) |
Forms the full M-by-M orthogonal matrix Q from the elementary reflectors returned by the base QR factorization algorithm. More... | |
subroutine | form_qr_pivot (r, tau, pvt, q, p, work, olwork, err) |
Forms the full M-by-M orthogonal matrix Q from the elementary reflectors returned by the base QR factorization algorithm. More... | |
subroutine | mult_qr_mtx (lside, trans, a, tau, c, work, olwork, err) |
Multiplies a general matrix by the orthogonal matrix Q from a QR factorization such that: C = op(Q) * C, or C = C * op(Q). More... | |
subroutine | mult_qr_vec (trans, a, tau, c, work, olwork, err) |
Multiplies a vector by the orthogonal matrix Q from a QR factorization such that: C = op(Q) * C. More... | |
subroutine, public | qr_rank1_update (q, r, u, v, work, err) |
Computes the rank 1 update to an M-by-N QR factored matrix A (M >= N) where A = Q * R, and A1 = A + U * V**T such that A1 = Q1 * R1. More... | |
subroutine, public | cholesky_factor (a, upper, err) |
Computes the Cholesky factorization of a symmetric, positive definite matrix. More... | |
subroutine, public | cholesky_rank1_update (r, u, work, err) |
Computes the rank 1 update to a Cholesky factored matrix (upper triangular). More... | |
subroutine, public | cholesky_rank1_downdate (r, u, work, err) |
Computes the rank 1 downdate to a Cholesky factored matrix (upper triangular). More... | |
subroutine, public | rz_factor (a, tau, work, olwork, err) |
Factors an upper trapezoidal matrix by means of orthogonal transformations such that A = R * Z = (R 0) * Z. Z is an orthogonal matrix of dimension N-by-N, and R is an M-by-M upper triangular matrix. More... | |
subroutine | mult_rz_mtx (lside, trans, l, a, tau, c, work, olwork, err) |
Multiplies a general matrix by the orthogonal matrix Z from an RZ factorization such that: C = op(Z) * C, or C = C * op(Z). More... | |
subroutine | mult_rz_vec (trans, l, a, tau, c, work, olwork, err) |
Multiplies a vector by the orthogonal matrix Z from an RZ factorization such that: C = op(Z) * C. More... | |
subroutine, public | svd (a, s, u, vt, work, olwork, err) |
Computes the singular value decomposition of a matrix A. The SVD is defined as: A = U * S * V**T, where U is an M-by-M orthogonal matrix, S is an M-by-N diagonal matrix, and V is an N-by-N orthogonal matrix. More... | |
subroutine, public linalg_factor::cholesky_factor | ( | real(real64), dimension(:,:), intent(inout) | a, |
logical, intent(in), optional | upper, | ||
class(errors), intent(inout), optional, target | err | ||
) |
Computes the Cholesky factorization of a symmetric, positive definite matrix.
[in,out] | a | On input, the N-by-N matrix to factor. On output, the factored matrix is returned in either the upper or lower triangular portion of the matrix, dependent upon the value of upper . |
[in] | upper | An optional input that, if specified, provides control over whether the factorization is computed as A = U**T * U (set to true), or as A = L * L**T (set to false). The default value is true such that A = U**T * U. |
[out] | err | An optional errors-based object that if provided can be used to retrieve information relating to any errors encountered during execution. If not provided, a default implementation of the errors class is used internally to provide error handling. Possible errors and warning messages that may be encountered are as follows.
|
Definition at line 1632 of file linalg_factor.f90.
subroutine, public linalg_factor::cholesky_rank1_downdate | ( | real(real64), dimension(:,:), intent(inout) | r, |
real(real64), dimension(:), intent(inout) | u, | ||
real(real64), dimension(:), intent(out), optional, target | work, | ||
class(errors), intent(inout), optional, target | err | ||
) |
Computes the rank 1 downdate to a Cholesky factored matrix (upper triangular).
[in,out] | r | On input, the N-by-N upper triangular matrix R. On output, the updated matrix R1. |
[in,out] | u | On input, the N-element update vector U. On output, the rotation sines used to transform R to R1. |
[out] | work | An optional argument that if supplied prevents local memory allocation. If provided, the array must have at least N elements. Additionally, this workspace array is used to contain the rotation cosines used to transform R to R1. |
[out] | err | An optional errors-based object that if provided can be used to retrieve information relating to any errors encountered during execution. If not provided, a default implementation of the errors class is used internally to provide error handling. Possible errors and warning messages that may be encountered are as follows.
|
Definition at line 1944 of file linalg_factor.f90.
subroutine, public linalg_factor::cholesky_rank1_update | ( | real(real64), dimension(:,:), intent(inout) | r, |
real(real64), dimension(:), intent(inout) | u, | ||
real(real64), dimension(:), intent(out), optional, target | work, | ||
class(errors), intent(inout), optional, target | err | ||
) |
Computes the rank 1 update to a Cholesky factored matrix (upper triangular).
[in,out] | r | On input, the N-by-N upper triangular matrix R. On output, the updated matrix R1. |
[in,out] | u | On input, the N-element update vector U. On output, the rotation sines used to transform R to R1. |
[out] | work | An optional argument that if supplied prevents local memory allocation. If provided, the array must have at least N elements. Additionally, this workspace array is used to contain the rotation cosines used to transform R to R1. |
[out] | err | An optional errors-based object that if provided can be used to retrieve information relating to any errors encountered during execution. If not provided, a default implementation of the errors class is used internally to provide error handling. Possible errors and warning messages that may be encountered are as follows.
|
Definition at line 1785 of file linalg_factor.f90.
|
private |
Extracts the L, U, and P matrices from the output of the lu_factor routine.
[in,out] | lu | On input, the N-by-N matrix as output by lu_factor. On output, the N-by-N lower triangular matrix L. |
[in] | ipvt | The N-element pivot array as output by lu_factor. |
[out] | u | An N-by-N matrix where the U matrix will be written. |
[out] | p | An N-by-N matrix where the row permutation matrix will be written. |
[out] | err | An optional errors-based object that if provided can be used to retrieve information relating to any errors encountered during execution. If not provided, a default implementation of the errors class is used internally to provide error handling. Possible errors and warning messages that may be encountered are as follows.
|
Notice, as both L and U are triangular in structure, the above equations can be solved by forward and backward substitution.
Definition at line 498 of file linalg_factor.f90.
|
private |
Extracts the L, and U matrices from the output of the lu_factor routine.
[in,out] | lu | On input, the N-by-N matrix as output by lu_factor. On output, the N-by-N lower triangular matrix L. |
[out] | u | An N-by-N matrix where the U matrix will be written. |
[out] | err | An optional errors-based object that if provided can be used to retrieve information relating to any errors encountered during execution. If not provided, a default implementation of the errors class is used internally to provide error handling. Possible errors and warning messages that may be encountered are as follows.
|
Definition at line 575 of file linalg_factor.f90.
|
private |
Forms the full M-by-M orthogonal matrix Q from the elementary reflectors returned by the base QR factorization algorithm.
[in,out] | r | On input, an M-by-N matrix where the elements below the diagonal contain the elementary reflectors generated from the QR factorization. On and above the diagonal, the matrix contains the matrix R. On output, the elements below the diagonal are zeroed such that the remaining matrix is simply the M-by-N matrix R. |
[in] | tau | A MIN(M, N)-element array containing the scalar factors of each elementary reflector defined in r . |
[out] | q | An M-by-M matrix where the full orthogonal matrix Q will be written. In the event that M > N, Q may be supplied as M-by-N, and therefore only return the useful submatrix Q1 (Q = [Q1, Q2]) as the factorization can be written as Q * R = [Q1, Q2] * [R1; 0]. |
[out] | work | An optional input, that if provided, prevents any local memory allocation. If not provided, the memory required is allocated within. If provided, the length of the array must be at least olwork . |
[out] | olwork | An optional output used to determine workspace size. If supplied, the routine determines the optimal size for work , and returns without performing any actual calculations. |
[out] | err | An optional errors-based object that if provided can be used to retrieve information relating to any errors encountered during execution. If not provided, a default implementation of the errors class is used internally to provide error handling. Possible errors and warning messages that may be encountered are as follows.
|
Definition at line 882 of file linalg_factor.f90.
|
private |
Forms the full M-by-M orthogonal matrix Q from the elementary reflectors returned by the base QR factorization algorithm.
[in,out] | r | On input, an M-by-N matrix where the elements below the diagonal contain the elementary reflectors generated from the QR factorization. On and above the diagonal, the matrix contains the matrix R. On output, the elements below the diagonal are zeroed such that the remaining matrix is simply the M-by-N matrix R. |
[in] | tau | A MIN(M, N)-element array containing the scalar factors of each elementary reflector defined in r . |
[in] | pvt | An N-element column pivot array as returned by the QR factorization. |
[out] | q | An M-by-M matrix where the full orthogonal matrix Q will be written. In the event that M > N, Q may be supplied as M-by-N, and therefore only return the useful submatrix Q1 (Q = [Q1, Q2]) as the factorization can be written as Q * R = [Q1, Q2] * [R1; 0]. |
[out] | p | An N-by-N matrix where the pivot matrix will be written. |
[out] | work | An optional input, that if provided, prevents any local memory allocation. If not provided, the memory required is allocated within. If provided, the length of the array must be at least olwork . |
[out] | olwork | An optional output used to determine workspace size. If supplied, the routine determines the optimal size for work , and returns without performing any actual calculations. |
[out] | err | An optional errors-based object that if provided can be used to retrieve information relating to any errors encountered during execution. If not provided, a default implementation of the errors class is used internally to provide error handling. Possible errors and warning messages that may be encountered are as follows.
|
Definition at line 1013 of file linalg_factor.f90.
subroutine, public linalg_factor::lu_factor | ( | real(real64), dimension(:,:), intent(inout) | a, |
integer(int32), dimension(:), intent(out) | ipvt, | ||
class(errors), intent(inout), optional, target | err | ||
) |
Computes the LU factorization of an M-by-N matrix.
[in,out] | a | On input, the M-by-N matrix on which to operate. On output, the LU factored matrix in the form [L\U] where the unit diagonal elements of L are not stored. |
[out] | ipvt | An MIN(M, N)-element array used to track row-pivot operations. The array stored pivot information such that row I is interchanged with row IPVT(I). |
[out] | err | An optional errors-based object that if provided can be used to retrieve information relating to any errors encountered during execution. If not provided, a default implementation of the errors class is used internally to provide error handling. Possible errors and warning messages that may be encountered are as follows.
|
Definition at line 414 of file linalg_factor.f90.
|
private |
Multiplies a general matrix by the orthogonal matrix Q from a QR factorization such that: C = op(Q) * C, or C = C * op(Q).
[in] | lside | Set to true to apply Q or Q**T from the left; else, set to false to apply Q or Q**T from the right. |
[in] | trans | Set to true to apply Q**T; else, set to false. |
[in] | a | On input, an LDA-by-K matrix containing the elementary reflectors output from the QR factorization. If lside is set to true, LDA = M, and M >= K >= 0; else, if lside is set to false, LDA = N, and N >= K >= 0. Notice, the contents of this matrix are restored on exit. |
[in] | tau | A K-element array containing the scalar factors of each elementary reflector defined in a . |
[in,out] | c | On input, the M-by-N matrix C. On output, the product of the orthogonal matrix Q and the original matrix C. |
[out] | work | An optional input, that if provided, prevents any local memory allocation. If not provided, the memory required is allocated within. If provided, the length of the array must be at least olwork . |
[out] | olwork | An optional output used to determine workspace size. If supplied, the routine determines the optimal size for work , and returns without performing any actual calculations. |
[out] | err | An optional errors-based object that if provided can be used to retrieve information relating to any errors encountered during execution. If not provided, a default implementation of the errors class is used internally to provide error handling. Possible errors and warning messages that may be encountered are as follows.
|
Definition at line 1115 of file linalg_factor.f90.
|
private |
Multiplies a vector by the orthogonal matrix Q from a QR factorization such that: C = op(Q) * C.
[in] | trans | Set to true to apply Q**T; else, set to false. |
[in] | a | On input, an M-by-K matrix containing the elementary reflectors output from the QR factorization. Notice, the contents of this matrix are restored on exit. |
[in] | tau | A K-element array containing the scalar factors of each elementary reflector defined in a . |
[in,out] | c | On input, the M-element vector C. On output, the product of the orthogonal matrix Q and the original vector C. |
[out] | work | An optional input, that if provided, prevents any local memory allocation. If not provided, the memory required is allocated within. If provided, the length of the array must be at least olwork . |
[out] | olwork | An optional output used to determine workspace size. If supplied, the routine determines the optimal size for work , and returns without performing any actual calculations. |
[out] | err | An optional errors-based object that if provided can be used to retrieve information relating to any errors encountered during execution. If not provided, a default implementation of the errors class is used internally to provide error handling. Possible errors and warning messages that may be encountered are as follows.
|
Definition at line 1242 of file linalg_factor.f90.
|
private |
Multiplies a general matrix by the orthogonal matrix Z from an RZ factorization such that: C = op(Z) * C, or C = C * op(Z).
[in] | lside | Set to true to apply Z or Z**T from the left; else, set to false to apply Z or Z**T from the right. |
[in] | trans | Set to true to apply Z**T; else, set to false. |
[in] | l | The number of columns in matrix a containing the meaningful part of the Householder vectors. If lside is true, M >= L >= 0; else, if lside is false, N >= L >= 0. |
[in,out] | a | On input the K-by-LTA matrix Z, where LTA = M if lside is true; else, LTA = N if lside is false. The I-th row must contain the Householder vector in the last k rows. Notice, the contents of this matrix are restored on exit. |
[in] | tau | A K-element array containing the scalar factors of the elementary reflectors, where M >= K >= 0 if lside is true; else, N >= K >= 0 if lside is false. |
[in,out] | c | On input, the M-by-N matrix C. On output, the product of the orthogonal matrix Z and the original matrix C. |
[out] | work | An optional input, that if provided, prevents any local memory allocation. If not provided, the memory required is allocated within. If provided, the length of the array must be at least olwork . |
[out] | olwork | An optional output used to determine workspace size. If supplied, the routine determines the optimal size for work , and returns without performing any actual calculations. |
[out] | err | An optional errors-based object that if provided can be used to retrieve information relating to any errors encountered during execution. If not provided, a default implementation of the errors class is used internally to provide error handling. Possible errors and warning messages that may be encountered are as follows.
|
Definition at line 2195 of file linalg_factor.f90.
|
private |
Multiplies a vector by the orthogonal matrix Z from an RZ factorization such that: C = op(Z) * C.
[in] | trans | Set to true to apply Z**T; else, set to false. |
[in] | l | The number of columns in matrix a containing the meaningful part of the Householder vectors. If lside is true, M >= L >= 0; else, if lside is false, N >= L >= 0. |
[in,out] | a | On input the K-by-LTA matrix Z, where LTA = M if lside is true; else, LTA = N if lside is false. The I-th row must contain the Householder vector in the last k rows. Notice, the contents of this matrix are restored on exit. |
[in] | tau | A K-element array containing the scalar factors of the elementary reflectors, where M >= K >= 0 if lside is true; else, N >= K >= 0 if lside is false. |
[in,out] | c | On input, the M-element array C. On output, the product of the orthogonal matrix Z and the original array C. |
[out] | work | An optional input, that if provided, prevents any local memory allocation. If not provided, the memory required is allocated within. If provided, the length of the array must be at least olwork . |
[out] | olwork | An optional output used to determine workspace size. If supplied, the routine determines the optimal size for work , and returns without performing any actual calculations. |
[out] | err | An optional errors-based object that if provided can be used to retrieve information relating to any errors encountered during execution. If not provided, a default implementation of the errors class is used internally to provide error handling. Possible errors and warning messages that may be encountered are as follows.
|
Definition at line 2337 of file linalg_factor.f90.
|
private |
Computes the QR factorization of an M-by-N matrix without pivoting.
[in,out] | a | On input, the M-by-N matrix to factor. On output, the elements on and above the diagonal contain the MIN(M, N)-by-N upper trapezoidal matrix R (R is upper triangular if M >= N). The elements below the diagonal, along with the array tau , represent the orthogonal matrix Q as a product of elementary reflectors. |
[out] | tau | A MIN(M, N)-element array used to store the scalar factors of the elementary reflectors. |
[out] | work | An optional input, that if provided, prevents any local memory allocation. If not provided, the memory required is allocated within. If provided, the length of the array must be at least olwork . |
[out] | olwork | An optional output used to determine workspace size. If supplied, the routine determines the optimal size for work , and returns without performing any actual calculations. |
[out] | err | An optional errors-based object that if provided can be used to retrieve information relating to any errors encountered during execution. If not provided, a default implementation of the errors class is used internally to provide error handling. Possible errors and warning messages that may be encountered are as follows.
|
Definition at line 664 of file linalg_factor.f90.
|
private |
Computes the QR factorization of an M-by-N matrix with column pivoting such that A * P = Q * R.
[in,out] | a | On input, the M-by-N matrix to factor. On output, the elements on and above the diagonal contain the MIN(M, N)-by-N upper trapezoidal matrix R (R is upper triangular if M >= N). The elements below the diagonal, along with the array tau , represent the orthogonal matrix Q as a product of elementary reflectors. |
[out] | tau | A MIN(M, N)-element array used to store the scalar factors of the elementary reflectors. |
[in,out] | jpvt | On input, an N-element array that if JPVT(I) .ne. 0, the I-th column of A is permuted to the front of A * P; if JPVT(I) = 0, the I-th column of A is a free column. On output, if JPVT(I) = K, then the I-th column of A * P was the K-th column of A. |
[out] | work | An optional input, that if provided, prevents any local memory allocation. If not provided, the memory required is allocated within. If provided, the length of the array must be at least olwork . |
[out] | olwork | An optional output used to determine workspace size. If supplied, the routine determines the optimal size for work , and returns without performing any actual calculations. |
[out] | err | An optional errors-based object that if provided can be used to retrieve information relating to any errors encountered during execution. If not provided, a default implementation of the errors class is used internally to provide error handling. Possible errors and warning messages that may be encountered are as follows.
|
Definition at line 767 of file linalg_factor.f90.
subroutine, public linalg_factor::qr_rank1_update | ( | real(real64), dimension(:,:), intent(inout) | q, |
real(real64), dimension(:,:), intent(inout) | r, | ||
real(real64), dimension(:), intent(inout) | u, | ||
real(real64), dimension(:), intent(inout) | v, | ||
real(real64), dimension(:), intent(out), optional, target | work, | ||
class(errors), intent(inout), optional, target | err | ||
) |
Computes the rank 1 update to an M-by-N QR factored matrix A (M >= N) where A = Q * R, and A1 = A + U * V**T such that A1 = Q1 * R1.
[in,out] | q | On input, the original M-by-K orthogonal matrix Q. On output, the updated matrix Q1. |
[in,out] | r | On input, the M-by-N matrix R. On output, the updated matrix R1. |
[in,out] | u | On input, the M-element U update vector. On output, the original content of the array is overwritten. |
[in,out] | v | On input, the N-element V update vector. On output, the original content of the array is overwritten. |
[out] | work | An optional argument that if supplied prevents local memory allocation. If provided, the array must have at least 2*K elements. |
[out] | err | An optional errors-based object that if provided can be used to retrieve information relating to any errors encountered during execution. If not provided, a default implementation of the errors class is used internally to provide error handling. Possible errors and warning messages that may be encountered are as follows.
|
Notice, K must either be equal to M, or to N. In the event that K = N, only the submatrix Qa is updated. This is appropriate as the QR factorization for an overdetermined system can be written as follows: A = Q * R = [Qa, Qb] * [Ra] [0 ] Note: Ra is upper triangular of dimension N-by-N.
Definition at line 1462 of file linalg_factor.f90.
subroutine, public linalg_factor::rz_factor | ( | real(real64), dimension(:,:), intent(inout) | a, |
real(real64), dimension(:), intent(out) | tau, | ||
real(real64), dimension(:), intent(out), optional, target | work, | ||
integer(int32), intent(out), optional | olwork, | ||
class(errors), intent(inout), optional, target | err | ||
) |
Factors an upper trapezoidal matrix by means of orthogonal transformations such that A = R * Z = (R 0) * Z. Z is an orthogonal matrix of dimension N-by-N, and R is an M-by-M upper triangular matrix.
[in,out] | a | On input, the M-by-N upper trapezoidal matrix to factor. On output, the leading M-by-M upper triangular part of the matrix contains the upper triangular matrix R, and elements N-L+1 to N of the first M rows of A, with the array tau , represent the orthogonal matrix Z as a product of M elementary reflectors. |
[out] | tau | An M-element array used to store the scalar factors of the elementary reflectors. |
[out] | work | An optional input, that if provided, prevents any local memory allocation. If not provided, the memory required is allocated within. If provided, the length of the array must be at least olwork . |
[out] | olwork | An optional output used to determine workspace size. If supplied, the routine determines the optimal size for work , and returns without performing any actual calculations. |
[out] | err | An optional errors-based object that if provided can be used to retrieve information relating to any errors encountered during execution. If not provided, a default implementation of the errors class is used internally to provide error handling. Possible errors and warning messages that may be encountered are as follows.
|
The factorization is obtained by Householder's method. The kth transformation matrix, Z( k ), which is used to introduce zeros into the ( m - k + 1 )th row of A, is given in the form Z( k ) = ( I 0 ), ( 0 T( k ) ) where T( k ) = I - tau*u( k )*u( k )**T, u( k ) = ( 1 ), ( 0 ) ( z( k ) ) tau is a scalar and z( k ) is an l element vector. tau and z( k ) are chosen to annihilate the elements of the kth row of A2. The scalar tau is returned in the kth element of TAU and the vector u( k ) in the kth row of A2, such that the elements of z( k ) are in a( k, l + 1 ), ..., a( k, n ). The elements of R are returned in the upper triangular part of A1. Z is given by Z = Z( 1 ) * Z( 2 ) * ... * Z( m ).
Definition at line 2083 of file linalg_factor.f90.
subroutine, public linalg_factor::svd | ( | real(real64), dimension(:,:), intent(inout) | a, |
real(real64), dimension(:), intent(out) | s, | ||
real(real64), dimension(:,:), intent(out), optional | u, | ||
real(real64), dimension(:,:), intent(out), optional | vt, | ||
real(real64), dimension(:), intent(out), optional, target | work, | ||
integer(int32), intent(out), optional | olwork, | ||
class(errors), intent(inout), optional, target | err | ||
) |
Computes the singular value decomposition of a matrix A. The SVD is defined as: A = U * S * V**T, where U is an M-by-M orthogonal matrix, S is an M-by-N diagonal matrix, and V is an N-by-N orthogonal matrix.
[in,out] | a | On input, the M-by-N matrix to factor. The matrix is overwritten on output. |
[out] | s | A MIN(M, N)-element array containing the singular values of a sorted in descending order. |
[out] | u | An optional argument, that if supplied, is used to contain the orthogonal matrix U from the decomposition. The matrix U contains the left singular vectors, and can be either M-by-M (all left singular vectors are computed), or M-by-MIN(M,N) (only the first MIN(M, N) left singular vectors are computed). |
[out] | vt | An optional argument, that if supplied, is used to contain the transpose of the N-by-N orthogonal matrix V. The matrix V contains the right singular vectors. |
[out] | work | An optional input, that if provided, prevents any local memory allocation. If not provided, the memory required is allocated within. If provided, the length of the array must be at least olwork . |
[out] | olwork | An optional output used to determine workspace size. If supplied, the routine determines the optimal size for work , and returns without performing any actual calculations. |
[out] | err | An optional errors-based object that if provided can be used to retrieve information relating to any errors encountered during execution. If not provided, a default implementation of the errors class is used internally to provide error handling. Possible errors and warning messages that may be encountered are as follows.
|
Definition at line 2496 of file linalg_factor.f90.