la_cholesky::cholesky Interface Reference

Computes the Cholesky factorization \( A = L \cdot L^T \), or \( A = U^T \cdot U \). More...

Public Member Functions
pure subroutine	la_s_cholesky_inplace (a, lower, other_zeroed, err)
pure subroutine	la_s_cholesky (a, c, lower, other_zeroed, err)
pure subroutine	la_d_cholesky_inplace (a, lower, other_zeroed, err)
pure subroutine	la_d_cholesky (a, c, lower, other_zeroed, err)
pure subroutine	la_q_cholesky_inplace (a, lower, other_zeroed, err)
pure subroutine	la_q_cholesky (a, c, lower, other_zeroed, err)
pure subroutine	la_c_cholesky_inplace (a, lower, other_zeroed, err)
pure subroutine	la_c_cholesky (a, c, lower, other_zeroed, err)
pure subroutine	la_z_cholesky_inplace (a, lower, other_zeroed, err)
pure subroutine	la_z_cholesky (a, c, lower, other_zeroed, err)
pure subroutine	la_w_cholesky_inplace (a, lower, other_zeroed, err)
pure subroutine	la_w_cholesky (a, c, lower, other_zeroed, err)

Detailed Description

Computes the Cholesky factorization \( A = L \cdot L^T \), or \( A = U^T \cdot U \).

Summary

Pure subroutine interface for computing the Cholesky triangular factors.

Description

This interface provides methods for computing the lower- or upper-triangular matrix from the Cholesky factorization of a real symmetric or complex Hermitian matrix. Supported data types include real and complex.
The factorization is computed in-place if only one matrix argument is present; or returned into a second matrix argument, if present. The lower logical flag allows to select between upper or lower factorization; the other_zeroed optional logical flag allows to choose whether the unused part of the triangular matrix should be filled with zeroes.

Note

The solution is based on LAPACK's POTRF methods.

Parameters

[in,out]	a	The input matrix of size \( [m, n] \). Overwritten with the Cholesky factor.
[out]	c	(Optional) The output matrix of size \( [n, n] \), containing the Cholesky factor.
[in]	lower	(Optional) Logical flag indicating whether the lower or upper triangular factor is required. Default: lower triangular factor.
[in]	other_zeroed	(Optional) Logical flag indicating whether the unused half of the matrix should be zeroed. Default: true.
[out]	err	(Optional) State return flag. If not provided, the function will stop on error.

Member Function/Subroutine Documentation

la_c_cholesky()

pure subroutine la_cholesky::cholesky::la_c_cholesky	(	complex(sp), dimension(:,:), intent(in)	a,
		complex(sp), dimension(:,:), intent(out)	c,
		logical(lk), intent(in), optional	lower,
		logical(lk), intent(in), optional	other_zeroed,
		type(la_state), intent(out), optional	err )

Parameters

[in]	a	Input matrix a[n,n]
[out]	c	Output matrix with Cholesky factors c[n,n]
[in]	lower	[optional] is the lower or upper triangular factor required? Default = lower
[in]	other_zeroed	[optional] should the unused half of the return matrix be zeroed out? Default: yes
[out]	err	[optional] state return flag. On error if not requested, the code will stop

la_c_cholesky_inplace()

pure subroutine la_cholesky::cholesky::la_c_cholesky_inplace	(	complex(sp), dimension(:,:), intent(inout), target	a,
		logical(lk), intent(in), optional	lower,
		logical(lk), intent(in), optional	other_zeroed,
		type(la_state), intent(out), optional	err )

Parameters

[in,out]	a	Input matrix a[m,n]
[in]	lower	[optional] is the lower or upper triangular factor required? Default = lower
[in]	other_zeroed	[optional] should the unused half of the return matrix be zeroed out? Default: yes
[out]	err	[optional] state return flag. On error if not requested, the code will stop

la_d_cholesky()

pure subroutine la_cholesky::cholesky::la_d_cholesky	(	real(dp), dimension(:,:), intent(in)	a,
		real(dp), dimension(:,:), intent(out)	c,
		logical(lk), intent(in), optional	lower,
		logical(lk), intent(in), optional	other_zeroed,
		type(la_state), intent(out), optional	err )

Parameters

[in]	a	Input matrix a[n,n]
[out]	c	Output matrix with Cholesky factors c[n,n]
[in]	lower	[optional] is the lower or upper triangular factor required? Default = lower
[in]	other_zeroed	[optional] should the unused half of the return matrix be zeroed out? Default: yes
[out]	err	[optional] state return flag. On error if not requested, the code will stop

la_d_cholesky_inplace()

pure subroutine la_cholesky::cholesky::la_d_cholesky_inplace	(	real(dp), dimension(:,:), intent(inout), target	a,
		logical(lk), intent(in), optional	lower,
		logical(lk), intent(in), optional	other_zeroed,
		type(la_state), intent(out), optional	err )

Parameters

[in,out]	a	Input matrix a[m,n]
[in]	lower	[optional] is the lower or upper triangular factor required? Default = lower
[in]	other_zeroed	[optional] should the unused half of the return matrix be zeroed out? Default: yes
[out]	err	[optional] state return flag. On error if not requested, the code will stop

la_q_cholesky()

pure subroutine la_cholesky::cholesky::la_q_cholesky	(	real(qp), dimension(:,:), intent(in)	a,
		real(qp), dimension(:,:), intent(out)	c,
		logical(lk), intent(in), optional	lower,
		logical(lk), intent(in), optional	other_zeroed,
		type(la_state), intent(out), optional	err )

Parameters

[in]	a	Input matrix a[n,n]
[out]	c	Output matrix with Cholesky factors c[n,n]
[in]	lower	[optional] is the lower or upper triangular factor required? Default = lower
[in]	other_zeroed	[optional] should the unused half of the return matrix be zeroed out? Default: yes
[out]	err	[optional] state return flag. On error if not requested, the code will stop

la_q_cholesky_inplace()

pure subroutine la_cholesky::cholesky::la_q_cholesky_inplace	(	real(qp), dimension(:,:), intent(inout), target	a,
		logical(lk), intent(in), optional	lower,
		logical(lk), intent(in), optional	other_zeroed,
		type(la_state), intent(out), optional	err )

Parameters

[in,out]	a	Input matrix a[m,n]
[in]	lower	[optional] is the lower or upper triangular factor required? Default = lower
[in]	other_zeroed	[optional] should the unused half of the return matrix be zeroed out? Default: yes
[out]	err	[optional] state return flag. On error if not requested, the code will stop

la_s_cholesky()

pure subroutine la_cholesky::cholesky::la_s_cholesky	(	real(sp), dimension(:,:), intent(in)	a,
		real(sp), dimension(:,:), intent(out)	c,
		logical(lk), intent(in), optional	lower,
		logical(lk), intent(in), optional	other_zeroed,
		type(la_state), intent(out), optional	err )

Parameters

[in]	a	Input matrix a[n,n]
[out]	c	Output matrix with Cholesky factors c[n,n]
[in]	lower	[optional] is the lower or upper triangular factor required? Default = lower
[in]	other_zeroed	[optional] should the unused half of the return matrix be zeroed out? Default: yes
[out]	err	[optional] state return flag. On error if not requested, the code will stop

la_s_cholesky_inplace()

pure subroutine la_cholesky::cholesky::la_s_cholesky_inplace	(	real(sp), dimension(:,:), intent(inout), target	a,
		logical(lk), intent(in), optional	lower,
		logical(lk), intent(in), optional	other_zeroed,
		type(la_state), intent(out), optional	err )

Parameters

[in,out]	a	Input matrix a[m,n]
[in]	lower	[optional] is the lower or upper triangular factor required? Default = lower
[in]	other_zeroed	[optional] should the unused half of the return matrix be zeroed out? Default: yes
[out]	err	[optional] state return flag. On error if not requested, the code will stop

la_w_cholesky()

pure subroutine la_cholesky::cholesky::la_w_cholesky	(	complex(qp), dimension(:,:), intent(in)	a,
		complex(qp), dimension(:,:), intent(out)	c,
		logical(lk), intent(in), optional	lower,
		logical(lk), intent(in), optional	other_zeroed,
		type(la_state), intent(out), optional	err )

Parameters

[in]	a	Input matrix a[n,n]
[out]	c	Output matrix with Cholesky factors c[n,n]
[in]	lower	[optional] is the lower or upper triangular factor required? Default = lower
[in]	other_zeroed	[optional] should the unused half of the return matrix be zeroed out? Default: yes
[out]	err	[optional] state return flag. On error if not requested, the code will stop

la_w_cholesky_inplace()

pure subroutine la_cholesky::cholesky::la_w_cholesky_inplace	(	complex(qp), dimension(:,:), intent(inout), target	a,
		logical(lk), intent(in), optional	lower,
		logical(lk), intent(in), optional	other_zeroed,
		type(la_state), intent(out), optional	err )

Parameters

[in,out]	a	Input matrix a[m,n]
[in]	lower	[optional] is the lower or upper triangular factor required? Default = lower
[in]	other_zeroed	[optional] should the unused half of the return matrix be zeroed out? Default: yes
[out]	err	[optional] state return flag. On error if not requested, the code will stop

la_z_cholesky()

pure subroutine la_cholesky::cholesky::la_z_cholesky	(	complex(dp), dimension(:,:), intent(in)	a,
		complex(dp), dimension(:,:), intent(out)	c,
		logical(lk), intent(in), optional	lower,
		logical(lk), intent(in), optional	other_zeroed,
		type(la_state), intent(out), optional	err )

Parameters

[in]	a	Input matrix a[n,n]
[out]	c	Output matrix with Cholesky factors c[n,n]
[in]	lower	[optional] is the lower or upper triangular factor required? Default = lower
[in]	other_zeroed	[optional] should the unused half of the return matrix be zeroed out? Default: yes
[out]	err	[optional] state return flag. On error if not requested, the code will stop

la_z_cholesky_inplace()

pure subroutine la_cholesky::cholesky::la_z_cholesky_inplace	(	complex(dp), dimension(:,:), intent(inout), target	a,
		logical(lk), intent(in), optional	lower,
		logical(lk), intent(in), optional	other_zeroed,
		type(la_state), intent(out), optional	err )

Parameters

[in,out]	a	Input matrix a[m,n]
[in]	lower	[optional] is the lower or upper triangular factor required? Default = lower
[in]	other_zeroed	[optional] should the unused half of the return matrix be zeroed out? Default: yes
[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_cholesky.f90