Public Member Functions
subroutine	la_ssolve_weighted_lstsq (w, a, b, x, cond, overwrite_a, rank, err)
	Compute the real(sp) weighted least-squares solution into x: minimize \|\|D(Ax - b)\|\|, D = diag(sqrt(w))

subroutine	la_dsolve_weighted_lstsq (w, a, b, x, cond, overwrite_a, rank, err)
	Compute the real(dp) weighted least-squares solution into x: minimize \|\|D(Ax - b)\|\|, D = diag(sqrt(w))

subroutine	la_qsolve_weighted_lstsq (w, a, b, x, cond, overwrite_a, rank, err)
	Compute the real(qp) weighted least-squares solution into x: minimize \|\|D(Ax - b)\|\|, D = diag(sqrt(w))

subroutine	la_csolve_weighted_lstsq (w, a, b, x, cond, overwrite_a, rank, err)
	Compute the complex(sp) weighted least-squares solution into x: minimize \|\|D(Ax - b)\|\|, D = diag(sqrt(w))

subroutine	la_zsolve_weighted_lstsq (w, a, b, x, cond, overwrite_a, rank, err)
	Compute the complex(dp) weighted least-squares solution into x: minimize \|\|D(Ax - b)\|\|, D = diag(sqrt(w))

subroutine	la_wsolve_weighted_lstsq (w, a, b, x, cond, overwrite_a, rank, err)
	Compute the complex(qp) weighted least-squares solution into x: minimize \|\|D(Ax - b)\|\|, D = diag(sqrt(w))

Member Function/Subroutine Documentation

◆ la_csolve_weighted_lstsq()

subroutine la_least_squares::solve_weighted_lstsq::la_csolve_weighted_lstsq	(	real(sp), dimension(:), intent(in)	w,
		complex(sp), dimension(:,:), intent(inout), target	a,
		complex(sp), dimension(:), intent(in)	b,
		complex(sp), dimension(:), intent(inout), target, contiguous	x,
		real(sp), intent(in), optional	cond,
		logical(lk), intent(in), optional	overwrite_a,
		integer(ilp), intent(out), optional	rank,
		type(la_state), intent(out), optional	err )

Compute the complex(sp) weighted least-squares solution into x: minimize ||D(Ax - b)||, D = diag(sqrt(w))

Parameters

[in]	w	Weight vector w[m]. It is always real, and all its entries must be positive
[in,out]	a	Input matrix a[m,n]
[in]	b	Right hand side vector b[m]
[in,out]	x	Result array x[n]
[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]	err	[optional] state return flag. On error if not requested, the code will stop

subroutine la_least_squares::solve_weighted_lstsq::la_dsolve_weighted_lstsq	(	real(dp), dimension(:), intent(in)	w,
		real(dp), dimension(:,:), intent(inout), target	a,
		real(dp), dimension(:), intent(in)	b,
		real(dp), dimension(:), intent(inout), target, contiguous	x,
		real(dp), intent(in), optional	cond,
		logical(lk), intent(in), optional	overwrite_a,
		integer(ilp), intent(out), optional	rank,
		type(la_state), intent(out), optional	err )

Compute the real(dp) weighted least-squares solution into x: minimize ||D(Ax - b)||, D = diag(sqrt(w))

Parameters

[in]	w	Weight vector w[m]. It is always real, and all its entries must be positive
[in,out]	a	Input matrix a[m,n]
[in]	b	Right hand side vector b[m]
[in,out]	x	Result array x[n]
[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]	err	[optional] state return flag. On error if not requested, the code will stop

subroutine la_least_squares::solve_weighted_lstsq::la_qsolve_weighted_lstsq	(	real(qp), dimension(:), intent(in)	w,
		real(qp), dimension(:,:), intent(inout), target	a,
		real(qp), dimension(:), intent(in)	b,
		real(qp), dimension(:), intent(inout), target, contiguous	x,
		real(qp), intent(in), optional	cond,
		logical(lk), intent(in), optional	overwrite_a,
		integer(ilp), intent(out), optional	rank,
		type(la_state), intent(out), optional	err )

Compute the real(qp) weighted least-squares solution into x: minimize ||D(Ax - b)||, D = diag(sqrt(w))

Parameters

[in]	w	Weight vector w[m]. It is always real, and all its entries must be positive
[in,out]	a	Input matrix a[m,n]
[in]	b	Right hand side vector b[m]
[in,out]	x	Result array x[n]
[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]	err	[optional] state return flag. On error if not requested, the code will stop

subroutine la_least_squares::solve_weighted_lstsq::la_ssolve_weighted_lstsq	(	real(sp), dimension(:), intent(in)	w,
		real(sp), dimension(:,:), intent(inout), target	a,
		real(sp), dimension(:), intent(in)	b,
		real(sp), dimension(:), intent(inout), target, contiguous	x,
		real(sp), intent(in), optional	cond,
		logical(lk), intent(in), optional	overwrite_a,
		integer(ilp), intent(out), optional	rank,
		type(la_state), intent(out), optional	err )

Compute the real(sp) weighted least-squares solution into x: minimize ||D(Ax - b)||, D = diag(sqrt(w))

Parameters

[in]	w	Weight vector w[m]. It is always real, and all its entries must be positive
[in,out]	a	Input matrix a[m,n]
[in]	b	Right hand side vector b[m]
[in,out]	x	Result array x[n]
[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]	err	[optional] state return flag. On error if not requested, the code will stop

subroutine la_least_squares::solve_weighted_lstsq::la_wsolve_weighted_lstsq	(	real(qp), dimension(:), intent(in)	w,
		complex(qp), dimension(:,:), intent(inout), target	a,
		complex(qp), dimension(:), intent(in)	b,
		complex(qp), dimension(:), intent(inout), target, contiguous	x,
		real(qp), intent(in), optional	cond,
		logical(lk), intent(in), optional	overwrite_a,
		integer(ilp), intent(out), optional	rank,
		type(la_state), intent(out), optional	err )

Compute the complex(qp) weighted least-squares solution into x: minimize ||D(Ax - b)||, D = diag(sqrt(w))

Parameters

[in]	w	Weight vector w[m]. It is always real, and all its entries must be positive
[in,out]	a	Input matrix a[m,n]
[in]	b	Right hand side vector b[m]
[in,out]	x	Result array x[n]
[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]	err	[optional] state return flag. On error if not requested, the code will stop

subroutine la_least_squares::solve_weighted_lstsq::la_zsolve_weighted_lstsq	(	real(dp), dimension(:), intent(in)	w,
		complex(dp), dimension(:,:), intent(inout), target	a,
		complex(dp), dimension(:), intent(in)	b,
		complex(dp), dimension(:), intent(inout), target, contiguous	x,
		real(dp), intent(in), optional	cond,
		logical(lk), intent(in), optional	overwrite_a,
		integer(ilp), intent(out), optional	rank,
		type(la_state), intent(out), optional	err )

Compute the complex(dp) weighted least-squares solution into x: minimize ||D(Ax - b)||, D = diag(sqrt(w))

Parameters

[in]	w	Weight vector w[m]. It is always real, and all its entries must be positive
[in,out]	a	Input matrix a[m,n]
[in]	b	Right hand side vector b[m]
[in,out]	x	Result array x[n]
[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]	err	[optional] state return flag. On error if not requested, the code will stop

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