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

Public Member Functions

pure real(sp) function, dimension(:), allocatable la_sweighted_lstsq (w, a, b, cond)
 Compute the real(sp) weighted least-squares solution: pure, stops on error.
 
real(sp) function, dimension(:), allocatable la_sweighted_lstsq_err (w, a, b, cond, overwrite_a, rank, err)
 Compute the real(sp) weighted least-squares solution, with a state return flag.
 
pure real(dp) function, dimension(:), allocatable la_dweighted_lstsq (w, a, b, cond)
 Compute the real(dp) weighted least-squares solution: pure, stops on error.
 
real(dp) function, dimension(:), allocatable la_dweighted_lstsq_err (w, a, b, cond, overwrite_a, rank, err)
 Compute the real(dp) weighted least-squares solution, with a state return flag.
 
pure real(xdp) function, dimension(:), allocatable la_xweighted_lstsq (w, a, b, cond)
 Compute the real(xdp) weighted least-squares solution: pure, stops on error.
 
real(xdp) function, dimension(:), allocatable la_xweighted_lstsq_err (w, a, b, cond, overwrite_a, rank, err)
 Compute the real(xdp) weighted least-squares solution, with a state return flag.
 
pure real(qp) function, dimension(:), allocatable la_qweighted_lstsq (w, a, b, cond)
 Compute the real(qp) weighted least-squares solution: pure, stops on error.
 
real(qp) function, dimension(:), allocatable la_qweighted_lstsq_err (w, a, b, cond, overwrite_a, rank, err)
 Compute the real(qp) weighted least-squares solution, with a state return flag.
 
pure complex(sp) function, dimension(:), allocatable la_cweighted_lstsq (w, a, b, cond)
 Compute the complex(sp) weighted least-squares solution: pure, stops on error.
 
complex(sp) function, dimension(:), allocatable la_cweighted_lstsq_err (w, a, b, cond, overwrite_a, rank, err)
 Compute the complex(sp) weighted least-squares solution, with a state return flag.
 
pure complex(dp) function, dimension(:), allocatable la_zweighted_lstsq (w, a, b, cond)
 Compute the complex(dp) weighted least-squares solution: pure, stops on error.
 
complex(dp) function, dimension(:), allocatable la_zweighted_lstsq_err (w, a, b, cond, overwrite_a, rank, err)
 Compute the complex(dp) weighted least-squares solution, with a state return flag.
 
pure complex(xdp) function, dimension(:), allocatable la_yweighted_lstsq (w, a, b, cond)
 Compute the complex(xdp) weighted least-squares solution: pure, stops on error.
 
complex(xdp) function, dimension(:), allocatable la_yweighted_lstsq_err (w, a, b, cond, overwrite_a, rank, err)
 Compute the complex(xdp) weighted least-squares solution, with a state return flag.
 
pure complex(qp) function, dimension(:), allocatable la_wweighted_lstsq (w, a, b, cond)
 Compute the complex(qp) weighted least-squares solution: pure, stops on error.
 
complex(qp) function, dimension(:), allocatable la_wweighted_lstsq_err (w, a, b, cond, overwrite_a, rank, err)
 Compute the complex(qp) weighted least-squares solution, with a state return flag.
 

Member Function/Subroutine Documentation

◆ la_cweighted_lstsq()

pure complex(sp) function, dimension(:), allocatable la_least_squares::weighted_lstsq::la_cweighted_lstsq ( real(sp), dimension(:), intent(in) w,
complex(sp), dimension(:,:), intent(in) a,
complex(sp), dimension(:), intent(in) b,
real(sp), intent(in), optional cond )

Compute the complex(sp) weighted least-squares solution: pure, stops on error.

Parameters
[in]wWeight vector w[m]. It is always real, and all its entries must be positive
[in]aInput matrix a[m,n]
[in]bRight hand side vector b[m]
[in]cond[optional] cutoff for rank evaluation: singular values s(i)<=cond*maxval(s) are considered 0.
Returns
Result array x[n]

◆ la_cweighted_lstsq_err()

complex(sp) function, dimension(:), allocatable la_least_squares::weighted_lstsq::la_cweighted_lstsq_err ( real(sp), dimension(:), intent(in) w,
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 complex(sp) weighted least-squares solution, with a state return flag.

Parameters
[in]wWeight vector w[m]. It is always real, and all its entries must be positive
[in,out]aInput matrix a[m,n]
[in]bRight hand side vector b[m]
[in]cond[optional] cutoff for rank evaluation: singular values s(i)<=cond*maxval(s) are considered 0.
[in]overwrite_a[optional] Can A data be overwritten and destroyed?
[out]rank[optional] Return rank of A
[out]errState return flag
Returns
Result array x[n]

◆ la_dweighted_lstsq()

pure real(dp) function, dimension(:), allocatable la_least_squares::weighted_lstsq::la_dweighted_lstsq ( real(dp), dimension(:), intent(in) w,
real(dp), dimension(:,:), intent(in) a,
real(dp), dimension(:), intent(in) b,
real(dp), intent(in), optional cond )

Compute the real(dp) weighted least-squares solution: pure, stops on error.

Parameters
[in]wWeight vector w[m]. It is always real, and all its entries must be positive
[in]aInput matrix a[m,n]
[in]bRight hand side vector b[m]
[in]cond[optional] cutoff for rank evaluation: singular values s(i)<=cond*maxval(s) are considered 0.
Returns
Result array x[n]

◆ la_dweighted_lstsq_err()

real(dp) function, dimension(:), allocatable la_least_squares::weighted_lstsq::la_dweighted_lstsq_err ( real(dp), dimension(:), intent(in) w,
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 real(dp) weighted least-squares solution, with a state return flag.

Parameters
[in]wWeight vector w[m]. It is always real, and all its entries must be positive
[in,out]aInput matrix a[m,n]
[in]bRight hand side vector b[m]
[in]cond[optional] cutoff for rank evaluation: singular values s(i)<=cond*maxval(s) are considered 0.
[in]overwrite_a[optional] Can A data be overwritten and destroyed?
[out]rank[optional] Return rank of A
[out]errState return flag
Returns
Result array x[n]

◆ la_qweighted_lstsq()

pure real(qp) function, dimension(:), allocatable la_least_squares::weighted_lstsq::la_qweighted_lstsq ( real(qp), dimension(:), intent(in) w,
real(qp), dimension(:,:), intent(in) a,
real(qp), dimension(:), intent(in) b,
real(qp), intent(in), optional cond )

Compute the real(qp) weighted least-squares solution: pure, stops on error.

Parameters
[in]wWeight vector w[m]. It is always real, and all its entries must be positive
[in]aInput matrix a[m,n]
[in]bRight hand side vector b[m]
[in]cond[optional] cutoff for rank evaluation: singular values s(i)<=cond*maxval(s) are considered 0.
Returns
Result array x[n]

◆ la_qweighted_lstsq_err()

real(qp) function, dimension(:), allocatable la_least_squares::weighted_lstsq::la_qweighted_lstsq_err ( real(qp), dimension(:), intent(in) w,
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 real(qp) weighted least-squares solution, with a state return flag.

Parameters
[in]wWeight vector w[m]. It is always real, and all its entries must be positive
[in,out]aInput matrix a[m,n]
[in]bRight hand side vector b[m]
[in]cond[optional] cutoff for rank evaluation: singular values s(i)<=cond*maxval(s) are considered 0.
[in]overwrite_a[optional] Can A data be overwritten and destroyed?
[out]rank[optional] Return rank of A
[out]errState return flag
Returns
Result array x[n]

◆ la_sweighted_lstsq()

pure real(sp) function, dimension(:), allocatable la_least_squares::weighted_lstsq::la_sweighted_lstsq ( real(sp), dimension(:), intent(in) w,
real(sp), dimension(:,:), intent(in) a,
real(sp), dimension(:), intent(in) b,
real(sp), intent(in), optional cond )

Compute the real(sp) weighted least-squares solution: pure, stops on error.

Parameters
[in]wWeight vector w[m]. It is always real, and all its entries must be positive
[in]aInput matrix a[m,n]
[in]bRight hand side vector b[m]
[in]cond[optional] cutoff for rank evaluation: singular values s(i)<=cond*maxval(s) are considered 0.
Returns
Result array x[n]

◆ la_sweighted_lstsq_err()

real(sp) function, dimension(:), allocatable la_least_squares::weighted_lstsq::la_sweighted_lstsq_err ( real(sp), dimension(:), intent(in) w,
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 real(sp) weighted least-squares solution, with a state return flag.

Parameters
[in]wWeight vector w[m]. It is always real, and all its entries must be positive
[in,out]aInput matrix a[m,n]
[in]bRight hand side vector b[m]
[in]cond[optional] cutoff for rank evaluation: singular values s(i)<=cond*maxval(s) are considered 0.
[in]overwrite_a[optional] Can A data be overwritten and destroyed?
[out]rank[optional] Return rank of A
[out]errState return flag
Returns
Result array x[n]

◆ la_wweighted_lstsq()

pure complex(qp) function, dimension(:), allocatable la_least_squares::weighted_lstsq::la_wweighted_lstsq ( real(qp), dimension(:), intent(in) w,
complex(qp), dimension(:,:), intent(in) a,
complex(qp), dimension(:), intent(in) b,
real(qp), intent(in), optional cond )

Compute the complex(qp) weighted least-squares solution: pure, stops on error.

Parameters
[in]wWeight vector w[m]. It is always real, and all its entries must be positive
[in]aInput matrix a[m,n]
[in]bRight hand side vector b[m]
[in]cond[optional] cutoff for rank evaluation: singular values s(i)<=cond*maxval(s) are considered 0.
Returns
Result array x[n]

◆ la_wweighted_lstsq_err()

complex(qp) function, dimension(:), allocatable la_least_squares::weighted_lstsq::la_wweighted_lstsq_err ( real(qp), dimension(:), intent(in) w,
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 complex(qp) weighted least-squares solution, with a state return flag.

Parameters
[in]wWeight vector w[m]. It is always real, and all its entries must be positive
[in,out]aInput matrix a[m,n]
[in]bRight hand side vector b[m]
[in]cond[optional] cutoff for rank evaluation: singular values s(i)<=cond*maxval(s) are considered 0.
[in]overwrite_a[optional] Can A data be overwritten and destroyed?
[out]rank[optional] Return rank of A
[out]errState return flag
Returns
Result array x[n]

◆ la_xweighted_lstsq()

pure real(xdp) function, dimension(:), allocatable la_least_squares::weighted_lstsq::la_xweighted_lstsq ( real(xdp), dimension(:), intent(in) w,
real(xdp), dimension(:,:), intent(in) a,
real(xdp), dimension(:), intent(in) b,
real(xdp), intent(in), optional cond )

Compute the real(xdp) weighted least-squares solution: pure, stops on error.

Parameters
[in]wWeight vector w[m]. It is always real, and all its entries must be positive
[in]aInput matrix a[m,n]
[in]bRight hand side vector b[m]
[in]cond[optional] cutoff for rank evaluation: singular values s(i)<=cond*maxval(s) are considered 0.
Returns
Result array x[n]

◆ la_xweighted_lstsq_err()

real(xdp) function, dimension(:), allocatable la_least_squares::weighted_lstsq::la_xweighted_lstsq_err ( real(xdp), dimension(:), intent(in) w,
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 real(xdp) weighted least-squares solution, with a state return flag.

Parameters
[in]wWeight vector w[m]. It is always real, and all its entries must be positive
[in,out]aInput matrix a[m,n]
[in]bRight hand side vector b[m]
[in]cond[optional] cutoff for rank evaluation: singular values s(i)<=cond*maxval(s) are considered 0.
[in]overwrite_a[optional] Can A data be overwritten and destroyed?
[out]rank[optional] Return rank of A
[out]errState return flag
Returns
Result array x[n]

◆ la_yweighted_lstsq()

pure complex(xdp) function, dimension(:), allocatable la_least_squares::weighted_lstsq::la_yweighted_lstsq ( real(xdp), dimension(:), intent(in) w,
complex(xdp), dimension(:,:), intent(in) a,
complex(xdp), dimension(:), intent(in) b,
real(xdp), intent(in), optional cond )

Compute the complex(xdp) weighted least-squares solution: pure, stops on error.

Parameters
[in]wWeight vector w[m]. It is always real, and all its entries must be positive
[in]aInput matrix a[m,n]
[in]bRight hand side vector b[m]
[in]cond[optional] cutoff for rank evaluation: singular values s(i)<=cond*maxval(s) are considered 0.
Returns
Result array x[n]

◆ la_yweighted_lstsq_err()

complex(xdp) function, dimension(:), allocatable la_least_squares::weighted_lstsq::la_yweighted_lstsq_err ( real(xdp), dimension(:), intent(in) w,
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 complex(xdp) weighted least-squares solution, with a state return flag.

Parameters
[in]wWeight vector w[m]. It is always real, and all its entries must be positive
[in,out]aInput matrix a[m,n]
[in]bRight hand side vector b[m]
[in]cond[optional] cutoff for rank evaluation: singular values s(i)<=cond*maxval(s) are considered 0.
[in]overwrite_a[optional] Can A data be overwritten and destroyed?
[out]rank[optional] Return rank of A
[out]errState return flag
Returns
Result array x[n]

◆ la_zweighted_lstsq()

pure complex(dp) function, dimension(:), allocatable la_least_squares::weighted_lstsq::la_zweighted_lstsq ( real(dp), dimension(:), intent(in) w,
complex(dp), dimension(:,:), intent(in) a,
complex(dp), dimension(:), intent(in) b,
real(dp), intent(in), optional cond )

Compute the complex(dp) weighted least-squares solution: pure, stops on error.

Parameters
[in]wWeight vector w[m]. It is always real, and all its entries must be positive
[in]aInput matrix a[m,n]
[in]bRight hand side vector b[m]
[in]cond[optional] cutoff for rank evaluation: singular values s(i)<=cond*maxval(s) are considered 0.
Returns
Result array x[n]

◆ la_zweighted_lstsq_err()

complex(dp) function, dimension(:), allocatable la_least_squares::weighted_lstsq::la_zweighted_lstsq_err ( real(dp), dimension(:), intent(in) w,
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 complex(dp) weighted least-squares solution, with a state return flag.

Parameters
[in]wWeight vector w[m]. It is always real, and all its entries must be positive
[in,out]aInput matrix a[m,n]
[in]bRight hand side vector b[m]
[in]cond[optional] cutoff for rank evaluation: singular values s(i)<=cond*maxval(s) are considered 0.
[in]overwrite_a[optional] Can A data be overwritten and destroyed?
[out]rank[optional] Return rank of A
[out]errState return flag
Returns
Result array x[n]

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