|
fortran-lapack
|
Compute a least squares solution to system \( A \cdot x = b \), i.e. such that the 2-norm \( \|b - A \cdot x\| \) is minimized. More...
Public Member Functions | |
| pure real(sp) function, dimension(:), allocatable | la_slstsq_one (a, b, cond) |
Compute the least-squares solution to a real(sp) system of linear equations Ax = B: pure, stops on error. | |
| real(sp) function, dimension(:), allocatable, target | la_slstsq_err_one (a, b, cond, overwrite_a, rank, err) |
| Compute the least-squares solution to a real(sp) system of linear equations Ax = B, with a state return flag. | |
| pure real(dp) function, dimension(:), allocatable | la_dlstsq_one (a, b, cond) |
Compute the least-squares solution to a real(dp) system of linear equations Ax = B: pure, stops on error. | |
| real(dp) function, dimension(:), allocatable, target | la_dlstsq_err_one (a, b, cond, overwrite_a, rank, err) |
| Compute the least-squares solution to a real(dp) system of linear equations Ax = B, with a state return flag. | |
| pure real(xdp) function, dimension(:), allocatable | la_xlstsq_one (a, b, cond) |
Compute the least-squares solution to a real(xdp) system of linear equations Ax = B: pure, stops on error. | |
| real(xdp) function, dimension(:), allocatable, target | la_xlstsq_err_one (a, b, cond, overwrite_a, rank, err) |
| Compute the least-squares solution to a real(xdp) system of linear equations Ax = B, with a state return flag. | |
| pure real(qp) function, dimension(:), allocatable | la_qlstsq_one (a, b, cond) |
Compute the least-squares solution to a real(qp) system of linear equations Ax = B: pure, stops on error. | |
| real(qp) function, dimension(:), allocatable, target | la_qlstsq_err_one (a, b, cond, overwrite_a, rank, err) |
| Compute the least-squares solution to a real(qp) system of linear equations Ax = B, with a state return flag. | |
| pure complex(sp) function, dimension(:), allocatable | la_clstsq_one (a, b, cond) |
Compute the least-squares solution to a complex(sp) system of linear equations Ax = B: pure, stops on error. | |
| complex(sp) function, dimension(:), allocatable, target | la_clstsq_err_one (a, b, cond, overwrite_a, rank, err) |
| Compute the least-squares solution to a complex(sp) system of linear equations Ax = B, with a state return flag. | |
| pure complex(dp) function, dimension(:), allocatable | la_zlstsq_one (a, b, cond) |
Compute the least-squares solution to a complex(dp) system of linear equations Ax = B: pure, stops on error. | |
| complex(dp) function, dimension(:), allocatable, target | la_zlstsq_err_one (a, b, cond, overwrite_a, rank, err) |
| Compute the least-squares solution to a complex(dp) system of linear equations Ax = B, with a state return flag. | |
| pure complex(xdp) function, dimension(:), allocatable | la_ylstsq_one (a, b, cond) |
Compute the least-squares solution to a complex(xdp) system of linear equations Ax = B: pure, stops on error. | |
| complex(xdp) function, dimension(:), allocatable, target | la_ylstsq_err_one (a, b, cond, overwrite_a, rank, err) |
| Compute the least-squares solution to a complex(xdp) system of linear equations Ax = B, with a state return flag. | |
| pure complex(qp) function, dimension(:), allocatable | la_wlstsq_one (a, b, cond) |
Compute the least-squares solution to a complex(qp) system of linear equations Ax = B: pure, stops on error. | |
| complex(qp) function, dimension(:), allocatable, target | la_wlstsq_err_one (a, b, cond, overwrite_a, rank, err) |
| Compute the least-squares solution to a complex(qp) system of linear equations Ax = B, with a state return flag. | |
| pure real(sp) function, dimension(:,:), allocatable | la_slstsq_multiple (a, b, cond) |
Compute the least-squares solution to a real(sp) system of linear equations Ax = B: pure, stops on error. | |
| real(sp) function, dimension(:,:), allocatable, target | la_slstsq_err_multiple (a, b, cond, overwrite_a, rank, err) |
| Compute the least-squares solution to a real(sp) system of linear equations Ax = B, with a state return flag. | |
| pure real(dp) function, dimension(:,:), allocatable | la_dlstsq_multiple (a, b, cond) |
Compute the least-squares solution to a real(dp) system of linear equations Ax = B: pure, stops on error. | |
| real(dp) function, dimension(:,:), allocatable, target | la_dlstsq_err_multiple (a, b, cond, overwrite_a, rank, err) |
| Compute the least-squares solution to a real(dp) system of linear equations Ax = B, with a state return flag. | |
| pure real(xdp) function, dimension(:,:), allocatable | la_xlstsq_multiple (a, b, cond) |
Compute the least-squares solution to a real(xdp) system of linear equations Ax = B: pure, stops on error. | |
| real(xdp) function, dimension(:,:), allocatable, target | la_xlstsq_err_multiple (a, b, cond, overwrite_a, rank, err) |
| Compute the least-squares solution to a real(xdp) system of linear equations Ax = B, with a state return flag. | |
| pure real(qp) function, dimension(:,:), allocatable | la_qlstsq_multiple (a, b, cond) |
Compute the least-squares solution to a real(qp) system of linear equations Ax = B: pure, stops on error. | |
| real(qp) function, dimension(:,:), allocatable, target | la_qlstsq_err_multiple (a, b, cond, overwrite_a, rank, err) |
| Compute the least-squares solution to a real(qp) system of linear equations Ax = B, with a state return flag. | |
| pure complex(sp) function, dimension(:,:), allocatable | la_clstsq_multiple (a, b, cond) |
Compute the least-squares solution to a complex(sp) system of linear equations Ax = B: pure, stops on error. | |
| complex(sp) function, dimension(:,:), allocatable, target | la_clstsq_err_multiple (a, b, cond, overwrite_a, rank, err) |
| Compute the least-squares solution to a complex(sp) system of linear equations Ax = B, with a state return flag. | |
| pure complex(dp) function, dimension(:,:), allocatable | la_zlstsq_multiple (a, b, cond) |
Compute the least-squares solution to a complex(dp) system of linear equations Ax = B: pure, stops on error. | |
| complex(dp) function, dimension(:,:), allocatable, target | la_zlstsq_err_multiple (a, b, cond, overwrite_a, rank, err) |
| Compute the least-squares solution to a complex(dp) system of linear equations Ax = B, with a state return flag. | |
| pure complex(xdp) function, dimension(:,:), allocatable | la_ylstsq_multiple (a, b, cond) |
Compute the least-squares solution to a complex(xdp) system of linear equations Ax = B: pure, stops on error. | |
| complex(xdp) function, dimension(:,:), allocatable, target | la_ylstsq_err_multiple (a, b, cond, overwrite_a, rank, err) |
| Compute the least-squares solution to a complex(xdp) system of linear equations Ax = B, with a state return flag. | |
| pure complex(qp) function, dimension(:,:), allocatable | la_wlstsq_multiple (a, b, cond) |
Compute the least-squares solution to a complex(qp) system of linear equations Ax = B: pure, stops on error. | |
| complex(qp) function, dimension(:,:), allocatable, target | la_wlstsq_err_multiple (a, b, cond, overwrite_a, rank, err) |
| Compute the least-squares solution to a complex(qp) system of linear equations Ax = B, with a state return flag. | |
Compute a least squares solution to system \( A \cdot x = b \), i.e. such that the 2-norm \( \|b - A \cdot x\| \) is minimized.
This function computes the least-squares solution to a real system of linear equations:
\( A \cdot x = b \)
where A is an n x n matrix and b is either a vector (n) or a matrix (n x nrhs). The solution x is returned as an allocatable array.
Without err the function is pure, takes A as intent(in), and stops on error. With err it returns the error state instead, can overwrite A, and can return the rank.
| [in,out] | a | The input matrix of size n x n. If overwrite_a is true, the contents of A may be modified during computation. |
| [in] | b | The right-hand side vector (n) or matrix (n x nrhs). |
| [in] | cond | (Optional) A cutoff for rank evaluation: singular values \( s(i) \) such that \( s(i) \leq \text{cond} \cdot \max(s) \) are considered zero. |
| [in] | overwrite_a | (Optional, with err only) If true, A and B may be overwritten and destroyed. Default is false. |
| [out] | rank | (Optional, with err only) The rank of the matrix A. |
| [out] | err | (Optional) A state return flag. If an error occurs and err is not provided, the function will stop execution. |
x of size n (for a single right-hand side) or n x nrhs; with err, an empty array if the problem is invalid.[*GELSS](@ref la_lapack::gelss).overwrite_a is enabled, the original contents of A and B may be lost.Compute the working space needed by a least squares solution of \( A \cdot x = b \).
This subroutine returns the sizes of the real, integer and (for complex data) complex working arrays that solve_lstsq needs for the given problem, so that a repeated solve of problems of the same size performs no allocation.
| [in] | a | The input matrix of size \( [m,n] \). Only its shape is used. |
| [in] | b | The right-hand side vector ( \(m\)) or matrix ( \(m \times nrhs\)). Only its shape is used. |
| [out] | lrwork | The size of the real working array. |
| [out] | liwork | The size of the integer working array. |
| [out] | lcwork | The size of the complex working array. Present for complex data only. |
Compute a least squares solution of \( A \cdot x = b \) into a pre-allocated array.
This subroutine computes the least-squares solution of a linear matrix problem and writes it into the caller's array, so that neither the solution nor the working space needs to be allocated internally.
| [in,out] | a | The input matrix of size \( [m,n] \). If overwrite_a is true, the contents of a may be modified during computation. |
| [in] | b | The right-hand side vector ( \(m\)) or matrix ( \(m \times nrhs\)). |
| [in,out] | x | The solution vector ( \(\ge n\)) or matrix ( \(\ge n \times nrhs\)). |
| [in,out] | real_storage | (Optional) Pre-allocated real working space. Its size is checked with lstsq_space. |
| [in,out] | int_storage | (Optional) Pre-allocated integer working space. |
| [in,out] | cmpl_storage | (Optional) Pre-allocated complex working space. Complex data only. |
| [in] | cond | (Optional) A cutoff for rank evaluation: singular values \( s(i) \) such that \( s(i) \leq \text{cond} \cdot \max(s) \) are considered zero. |
| [out] | singvals | (Optional) The \( \min(m,n) \) singular values, in decreasing order. |
| [in] | overwrite_a | (Optional) If true, a may be overwritten and destroyed. Default is false. |
| [out] | rank | (Optional) The rank of the matrix a. |
| [out] | err | (Optional) A state return flag. If an error occurs and err is not provided, the function will stop execution. |
Compute a weighted least squares solution of \( A \cdot x = b \).
This function minimizes \( \|D (b - A \cdot x)\| \) with \( D = \mathrm{diag}(\sqrt{w}) \), that is, it gives the \(i\)-th equation the weight \( w_i \).
Without err the function is pure, takes a as intent(in), and stops on error. With err it returns the error state instead, can overwrite a, and can return the rank.
| [in] | w | The weight vector of size \(m\). It is always real, and every entry must be positive. |
| [in,out] | a | The input matrix of size \( [m,n] \). If overwrite_a is true, the contents of a may be modified during computation. |
| [in] | b | The right-hand side vector of size \(m\). |
| [in] | cond | (Optional) A cutoff for rank evaluation. |
| [in] | overwrite_a | (Optional, with err only) If true, a may be overwritten and destroyed. Default is false. |
| [out] | rank | (Optional, with err only) The rank of the matrix a. |
| [out] | err | (Optional) A state return flag. If an error occurs and err is not provided, the function will stop execution. |
x of size \(n\).Compute a weighted least squares solution into a pre-allocated array.
This subroutine is the subroutine form of weighted_lstsq: it writes the solution into the caller's array.
| [in] | w | The weight vector of size \(m\). It is always real, and every entry must be positive. |
| [in,out] | a | The input matrix of size \( [m,n] \). If overwrite_a is true, the contents of a may be modified during computation. |
| [in] | b | The right-hand side vector of size \(m\). |
| [in,out] | x | The solution vector of size \(n\). |
| [in] | cond | (Optional) A cutoff for rank evaluation. |
| [in] | overwrite_a | (Optional) If true, a may be overwritten and destroyed. Default is false. |
| [out] | rank | (Optional) The rank of the matrix a. |
| [out] | err | (Optional) A state return flag. If an error occurs and err is not provided, the function will stop execution. |
Compute the solution of an equality-constrained least squares problem.
This function minimizes \( \|b - A \cdot x\| \) subject to \( C \cdot x = d \), with \( A \) of size \( [m,n] \) and \( C \) of size \( [p,n] \), \( p \le n \le m+p \).
Without err the function is pure, takes A, b, C and d as intent(in), and stops on error. With err it returns the error state instead, and can overwrite them.
| [in,out] | A | The least-squares matrix of size \( [m,n] \). |
| [in,out] | b | The least-squares right-hand side vector of size \(m\). |
| [in,out] | C | The constraint matrix of size \( [p,n] \). |
| [in,out] | d | The constraint right-hand side vector of size \(p\). |
| [in] | overwrite_matrices | (Optional, with err only) If true, A, b, C and d may be overwritten and destroyed. Default is false. |
| [out] | err | (Optional) A state return flag. If an error occurs and err is not provided, the function will stop execution. |
x of size \(n\).Compute the solution of an equality-constrained least squares problem into a pre-allocated array.
This subroutine is the subroutine form of constrained_lstsq: it writes the solution into the caller's array and can reuse a caller-provided workspace.
| [in,out] | A | The least-squares matrix of size \( [m,n] \). |
| [in,out] | b | The least-squares right-hand side vector of size \(m\). |
| [in,out] | C | The constraint matrix of size \( [p,n] \). |
| [in,out] | d | The constraint right-hand side vector of size \(p\). |
| [out] | x | The solution vector of size \(n\). |
| [out] | storage | (Optional) Pre-allocated workspace. Its size is checked with constrained_lstsq_space. |
| [in] | overwrite_matrices | (Optional) If true, A, b, C and d may be overwritten and destroyed. Default is false. |
| [out] | err | (Optional) A state return flag. If an error occurs and err is not provided, the function will stop execution. |
Compute the working space needed by the equality-constrained least squares solver.
This subroutine queries LAPACK for the optimal size of the workspace array that solve_constrained_lstsq needs.
| [in] | A | The least-squares matrix of size \( [m,n] \). Only its shape is used. |
| [in] | C | The constraint matrix of size \( [p,n] \). Only its shape is used. |
| [out] | lwork | The size of the workspace array. |
| [out] | err | (Optional) A state return flag. If an error occurs and err is not provided, the function will stop execution. |
Compute a generalized least squares solution of \( A \cdot x = b \).
This function minimizes \( (b - A \cdot x)^H W^{-1} (b - A \cdot x) \), the least-squares cost of observations whose errors are correlated, with the symmetric (Hermitian) positive definite covariance matrix \( W \).
| [in] | w | The covariance matrix of size \( [m,m] \), or a square root \( B \) of it, \( W = B B^H \), if prefactored_w is true. |
| [in] | a | The input matrix of size \( [m,n] \), with \( m \ge n \). |
| [in] | b | The right-hand side vector of size \(m\). |
| [in] | prefactored_w | (Optional) If true, w is a square root of the covariance matrix, for example its Cholesky factor. Default is false. |
| [out] | err | (Optional) A state return flag. Without it the function is pure, and an error stops execution. |
x of size \(n\).err is pure; the form with err is not, because a pure function cannot return an error argument.Compute a generalized least squares solution into a pre-allocated array.
This subroutine is the subroutine form of generalized_lstsq: it writes the solution into the caller's array, can reuse a caller-provided workspace, and can work on w and a in place.
| [in,out] | w | The covariance matrix of size \( [m,m] \), or a square root of it if prefactored_w is true. Unchanged unless overwrite_w is true. |
| [in,out] | a | The input matrix of size \( [m,n] \), with \( m \ge n \). Unchanged unless overwrite_a is true. |
| [in] | b | The right-hand side vector of size \(m\). |
| [out] | x | The solution vector of size \(n\). |
| [in,out] | storage | (Optional) Pre-allocated workspace. Its size is checked with generalized_lstsq_space. |
| [in] | prefactored_w | (Optional) If true, w is a square root of the covariance matrix. Default is false. |
| [in] | overwrite_a | (Optional) If true, a may be overwritten and destroyed. Default is false. |
| [in] | overwrite_w | (Optional) If true, w may be overwritten and destroyed. Default is false. |
| [out] | err | (Optional) A state return flag. If an error occurs and err is not provided, the subroutine will stop execution. |
storage, overwrite_a and overwrite_w it allocates nothing.Compute the working space needed by the generalized least squares solver.
This subroutine returns the size of the workspace array that solve_generalized_lstsq needs: the optimal workspace of LAPACK's GGGLM, plus two vectors of size \(m\).
| [in] | a | The input matrix of size \( [m,n] \). Only its shape is used. |
| [out] | lwork | The size of the workspace array. |
| [out] | err | (Optional) A state return flag. If an error occurs and err is not provided, the subroutine will stop execution. |
| complex(sp) function, dimension(:,:), allocatable, target la_least_squares::lstsq::la_clstsq_err_multiple | ( | complex(sp), dimension(:,:), intent(inout), target | a, |
| complex(sp), dimension(:,:), intent(in) | b, | ||
| real(sp), intent(in), optional | cond, | ||
| logical(lk), intent(in), optional | overwrite_a, | ||
| integer(ilp), intent(out), optional | rank, | ||
| type(la_state), intent(out) | err ) |
Compute the least-squares solution to a complex(sp) system of linear equations Ax = B, with a state return flag.
| [in,out] | a | Input matrix a[n,n] |
| [in] | b | Right hand side vector or array, b[n] or b[n,nrhs] |
| [in] | cond | [optional] cutoff for rank evaluation: singular values s(i)<=cond*maxval(s) are considered 0. |
| [in] | overwrite_a | [optional] Can A,b data be overwritten and destroyed? |
| [out] | rank | [optional] Return rank of A |
| [out] | err | State return flag |
| complex(sp) function, dimension(:), allocatable, target la_least_squares::lstsq::la_clstsq_err_one | ( | complex(sp), dimension(:,:), intent(inout), target | a, |
| complex(sp), dimension(:), intent(in) | b, | ||
| real(sp), intent(in), optional | cond, | ||
| logical(lk), intent(in), optional | overwrite_a, | ||
| integer(ilp), intent(out), optional | rank, | ||
| type(la_state), intent(out) | err ) |
Compute the least-squares solution to a complex(sp) system of linear equations Ax = B, with a state return flag.
| [in,out] | a | Input matrix a[n,n] |
| [in] | b | Right hand side vector or array, b[n] or b[n,nrhs] |
| [in] | cond | [optional] cutoff for rank evaluation: singular values s(i)<=cond*maxval(s) are considered 0. |
| [in] | overwrite_a | [optional] Can A,b data be overwritten and destroyed? |
| [out] | rank | [optional] Return rank of A |
| [out] | err | State return flag |
| pure complex(sp) function, dimension(:,:), allocatable la_least_squares::lstsq::la_clstsq_multiple | ( | complex(sp), dimension(:,:), intent(in) | a, |
| complex(sp), dimension(:,:), intent(in) | b, | ||
| real(sp), intent(in), optional | cond ) |
Compute the least-squares solution to a complex(sp) system of linear equations Ax = B: pure, stops on error.
| [in] | a | Input matrix a[n,n] |
| [in] | b | Right hand side vector or array, b[n] or b[n,nrhs] |
| [in] | cond | [optional] cutoff for rank evaluation: singular values s(i)<=cond*maxval(s) are considered 0. |
| pure complex(sp) function, dimension(:), allocatable la_least_squares::lstsq::la_clstsq_one | ( | complex(sp), dimension(:,:), intent(in) | a, |
| complex(sp), dimension(:), intent(in) | b, | ||
| real(sp), intent(in), optional | cond ) |
Compute the least-squares solution to a complex(sp) system of linear equations Ax = B: pure, stops on error.
| [in] | a | Input matrix a[n,n] |
| [in] | b | Right hand side vector or array, b[n] or b[n,nrhs] |
| [in] | cond | [optional] cutoff for rank evaluation: singular values s(i)<=cond*maxval(s) are considered 0. |
| real(dp) function, dimension(:,:), allocatable, target la_least_squares::lstsq::la_dlstsq_err_multiple | ( | real(dp), dimension(:,:), intent(inout), target | a, |
| real(dp), dimension(:,:), intent(in) | b, | ||
| real(dp), intent(in), optional | cond, | ||
| logical(lk), intent(in), optional | overwrite_a, | ||
| integer(ilp), intent(out), optional | rank, | ||
| type(la_state), intent(out) | err ) |
Compute the least-squares solution to a real(dp) system of linear equations Ax = B, with a state return flag.
| [in,out] | a | Input matrix a[n,n] |
| [in] | b | Right hand side vector or array, b[n] or b[n,nrhs] |
| [in] | cond | [optional] cutoff for rank evaluation: singular values s(i)<=cond*maxval(s) are considered 0. |
| [in] | overwrite_a | [optional] Can A,b data be overwritten and destroyed? |
| [out] | rank | [optional] Return rank of A |
| [out] | err | State return flag |
| real(dp) function, dimension(:), allocatable, target la_least_squares::lstsq::la_dlstsq_err_one | ( | real(dp), dimension(:,:), intent(inout), target | a, |
| real(dp), dimension(:), intent(in) | b, | ||
| real(dp), intent(in), optional | cond, | ||
| logical(lk), intent(in), optional | overwrite_a, | ||
| integer(ilp), intent(out), optional | rank, | ||
| type(la_state), intent(out) | err ) |
Compute the least-squares solution to a real(dp) system of linear equations Ax = B, with a state return flag.
| [in,out] | a | Input matrix a[n,n] |
| [in] | b | Right hand side vector or array, b[n] or b[n,nrhs] |
| [in] | cond | [optional] cutoff for rank evaluation: singular values s(i)<=cond*maxval(s) are considered 0. |
| [in] | overwrite_a | [optional] Can A,b data be overwritten and destroyed? |
| [out] | rank | [optional] Return rank of A |
| [out] | err | State return flag |
| pure real(dp) function, dimension(:,:), allocatable la_least_squares::lstsq::la_dlstsq_multiple | ( | real(dp), dimension(:,:), intent(in) | a, |
| real(dp), dimension(:,:), intent(in) | b, | ||
| real(dp), intent(in), optional | cond ) |
Compute the least-squares solution to a real(dp) system of linear equations Ax = B: pure, stops on error.
| [in] | a | Input matrix a[n,n] |
| [in] | b | Right hand side vector or array, b[n] or b[n,nrhs] |
| [in] | cond | [optional] cutoff for rank evaluation: singular values s(i)<=cond*maxval(s) are considered 0. |
| pure real(dp) function, dimension(:), allocatable la_least_squares::lstsq::la_dlstsq_one | ( | real(dp), dimension(:,:), intent(in) | a, |
| real(dp), dimension(:), intent(in) | b, | ||
| real(dp), intent(in), optional | cond ) |
Compute the least-squares solution to a real(dp) system of linear equations Ax = B: pure, stops on error.
| [in] | a | Input matrix a[n,n] |
| [in] | b | Right hand side vector or array, b[n] or b[n,nrhs] |
| [in] | cond | [optional] cutoff for rank evaluation: singular values s(i)<=cond*maxval(s) are considered 0. |
| real(qp) function, dimension(:,:), allocatable, target la_least_squares::lstsq::la_qlstsq_err_multiple | ( | real(qp), dimension(:,:), intent(inout), target | a, |
| real(qp), dimension(:,:), intent(in) | b, | ||
| real(qp), intent(in), optional | cond, | ||
| logical(lk), intent(in), optional | overwrite_a, | ||
| integer(ilp), intent(out), optional | rank, | ||
| type(la_state), intent(out) | err ) |
Compute the least-squares solution to a real(qp) system of linear equations Ax = B, with a state return flag.
| [in,out] | a | Input matrix a[n,n] |
| [in] | b | Right hand side vector or array, b[n] or b[n,nrhs] |
| [in] | cond | [optional] cutoff for rank evaluation: singular values s(i)<=cond*maxval(s) are considered 0. |
| [in] | overwrite_a | [optional] Can A,b data be overwritten and destroyed? |
| [out] | rank | [optional] Return rank of A |
| [out] | err | State return flag |
| real(qp) function, dimension(:), allocatable, target la_least_squares::lstsq::la_qlstsq_err_one | ( | real(qp), dimension(:,:), intent(inout), target | a, |
| real(qp), dimension(:), intent(in) | b, | ||
| real(qp), intent(in), optional | cond, | ||
| logical(lk), intent(in), optional | overwrite_a, | ||
| integer(ilp), intent(out), optional | rank, | ||
| type(la_state), intent(out) | err ) |
Compute the least-squares solution to a real(qp) system of linear equations Ax = B, with a state return flag.
| [in,out] | a | Input matrix a[n,n] |
| [in] | b | Right hand side vector or array, b[n] or b[n,nrhs] |
| [in] | cond | [optional] cutoff for rank evaluation: singular values s(i)<=cond*maxval(s) are considered 0. |
| [in] | overwrite_a | [optional] Can A,b data be overwritten and destroyed? |
| [out] | rank | [optional] Return rank of A |
| [out] | err | State return flag |
| pure real(qp) function, dimension(:,:), allocatable la_least_squares::lstsq::la_qlstsq_multiple | ( | real(qp), dimension(:,:), intent(in) | a, |
| real(qp), dimension(:,:), intent(in) | b, | ||
| real(qp), intent(in), optional | cond ) |
Compute the least-squares solution to a real(qp) system of linear equations Ax = B: pure, stops on error.
| [in] | a | Input matrix a[n,n] |
| [in] | b | Right hand side vector or array, b[n] or b[n,nrhs] |
| [in] | cond | [optional] cutoff for rank evaluation: singular values s(i)<=cond*maxval(s) are considered 0. |
| pure real(qp) function, dimension(:), allocatable la_least_squares::lstsq::la_qlstsq_one | ( | real(qp), dimension(:,:), intent(in) | a, |
| real(qp), dimension(:), intent(in) | b, | ||
| real(qp), intent(in), optional | cond ) |
Compute the least-squares solution to a real(qp) system of linear equations Ax = B: pure, stops on error.
| [in] | a | Input matrix a[n,n] |
| [in] | b | Right hand side vector or array, b[n] or b[n,nrhs] |
| [in] | cond | [optional] cutoff for rank evaluation: singular values s(i)<=cond*maxval(s) are considered 0. |
| real(sp) function, dimension(:,:), allocatable, target la_least_squares::lstsq::la_slstsq_err_multiple | ( | real(sp), dimension(:,:), intent(inout), target | a, |
| real(sp), dimension(:,:), intent(in) | b, | ||
| real(sp), intent(in), optional | cond, | ||
| logical(lk), intent(in), optional | overwrite_a, | ||
| integer(ilp), intent(out), optional | rank, | ||
| type(la_state), intent(out) | err ) |
Compute the least-squares solution to a real(sp) system of linear equations Ax = B, with a state return flag.
| [in,out] | a | Input matrix a[n,n] |
| [in] | b | Right hand side vector or array, b[n] or b[n,nrhs] |
| [in] | cond | [optional] cutoff for rank evaluation: singular values s(i)<=cond*maxval(s) are considered 0. |
| [in] | overwrite_a | [optional] Can A,b data be overwritten and destroyed? |
| [out] | rank | [optional] Return rank of A |
| [out] | err | State return flag |
| real(sp) function, dimension(:), allocatable, target la_least_squares::lstsq::la_slstsq_err_one | ( | real(sp), dimension(:,:), intent(inout), target | a, |
| real(sp), dimension(:), intent(in) | b, | ||
| real(sp), intent(in), optional | cond, | ||
| logical(lk), intent(in), optional | overwrite_a, | ||
| integer(ilp), intent(out), optional | rank, | ||
| type(la_state), intent(out) | err ) |
Compute the least-squares solution to a real(sp) system of linear equations Ax = B, with a state return flag.
| [in,out] | a | Input matrix a[n,n] |
| [in] | b | Right hand side vector or array, b[n] or b[n,nrhs] |
| [in] | cond | [optional] cutoff for rank evaluation: singular values s(i)<=cond*maxval(s) are considered 0. |
| [in] | overwrite_a | [optional] Can A,b data be overwritten and destroyed? |
| [out] | rank | [optional] Return rank of A |
| [out] | err | State return flag |
| pure real(sp) function, dimension(:,:), allocatable la_least_squares::lstsq::la_slstsq_multiple | ( | real(sp), dimension(:,:), intent(in) | a, |
| real(sp), dimension(:,:), intent(in) | b, | ||
| real(sp), intent(in), optional | cond ) |
Compute the least-squares solution to a real(sp) system of linear equations Ax = B: pure, stops on error.
| [in] | a | Input matrix a[n,n] |
| [in] | b | Right hand side vector or array, b[n] or b[n,nrhs] |
| [in] | cond | [optional] cutoff for rank evaluation: singular values s(i)<=cond*maxval(s) are considered 0. |
| pure real(sp) function, dimension(:), allocatable la_least_squares::lstsq::la_slstsq_one | ( | real(sp), dimension(:,:), intent(in) | a, |
| real(sp), dimension(:), intent(in) | b, | ||
| real(sp), intent(in), optional | cond ) |
Compute the least-squares solution to a real(sp) system of linear equations Ax = B: pure, stops on error.
| [in] | a | Input matrix a[n,n] |
| [in] | b | Right hand side vector or array, b[n] or b[n,nrhs] |
| [in] | cond | [optional] cutoff for rank evaluation: singular values s(i)<=cond*maxval(s) are considered 0. |
| complex(qp) function, dimension(:,:), allocatable, target la_least_squares::lstsq::la_wlstsq_err_multiple | ( | complex(qp), dimension(:,:), intent(inout), target | a, |
| complex(qp), dimension(:,:), intent(in) | b, | ||
| real(qp), intent(in), optional | cond, | ||
| logical(lk), intent(in), optional | overwrite_a, | ||
| integer(ilp), intent(out), optional | rank, | ||
| type(la_state), intent(out) | err ) |
Compute the least-squares solution to a complex(qp) system of linear equations Ax = B, with a state return flag.
| [in,out] | a | Input matrix a[n,n] |
| [in] | b | Right hand side vector or array, b[n] or b[n,nrhs] |
| [in] | cond | [optional] cutoff for rank evaluation: singular values s(i)<=cond*maxval(s) are considered 0. |
| [in] | overwrite_a | [optional] Can A,b data be overwritten and destroyed? |
| [out] | rank | [optional] Return rank of A |
| [out] | err | State return flag |
| complex(qp) function, dimension(:), allocatable, target la_least_squares::lstsq::la_wlstsq_err_one | ( | complex(qp), dimension(:,:), intent(inout), target | a, |
| complex(qp), dimension(:), intent(in) | b, | ||
| real(qp), intent(in), optional | cond, | ||
| logical(lk), intent(in), optional | overwrite_a, | ||
| integer(ilp), intent(out), optional | rank, | ||
| type(la_state), intent(out) | err ) |
Compute the least-squares solution to a complex(qp) system of linear equations Ax = B, with a state return flag.
| [in,out] | a | Input matrix a[n,n] |
| [in] | b | Right hand side vector or array, b[n] or b[n,nrhs] |
| [in] | cond | [optional] cutoff for rank evaluation: singular values s(i)<=cond*maxval(s) are considered 0. |
| [in] | overwrite_a | [optional] Can A,b data be overwritten and destroyed? |
| [out] | rank | [optional] Return rank of A |
| [out] | err | State return flag |
| pure complex(qp) function, dimension(:,:), allocatable la_least_squares::lstsq::la_wlstsq_multiple | ( | complex(qp), dimension(:,:), intent(in) | a, |
| complex(qp), dimension(:,:), intent(in) | b, | ||
| real(qp), intent(in), optional | cond ) |
Compute the least-squares solution to a complex(qp) system of linear equations Ax = B: pure, stops on error.
| [in] | a | Input matrix a[n,n] |
| [in] | b | Right hand side vector or array, b[n] or b[n,nrhs] |
| [in] | cond | [optional] cutoff for rank evaluation: singular values s(i)<=cond*maxval(s) are considered 0. |
| pure complex(qp) function, dimension(:), allocatable la_least_squares::lstsq::la_wlstsq_one | ( | complex(qp), dimension(:,:), intent(in) | a, |
| complex(qp), dimension(:), intent(in) | b, | ||
| real(qp), intent(in), optional | cond ) |
Compute the least-squares solution to a complex(qp) system of linear equations Ax = B: pure, stops on error.
| [in] | a | Input matrix a[n,n] |
| [in] | b | Right hand side vector or array, b[n] or b[n,nrhs] |
| [in] | cond | [optional] cutoff for rank evaluation: singular values s(i)<=cond*maxval(s) are considered 0. |
| real(xdp) function, dimension(:,:), allocatable, target la_least_squares::lstsq::la_xlstsq_err_multiple | ( | real(xdp), dimension(:,:), intent(inout), target | a, |
| real(xdp), dimension(:,:), intent(in) | b, | ||
| real(xdp), intent(in), optional | cond, | ||
| logical(lk), intent(in), optional | overwrite_a, | ||
| integer(ilp), intent(out), optional | rank, | ||
| type(la_state), intent(out) | err ) |
Compute the least-squares solution to a real(xdp) system of linear equations Ax = B, with a state return flag.
| [in,out] | a | Input matrix a[n,n] |
| [in] | b | Right hand side vector or array, b[n] or b[n,nrhs] |
| [in] | cond | [optional] cutoff for rank evaluation: singular values s(i)<=cond*maxval(s) are considered 0. |
| [in] | overwrite_a | [optional] Can A,b data be overwritten and destroyed? |
| [out] | rank | [optional] Return rank of A |
| [out] | err | State return flag |
| real(xdp) function, dimension(:), allocatable, target la_least_squares::lstsq::la_xlstsq_err_one | ( | real(xdp), dimension(:,:), intent(inout), target | a, |
| real(xdp), dimension(:), intent(in) | b, | ||
| real(xdp), intent(in), optional | cond, | ||
| logical(lk), intent(in), optional | overwrite_a, | ||
| integer(ilp), intent(out), optional | rank, | ||
| type(la_state), intent(out) | err ) |
Compute the least-squares solution to a real(xdp) system of linear equations Ax = B, with a state return flag.
| [in,out] | a | Input matrix a[n,n] |
| [in] | b | Right hand side vector or array, b[n] or b[n,nrhs] |
| [in] | cond | [optional] cutoff for rank evaluation: singular values s(i)<=cond*maxval(s) are considered 0. |
| [in] | overwrite_a | [optional] Can A,b data be overwritten and destroyed? |
| [out] | rank | [optional] Return rank of A |
| [out] | err | State return flag |
| pure real(xdp) function, dimension(:,:), allocatable la_least_squares::lstsq::la_xlstsq_multiple | ( | real(xdp), dimension(:,:), intent(in) | a, |
| real(xdp), dimension(:,:), intent(in) | b, | ||
| real(xdp), intent(in), optional | cond ) |
Compute the least-squares solution to a real(xdp) system of linear equations Ax = B: pure, stops on error.
| [in] | a | Input matrix a[n,n] |
| [in] | b | Right hand side vector or array, b[n] or b[n,nrhs] |
| [in] | cond | [optional] cutoff for rank evaluation: singular values s(i)<=cond*maxval(s) are considered 0. |
| pure real(xdp) function, dimension(:), allocatable la_least_squares::lstsq::la_xlstsq_one | ( | real(xdp), dimension(:,:), intent(in) | a, |
| real(xdp), dimension(:), intent(in) | b, | ||
| real(xdp), intent(in), optional | cond ) |
Compute the least-squares solution to a real(xdp) system of linear equations Ax = B: pure, stops on error.
| [in] | a | Input matrix a[n,n] |
| [in] | b | Right hand side vector or array, b[n] or b[n,nrhs] |
| [in] | cond | [optional] cutoff for rank evaluation: singular values s(i)<=cond*maxval(s) are considered 0. |
| complex(xdp) function, dimension(:,:), allocatable, target la_least_squares::lstsq::la_ylstsq_err_multiple | ( | complex(xdp), dimension(:,:), intent(inout), target | a, |
| complex(xdp), dimension(:,:), intent(in) | b, | ||
| real(xdp), intent(in), optional | cond, | ||
| logical(lk), intent(in), optional | overwrite_a, | ||
| integer(ilp), intent(out), optional | rank, | ||
| type(la_state), intent(out) | err ) |
Compute the least-squares solution to a complex(xdp) system of linear equations Ax = B, with a state return flag.
| [in,out] | a | Input matrix a[n,n] |
| [in] | b | Right hand side vector or array, b[n] or b[n,nrhs] |
| [in] | cond | [optional] cutoff for rank evaluation: singular values s(i)<=cond*maxval(s) are considered 0. |
| [in] | overwrite_a | [optional] Can A,b data be overwritten and destroyed? |
| [out] | rank | [optional] Return rank of A |
| [out] | err | State return flag |
| complex(xdp) function, dimension(:), allocatable, target la_least_squares::lstsq::la_ylstsq_err_one | ( | complex(xdp), dimension(:,:), intent(inout), target | a, |
| complex(xdp), dimension(:), intent(in) | b, | ||
| real(xdp), intent(in), optional | cond, | ||
| logical(lk), intent(in), optional | overwrite_a, | ||
| integer(ilp), intent(out), optional | rank, | ||
| type(la_state), intent(out) | err ) |
Compute the least-squares solution to a complex(xdp) system of linear equations Ax = B, with a state return flag.
| [in,out] | a | Input matrix a[n,n] |
| [in] | b | Right hand side vector or array, b[n] or b[n,nrhs] |
| [in] | cond | [optional] cutoff for rank evaluation: singular values s(i)<=cond*maxval(s) are considered 0. |
| [in] | overwrite_a | [optional] Can A,b data be overwritten and destroyed? |
| [out] | rank | [optional] Return rank of A |
| [out] | err | State return flag |
| pure complex(xdp) function, dimension(:,:), allocatable la_least_squares::lstsq::la_ylstsq_multiple | ( | complex(xdp), dimension(:,:), intent(in) | a, |
| complex(xdp), dimension(:,:), intent(in) | b, | ||
| real(xdp), intent(in), optional | cond ) |
Compute the least-squares solution to a complex(xdp) system of linear equations Ax = B: pure, stops on error.
| [in] | a | Input matrix a[n,n] |
| [in] | b | Right hand side vector or array, b[n] or b[n,nrhs] |
| [in] | cond | [optional] cutoff for rank evaluation: singular values s(i)<=cond*maxval(s) are considered 0. |
| pure complex(xdp) function, dimension(:), allocatable la_least_squares::lstsq::la_ylstsq_one | ( | complex(xdp), dimension(:,:), intent(in) | a, |
| complex(xdp), dimension(:), intent(in) | b, | ||
| real(xdp), intent(in), optional | cond ) |
Compute the least-squares solution to a complex(xdp) system of linear equations Ax = B: pure, stops on error.
| [in] | a | Input matrix a[n,n] |
| [in] | b | Right hand side vector or array, b[n] or b[n,nrhs] |
| [in] | cond | [optional] cutoff for rank evaluation: singular values s(i)<=cond*maxval(s) are considered 0. |
| complex(dp) function, dimension(:,:), allocatable, target la_least_squares::lstsq::la_zlstsq_err_multiple | ( | complex(dp), dimension(:,:), intent(inout), target | a, |
| complex(dp), dimension(:,:), intent(in) | b, | ||
| real(dp), intent(in), optional | cond, | ||
| logical(lk), intent(in), optional | overwrite_a, | ||
| integer(ilp), intent(out), optional | rank, | ||
| type(la_state), intent(out) | err ) |
Compute the least-squares solution to a complex(dp) system of linear equations Ax = B, with a state return flag.
| [in,out] | a | Input matrix a[n,n] |
| [in] | b | Right hand side vector or array, b[n] or b[n,nrhs] |
| [in] | cond | [optional] cutoff for rank evaluation: singular values s(i)<=cond*maxval(s) are considered 0. |
| [in] | overwrite_a | [optional] Can A,b data be overwritten and destroyed? |
| [out] | rank | [optional] Return rank of A |
| [out] | err | State return flag |
| complex(dp) function, dimension(:), allocatable, target la_least_squares::lstsq::la_zlstsq_err_one | ( | complex(dp), dimension(:,:), intent(inout), target | a, |
| complex(dp), dimension(:), intent(in) | b, | ||
| real(dp), intent(in), optional | cond, | ||
| logical(lk), intent(in), optional | overwrite_a, | ||
| integer(ilp), intent(out), optional | rank, | ||
| type(la_state), intent(out) | err ) |
Compute the least-squares solution to a complex(dp) system of linear equations Ax = B, with a state return flag.
| [in,out] | a | Input matrix a[n,n] |
| [in] | b | Right hand side vector or array, b[n] or b[n,nrhs] |
| [in] | cond | [optional] cutoff for rank evaluation: singular values s(i)<=cond*maxval(s) are considered 0. |
| [in] | overwrite_a | [optional] Can A,b data be overwritten and destroyed? |
| [out] | rank | [optional] Return rank of A |
| [out] | err | State return flag |
| pure complex(dp) function, dimension(:,:), allocatable la_least_squares::lstsq::la_zlstsq_multiple | ( | complex(dp), dimension(:,:), intent(in) | a, |
| complex(dp), dimension(:,:), intent(in) | b, | ||
| real(dp), intent(in), optional | cond ) |
Compute the least-squares solution to a complex(dp) system of linear equations Ax = B: pure, stops on error.
| [in] | a | Input matrix a[n,n] |
| [in] | b | Right hand side vector or array, b[n] or b[n,nrhs] |
| [in] | cond | [optional] cutoff for rank evaluation: singular values s(i)<=cond*maxval(s) are considered 0. |
| pure complex(dp) function, dimension(:), allocatable la_least_squares::lstsq::la_zlstsq_one | ( | complex(dp), dimension(:,:), intent(in) | a, |
| complex(dp), dimension(:), intent(in) | b, | ||
| real(dp), intent(in), optional | cond ) |
Compute the least-squares solution to a complex(dp) system of linear equations Ax = B: pure, stops on error.
| [in] | a | Input matrix a[n,n] |
| [in] | b | Right hand side vector or array, b[n] or b[n,nrhs] |
| [in] | cond | [optional] cutoff for rank evaluation: singular values s(i)<=cond*maxval(s) are considered 0. |