la_solve::solve_chol Interface Reference

Public Member Functions
pure subroutine	la_ssolve_chol_one (a, b, x, lower, overwrite_a, err)
	Cholesky factorize and solve in one call, _one, real(sp)
pure subroutine	la_dsolve_chol_one (a, b, x, lower, overwrite_a, err)
	Cholesky factorize and solve in one call, _one, real(dp)
pure subroutine	la_qsolve_chol_one (a, b, x, lower, overwrite_a, err)
	Cholesky factorize and solve in one call, _one, real(qp)
pure subroutine	la_csolve_chol_one (a, b, x, lower, overwrite_a, err)
	Cholesky factorize and solve in one call, _one, complex(sp)
pure subroutine	la_zsolve_chol_one (a, b, x, lower, overwrite_a, err)
	Cholesky factorize and solve in one call, _one, complex(dp)
pure subroutine	la_wsolve_chol_one (a, b, x, lower, overwrite_a, err)
	Cholesky factorize and solve in one call, _one, complex(qp)
pure subroutine	la_ssolve_chol_multiple (a, b, x, lower, overwrite_a, err)
	Cholesky factorize and solve in one call, _multiple, real(sp)
pure subroutine	la_dsolve_chol_multiple (a, b, x, lower, overwrite_a, err)
	Cholesky factorize and solve in one call, _multiple, real(dp)
pure subroutine	la_qsolve_chol_multiple (a, b, x, lower, overwrite_a, err)
	Cholesky factorize and solve in one call, _multiple, real(qp)
pure subroutine	la_csolve_chol_multiple (a, b, x, lower, overwrite_a, err)
	Cholesky factorize and solve in one call, _multiple, complex(sp)
pure subroutine	la_zsolve_chol_multiple (a, b, x, lower, overwrite_a, err)
	Cholesky factorize and solve in one call, _multiple, complex(dp)
pure subroutine	la_wsolve_chol_multiple (a, b, x, lower, overwrite_a, err)
	Cholesky factorize and solve in one call, _multiple, complex(qp)

Member Function/Subroutine Documentation

la_csolve_chol_multiple()

pure subroutine la_solve::solve_chol::la_csolve_chol_multiple	(	complex(sp), dimension(:,:), intent(inout), target	a,
		complex(sp), dimension(:,:), intent(in)	b,
		complex(sp), dimension(:,:), intent(inout), target, contiguous	x,
		logical(lk), intent(in), optional	lower,
		logical(lk), intent(in), optional	overwrite_a,
		type(la_state), intent(out), optional	err )

Cholesky factorize and solve in one call, _multiple, complex(sp)

Parameters

[in,out]	a	Input Hermitian positive definite matrix a[n,n]
[in]	b	Right hand side vector or array, b[n] or b[n,nrhs]
[in,out]	x	Result array/matrix x[n] or x[n,nrhs]
[in]	lower	[optional] Use the lower triangular factorization? Default: .true.
[in]	overwrite_a	[optional] Can A data be overwritten and destroyed?
[out]	err	[optional] state return flag. On error if not requested, the code will stop

la_csolve_chol_one()

pure subroutine la_solve::solve_chol::la_csolve_chol_one	(	complex(sp), dimension(:,:), intent(inout), target	a,
		complex(sp), dimension(:), intent(in)	b,
		complex(sp), dimension(:), intent(inout), target, contiguous	x,
		logical(lk), intent(in), optional	lower,
		logical(lk), intent(in), optional	overwrite_a,
		type(la_state), intent(out), optional	err )

Cholesky factorize and solve in one call, _one, complex(sp)

Parameters

[in,out]	a	Input Hermitian positive definite matrix a[n,n]
[in]	b	Right hand side vector or array, b[n] or b[n,nrhs]
[in,out]	x	Result array/matrix x[n] or x[n,nrhs]
[in]	lower	[optional] Use the lower triangular factorization? Default: .true.
[in]	overwrite_a	[optional] Can A data be overwritten and destroyed?
[out]	err	[optional] state return flag. On error if not requested, the code will stop

la_dsolve_chol_multiple()

pure subroutine la_solve::solve_chol::la_dsolve_chol_multiple	(	real(dp), dimension(:,:), intent(inout), target	a,
		real(dp), dimension(:,:), intent(in)	b,
		real(dp), dimension(:,:), intent(inout), target, contiguous	x,
		logical(lk), intent(in), optional	lower,
		logical(lk), intent(in), optional	overwrite_a,
		type(la_state), intent(out), optional	err )

Cholesky factorize and solve in one call, _multiple, real(dp)

Parameters

[in,out]	a	Input Hermitian positive definite matrix a[n,n]
[in]	b	Right hand side vector or array, b[n] or b[n,nrhs]
[in,out]	x	Result array/matrix x[n] or x[n,nrhs]
[in]	lower	[optional] Use the lower triangular factorization? Default: .true.
[in]	overwrite_a	[optional] Can A data be overwritten and destroyed?
[out]	err	[optional] state return flag. On error if not requested, the code will stop

la_dsolve_chol_one()

pure subroutine la_solve::solve_chol::la_dsolve_chol_one	(	real(dp), dimension(:,:), intent(inout), target	a,
		real(dp), dimension(:), intent(in)	b,
		real(dp), dimension(:), intent(inout), target, contiguous	x,
		logical(lk), intent(in), optional	lower,
		logical(lk), intent(in), optional	overwrite_a,
		type(la_state), intent(out), optional	err )

Cholesky factorize and solve in one call, _one, real(dp)

Parameters

[in,out]	a	Input Hermitian positive definite matrix a[n,n]
[in]	b	Right hand side vector or array, b[n] or b[n,nrhs]
[in,out]	x	Result array/matrix x[n] or x[n,nrhs]
[in]	lower	[optional] Use the lower triangular factorization? Default: .true.
[in]	overwrite_a	[optional] Can A data be overwritten and destroyed?
[out]	err	[optional] state return flag. On error if not requested, the code will stop

la_qsolve_chol_multiple()

pure subroutine la_solve::solve_chol::la_qsolve_chol_multiple	(	real(qp), dimension(:,:), intent(inout), target	a,
		real(qp), dimension(:,:), intent(in)	b,
		real(qp), dimension(:,:), intent(inout), target, contiguous	x,
		logical(lk), intent(in), optional	lower,
		logical(lk), intent(in), optional	overwrite_a,
		type(la_state), intent(out), optional	err )

Cholesky factorize and solve in one call, _multiple, real(qp)

Parameters

[in,out]	a	Input Hermitian positive definite matrix a[n,n]
[in]	b	Right hand side vector or array, b[n] or b[n,nrhs]
[in,out]	x	Result array/matrix x[n] or x[n,nrhs]
[in]	lower	[optional] Use the lower triangular factorization? Default: .true.
[in]	overwrite_a	[optional] Can A data be overwritten and destroyed?
[out]	err	[optional] state return flag. On error if not requested, the code will stop

la_qsolve_chol_one()

pure subroutine la_solve::solve_chol::la_qsolve_chol_one	(	real(qp), dimension(:,:), intent(inout), target	a,
		real(qp), dimension(:), intent(in)	b,
		real(qp), dimension(:), intent(inout), target, contiguous	x,
		logical(lk), intent(in), optional	lower,
		logical(lk), intent(in), optional	overwrite_a,
		type(la_state), intent(out), optional	err )

Cholesky factorize and solve in one call, _one, real(qp)

Parameters

[in,out]	a	Input Hermitian positive definite matrix a[n,n]
[in]	b	Right hand side vector or array, b[n] or b[n,nrhs]
[in,out]	x	Result array/matrix x[n] or x[n,nrhs]
[in]	lower	[optional] Use the lower triangular factorization? Default: .true.
[in]	overwrite_a	[optional] Can A data be overwritten and destroyed?
[out]	err	[optional] state return flag. On error if not requested, the code will stop

la_ssolve_chol_multiple()

pure subroutine la_solve::solve_chol::la_ssolve_chol_multiple	(	real(sp), dimension(:,:), intent(inout), target	a,
		real(sp), dimension(:,:), intent(in)	b,
		real(sp), dimension(:,:), intent(inout), target, contiguous	x,
		logical(lk), intent(in), optional	lower,
		logical(lk), intent(in), optional	overwrite_a,
		type(la_state), intent(out), optional	err )

Cholesky factorize and solve in one call, _multiple, real(sp)

Parameters

[in,out]	a	Input Hermitian positive definite matrix a[n,n]
[in]	b	Right hand side vector or array, b[n] or b[n,nrhs]
[in,out]	x	Result array/matrix x[n] or x[n,nrhs]
[in]	lower	[optional] Use the lower triangular factorization? Default: .true.
[in]	overwrite_a	[optional] Can A data be overwritten and destroyed?
[out]	err	[optional] state return flag. On error if not requested, the code will stop

la_ssolve_chol_one()

pure subroutine la_solve::solve_chol::la_ssolve_chol_one	(	real(sp), dimension(:,:), intent(inout), target	a,
		real(sp), dimension(:), intent(in)	b,
		real(sp), dimension(:), intent(inout), target, contiguous	x,
		logical(lk), intent(in), optional	lower,
		logical(lk), intent(in), optional	overwrite_a,
		type(la_state), intent(out), optional	err )

Cholesky factorize and solve in one call, _one, real(sp)

Parameters

[in,out]	a	Input Hermitian positive definite matrix a[n,n]
[in]	b	Right hand side vector or array, b[n] or b[n,nrhs]
[in,out]	x	Result array/matrix x[n] or x[n,nrhs]
[in]	lower	[optional] Use the lower triangular factorization? Default: .true.
[in]	overwrite_a	[optional] Can A data be overwritten and destroyed?
[out]	err	[optional] state return flag. On error if not requested, the code will stop

la_wsolve_chol_multiple()

pure subroutine la_solve::solve_chol::la_wsolve_chol_multiple	(	complex(qp), dimension(:,:), intent(inout), target	a,
		complex(qp), dimension(:,:), intent(in)	b,
		complex(qp), dimension(:,:), intent(inout), target, contiguous	x,
		logical(lk), intent(in), optional	lower,
		logical(lk), intent(in), optional	overwrite_a,
		type(la_state), intent(out), optional	err )

Cholesky factorize and solve in one call, _multiple, complex(qp)

Parameters

[in,out]	a	Input Hermitian positive definite matrix a[n,n]
[in]	b	Right hand side vector or array, b[n] or b[n,nrhs]
[in,out]	x	Result array/matrix x[n] or x[n,nrhs]
[in]	lower	[optional] Use the lower triangular factorization? Default: .true.
[in]	overwrite_a	[optional] Can A data be overwritten and destroyed?
[out]	err	[optional] state return flag. On error if not requested, the code will stop

la_wsolve_chol_one()

pure subroutine la_solve::solve_chol::la_wsolve_chol_one	(	complex(qp), dimension(:,:), intent(inout), target	a,
		complex(qp), dimension(:), intent(in)	b,
		complex(qp), dimension(:), intent(inout), target, contiguous	x,
		logical(lk), intent(in), optional	lower,
		logical(lk), intent(in), optional	overwrite_a,
		type(la_state), intent(out), optional	err )

Cholesky factorize and solve in one call, _one, complex(qp)

Parameters

[in,out]	a	Input Hermitian positive definite matrix a[n,n]
[in]	b	Right hand side vector or array, b[n] or b[n,nrhs]
[in,out]	x	Result array/matrix x[n] or x[n,nrhs]
[in]	lower	[optional] Use the lower triangular factorization? Default: .true.
[in]	overwrite_a	[optional] Can A data be overwritten and destroyed?
[out]	err	[optional] state return flag. On error if not requested, the code will stop

la_zsolve_chol_multiple()

pure subroutine la_solve::solve_chol::la_zsolve_chol_multiple	(	complex(dp), dimension(:,:), intent(inout), target	a,
		complex(dp), dimension(:,:), intent(in)	b,
		complex(dp), dimension(:,:), intent(inout), target, contiguous	x,
		logical(lk), intent(in), optional	lower,
		logical(lk), intent(in), optional	overwrite_a,
		type(la_state), intent(out), optional	err )

Cholesky factorize and solve in one call, _multiple, complex(dp)

Parameters

[in,out]	a	Input Hermitian positive definite matrix a[n,n]
[in]	b	Right hand side vector or array, b[n] or b[n,nrhs]
[in,out]	x	Result array/matrix x[n] or x[n,nrhs]
[in]	lower	[optional] Use the lower triangular factorization? Default: .true.
[in]	overwrite_a	[optional] Can A data be overwritten and destroyed?
[out]	err	[optional] state return flag. On error if not requested, the code will stop

la_zsolve_chol_one()

pure subroutine la_solve::solve_chol::la_zsolve_chol_one	(	complex(dp), dimension(:,:), intent(inout), target	a,
		complex(dp), dimension(:), intent(in)	b,
		complex(dp), dimension(:), intent(inout), target, contiguous	x,
		logical(lk), intent(in), optional	lower,
		logical(lk), intent(in), optional	overwrite_a,
		type(la_state), intent(out), optional	err )

Cholesky factorize and solve in one call, _one, complex(dp)

Parameters

[in,out]	a	Input Hermitian positive definite matrix a[n,n]
[in]	b	Right hand side vector or array, b[n] or b[n,nrhs]
[in,out]	x	Result array/matrix x[n] or x[n,nrhs]
[in]	lower	[optional] Use the lower triangular factorization? Default: .true.
[in]	overwrite_a	[optional] Can A data be overwritten and destroyed?
[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:

• la_solve.f90