fortran-lapack
Loading...
Searching...
No Matches
la_least_squares::solve_generalized_lstsq Interface Reference

Public Member Functions

pure subroutine la_ssolve_generalized_lstsq (w, a, b, x, storage, prefactored_w, overwrite_a, overwrite_w, err)
 Solve the real(sp) generalized least-squares problem into x: minimize (b-Ax)^H W^{-1} (b-Ax)
 
pure subroutine la_dsolve_generalized_lstsq (w, a, b, x, storage, prefactored_w, overwrite_a, overwrite_w, err)
 Solve the real(dp) generalized least-squares problem into x: minimize (b-Ax)^H W^{-1} (b-Ax)
 
pure subroutine la_xsolve_generalized_lstsq (w, a, b, x, storage, prefactored_w, overwrite_a, overwrite_w, err)
 Solve the real(xdp) generalized least-squares problem into x: minimize (b-Ax)^H W^{-1} (b-Ax)
 
pure subroutine la_qsolve_generalized_lstsq (w, a, b, x, storage, prefactored_w, overwrite_a, overwrite_w, err)
 Solve the real(qp) generalized least-squares problem into x: minimize (b-Ax)^H W^{-1} (b-Ax)
 
pure subroutine la_csolve_generalized_lstsq (w, a, b, x, storage, prefactored_w, overwrite_a, overwrite_w, err)
 Solve the complex(sp) generalized least-squares problem into x: minimize (b-Ax)^H W^{-1} (b-Ax)
 
pure subroutine la_zsolve_generalized_lstsq (w, a, b, x, storage, prefactored_w, overwrite_a, overwrite_w, err)
 Solve the complex(dp) generalized least-squares problem into x: minimize (b-Ax)^H W^{-1} (b-Ax)
 
pure subroutine la_ysolve_generalized_lstsq (w, a, b, x, storage, prefactored_w, overwrite_a, overwrite_w, err)
 Solve the complex(xdp) generalized least-squares problem into x: minimize (b-Ax)^H W^{-1} (b-Ax)
 
pure subroutine la_wsolve_generalized_lstsq (w, a, b, x, storage, prefactored_w, overwrite_a, overwrite_w, err)
 Solve the complex(qp) generalized least-squares problem into x: minimize (b-Ax)^H W^{-1} (b-Ax)
 

Member Function/Subroutine Documentation

◆ la_csolve_generalized_lstsq()

pure subroutine la_least_squares::solve_generalized_lstsq::la_csolve_generalized_lstsq ( complex(sp), dimension(:,:), intent(inout), target w,
complex(sp), dimension(:,:), intent(inout), target a,
complex(sp), dimension(:), intent(in) b,
complex(sp), dimension(:), intent(out) x,
complex(sp), dimension(:), intent(inout), optional, target, contiguous storage,
logical(lk), intent(in), optional prefactored_w,
logical(lk), intent(in), optional overwrite_a,
logical(lk), intent(in), optional overwrite_w,
type(la_state), intent(out), optional err )

Solve the complex(sp) generalized least-squares problem into x: minimize (b-Ax)^H W^{-1} (b-Ax)

Parameters
[in,out]wCovariance matrix w[m,m], or its square root if prefactored_w
[in,out]aInput matrix a[m,n]
[in]bRight hand side vector b[m]
[out]xSolution vector x[n]
[in,out]storage[optional] working storage space
[in]prefactored_w[optional] Is w a square root of the covariance matrix?
[in]overwrite_a[optional] Can A data be overwritten and destroyed?
[in]overwrite_w[optional] Can W data be overwritten and destroyed?
[out]err[optional] state return flag. On error if not requested, the code will stop
Here is the call graph for this function:

◆ la_dsolve_generalized_lstsq()

pure subroutine la_least_squares::solve_generalized_lstsq::la_dsolve_generalized_lstsq ( real(dp), dimension(:,:), intent(inout), target w,
real(dp), dimension(:,:), intent(inout), target a,
real(dp), dimension(:), intent(in) b,
real(dp), dimension(:), intent(out) x,
real(dp), dimension(:), intent(inout), optional, target, contiguous storage,
logical(lk), intent(in), optional prefactored_w,
logical(lk), intent(in), optional overwrite_a,
logical(lk), intent(in), optional overwrite_w,
type(la_state), intent(out), optional err )

Solve the real(dp) generalized least-squares problem into x: minimize (b-Ax)^H W^{-1} (b-Ax)

Parameters
[in,out]wCovariance matrix w[m,m], or its square root if prefactored_w
[in,out]aInput matrix a[m,n]
[in]bRight hand side vector b[m]
[out]xSolution vector x[n]
[in,out]storage[optional] working storage space
[in]prefactored_w[optional] Is w a square root of the covariance matrix?
[in]overwrite_a[optional] Can A data be overwritten and destroyed?
[in]overwrite_w[optional] Can W data be overwritten and destroyed?
[out]err[optional] state return flag. On error if not requested, the code will stop
Here is the call graph for this function:

◆ la_qsolve_generalized_lstsq()

pure subroutine la_least_squares::solve_generalized_lstsq::la_qsolve_generalized_lstsq ( real(qp), dimension(:,:), intent(inout), target w,
real(qp), dimension(:,:), intent(inout), target a,
real(qp), dimension(:), intent(in) b,
real(qp), dimension(:), intent(out) x,
real(qp), dimension(:), intent(inout), optional, target, contiguous storage,
logical(lk), intent(in), optional prefactored_w,
logical(lk), intent(in), optional overwrite_a,
logical(lk), intent(in), optional overwrite_w,
type(la_state), intent(out), optional err )

Solve the real(qp) generalized least-squares problem into x: minimize (b-Ax)^H W^{-1} (b-Ax)

Parameters
[in,out]wCovariance matrix w[m,m], or its square root if prefactored_w
[in,out]aInput matrix a[m,n]
[in]bRight hand side vector b[m]
[out]xSolution vector x[n]
[in,out]storage[optional] working storage space
[in]prefactored_w[optional] Is w a square root of the covariance matrix?
[in]overwrite_a[optional] Can A data be overwritten and destroyed?
[in]overwrite_w[optional] Can W data be overwritten and destroyed?
[out]err[optional] state return flag. On error if not requested, the code will stop
Here is the call graph for this function:

◆ la_ssolve_generalized_lstsq()

pure subroutine la_least_squares::solve_generalized_lstsq::la_ssolve_generalized_lstsq ( real(sp), dimension(:,:), intent(inout), target w,
real(sp), dimension(:,:), intent(inout), target a,
real(sp), dimension(:), intent(in) b,
real(sp), dimension(:), intent(out) x,
real(sp), dimension(:), intent(inout), optional, target, contiguous storage,
logical(lk), intent(in), optional prefactored_w,
logical(lk), intent(in), optional overwrite_a,
logical(lk), intent(in), optional overwrite_w,
type(la_state), intent(out), optional err )

Solve the real(sp) generalized least-squares problem into x: minimize (b-Ax)^H W^{-1} (b-Ax)

Parameters
[in,out]wCovariance matrix w[m,m], or its square root if prefactored_w
[in,out]aInput matrix a[m,n]
[in]bRight hand side vector b[m]
[out]xSolution vector x[n]
[in,out]storage[optional] working storage space
[in]prefactored_w[optional] Is w a square root of the covariance matrix?
[in]overwrite_a[optional] Can A data be overwritten and destroyed?
[in]overwrite_w[optional] Can W data be overwritten and destroyed?
[out]err[optional] state return flag. On error if not requested, the code will stop
Here is the call graph for this function:

◆ la_wsolve_generalized_lstsq()

pure subroutine la_least_squares::solve_generalized_lstsq::la_wsolve_generalized_lstsq ( complex(qp), dimension(:,:), intent(inout), target w,
complex(qp), dimension(:,:), intent(inout), target a,
complex(qp), dimension(:), intent(in) b,
complex(qp), dimension(:), intent(out) x,
complex(qp), dimension(:), intent(inout), optional, target, contiguous storage,
logical(lk), intent(in), optional prefactored_w,
logical(lk), intent(in), optional overwrite_a,
logical(lk), intent(in), optional overwrite_w,
type(la_state), intent(out), optional err )

Solve the complex(qp) generalized least-squares problem into x: minimize (b-Ax)^H W^{-1} (b-Ax)

Parameters
[in,out]wCovariance matrix w[m,m], or its square root if prefactored_w
[in,out]aInput matrix a[m,n]
[in]bRight hand side vector b[m]
[out]xSolution vector x[n]
[in,out]storage[optional] working storage space
[in]prefactored_w[optional] Is w a square root of the covariance matrix?
[in]overwrite_a[optional] Can A data be overwritten and destroyed?
[in]overwrite_w[optional] Can W data be overwritten and destroyed?
[out]err[optional] state return flag. On error if not requested, the code will stop
Here is the call graph for this function:

◆ la_xsolve_generalized_lstsq()

pure subroutine la_least_squares::solve_generalized_lstsq::la_xsolve_generalized_lstsq ( real(xdp), dimension(:,:), intent(inout), target w,
real(xdp), dimension(:,:), intent(inout), target a,
real(xdp), dimension(:), intent(in) b,
real(xdp), dimension(:), intent(out) x,
real(xdp), dimension(:), intent(inout), optional, target, contiguous storage,
logical(lk), intent(in), optional prefactored_w,
logical(lk), intent(in), optional overwrite_a,
logical(lk), intent(in), optional overwrite_w,
type(la_state), intent(out), optional err )

Solve the real(xdp) generalized least-squares problem into x: minimize (b-Ax)^H W^{-1} (b-Ax)

Parameters
[in,out]wCovariance matrix w[m,m], or its square root if prefactored_w
[in,out]aInput matrix a[m,n]
[in]bRight hand side vector b[m]
[out]xSolution vector x[n]
[in,out]storage[optional] working storage space
[in]prefactored_w[optional] Is w a square root of the covariance matrix?
[in]overwrite_a[optional] Can A data be overwritten and destroyed?
[in]overwrite_w[optional] Can W data be overwritten and destroyed?
[out]err[optional] state return flag. On error if not requested, the code will stop
Here is the call graph for this function:

◆ la_ysolve_generalized_lstsq()

pure subroutine la_least_squares::solve_generalized_lstsq::la_ysolve_generalized_lstsq ( complex(xdp), dimension(:,:), intent(inout), target w,
complex(xdp), dimension(:,:), intent(inout), target a,
complex(xdp), dimension(:), intent(in) b,
complex(xdp), dimension(:), intent(out) x,
complex(xdp), dimension(:), intent(inout), optional, target, contiguous storage,
logical(lk), intent(in), optional prefactored_w,
logical(lk), intent(in), optional overwrite_a,
logical(lk), intent(in), optional overwrite_w,
type(la_state), intent(out), optional err )

Solve the complex(xdp) generalized least-squares problem into x: minimize (b-Ax)^H W^{-1} (b-Ax)

Parameters
[in,out]wCovariance matrix w[m,m], or its square root if prefactored_w
[in,out]aInput matrix a[m,n]
[in]bRight hand side vector b[m]
[out]xSolution vector x[n]
[in,out]storage[optional] working storage space
[in]prefactored_w[optional] Is w a square root of the covariance matrix?
[in]overwrite_a[optional] Can A data be overwritten and destroyed?
[in]overwrite_w[optional] Can W data be overwritten and destroyed?
[out]err[optional] state return flag. On error if not requested, the code will stop
Here is the call graph for this function:

◆ la_zsolve_generalized_lstsq()

pure subroutine la_least_squares::solve_generalized_lstsq::la_zsolve_generalized_lstsq ( complex(dp), dimension(:,:), intent(inout), target w,
complex(dp), dimension(:,:), intent(inout), target a,
complex(dp), dimension(:), intent(in) b,
complex(dp), dimension(:), intent(out) x,
complex(dp), dimension(:), intent(inout), optional, target, contiguous storage,
logical(lk), intent(in), optional prefactored_w,
logical(lk), intent(in), optional overwrite_a,
logical(lk), intent(in), optional overwrite_w,
type(la_state), intent(out), optional err )

Solve the complex(dp) generalized least-squares problem into x: minimize (b-Ax)^H W^{-1} (b-Ax)

Parameters
[in,out]wCovariance matrix w[m,m], or its square root if prefactored_w
[in,out]aInput matrix a[m,n]
[in]bRight hand side vector b[m]
[out]xSolution vector x[n]
[in,out]storage[optional] working storage space
[in]prefactored_w[optional] Is w a square root of the covariance matrix?
[in]overwrite_a[optional] Can A data be overwritten and destroyed?
[in]overwrite_w[optional] Can W data be overwritten and destroyed?
[out]err[optional] state return flag. On error if not requested, the code will stop
Here is the call graph for this function:

The documentation for this interface was generated from the following file: