la_cholesky::cholesky Interface Reference

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)

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