hecmw_mf_kernel Module Reference

Dense kernels of the multifrontal solver, symmetric (LDLt) and unsymmetric (LU) mode. More...

Functions/Subroutines
subroutine, public	hecmw_mf_kernel_ldlt (n, lda, a, zero, info)
	In place LDLt of the lower triangle of a(n,n) without pivoting; info is the index of the first pivot whose magnitude is not above zero, 0 on success. More...
subroutine, public	hecmw_mf_kernel_trsm (m, n, ldl, l, lda, a)
	a(m,n) <- a * L^-T * D^-1 with L, D taken from the factored tile l(n,n) (1x1 pivots only). More...
subroutine, public	hecmw_mf_kernel_panel_nopiv (m, n, lda, a, u, zero, info)
	Factor the panel a(m,n) (leading n x n block LDLt, rows below by the panel solve) without pivoting and check the threshold u afterwards: info is 0 when every pivot magnitude is above zero and every entry of L is bounded by 1/u, otherwise the first column that fails. More...
subroutine, public	hecmw_mf_kernel_panel_piv (m, n, lda, a, blk, u, alpha, zero, allow_delay, wk, npiv, perm, ptype, dsub, nswap, n2x2, info)
	Factor the panel a(m,n) with 1x1 and 2x2 pivots chosen among its n columns. A column is accepted as a 1x1 pivot when it satisfies the threshold u against the whole column; else a partner is searched, first among the columns of the same block (blk), then among the others, and the Bunch-Kaufman rule with alpha decides between a 1x1 pivot on the partner and a 2x2 pivot, the latter accepted when the entries of L stay bounded by 1/u. Columns without an acceptable pivot are moved to the end of the panel (allow_delay) or stop the factorization (info = column). On return the first npiv columns are factored, perm(j) is the original column at position j, and blk is permuted alike. wk holds 2*m words. More...
subroutine, public	hecmw_mf_kernel_scale (m, n, ldl, l, ptype, dsub, lda, a, w)
	w(m,n) <- a * D with the block diagonal D of the factored tile l(n,n). More...
subroutine, public	hecmw_mf_kernel_gemm (m, n, k, ldw, w, ldb, b, ldc, c)
	c(m,n) <- c - w(m,k) * b(n,k)^T More...
subroutine, public	hecmw_mf_kernel_trsv (n, ldl, l, x)
	x <- L^-1 x with the unit lower triangle of the tile l(n,n). More...
subroutine, public	hecmw_mf_kernel_trsv_t (n, ldl, l, x)
	x <- L^-T x with the unit lower triangle of the tile l(n,n). More...
subroutine, public	hecmw_mf_kernel_dsolve (n, ldl, l, ptype, dsub, x)
	x <- D^-1 x with the block diagonal D of the factored tile l(n,n). More...
subroutine, public	hecmw_mf_kernel_gemv (m, n, lda, a, x, y)
	y(m) <- y - a(m,n) * x(n) More...
subroutine, public	hecmw_mf_kernel_gemv_t (m, n, lda, a, x, y)
	y(n) <- y - a(m,n)^T * x(m) More...
subroutine, public	hecmw_mf_kernel_lu (n, lda, a, ldb, b, zero, info)
	In place LU of the n x n block held in a (diagonal and below) and b (above, transposed) without pivoting; info is the index of the first pivot whose magnitude is not above zero, 0 on success. More...
subroutine, public	hecmw_mf_kernel_trsm_rt (m, n, ldt, t, unit, lda, a)
	a(m,n) <- a * T^-T with the lower triangle of t(n,n), unit diagonal when unit. More...
subroutine, public	hecmw_mf_kernel_panel_lu_nopiv (m, n, lda, a, ldb, b, u, zero, info)
	LU of the panel a(m,n), b(m,n) (leading n x n block, rows below by the panel solves) without pivoting and the threshold check afterwards, as panel_nopiv. The diagonal of b receives the diagonal of U. More...
subroutine, public	hecmw_mf_kernel_panel_lu_piv (m, n, lda, a, ldb, b, blk, blkr, u, zero, allow_delay, npiv, permc, permr, nswap, info)
	LU of the panel a(m,n), b(m,n) with threshold partial pivoting among its n rows: column p takes the row of largest magnitude among the rows of the same block (blkr against blk(p)), else among the other panel rows, when it reaches u times the largest magnitude of the whole column. Rows are exchanged, columns are not. Columns without an acceptable pivot are moved with their rows to the end of the panel (allow_delay) or stop the factorization (info = column). On return the first npiv columns are factored, permc(j) and permr(j) are the original column and row at position j, and blk, blkr are permuted alike. More...
subroutine, public	hecmw_mf_kernel_usolve (n, ldl, l, ldu, ut, x)
	x <- U^-1 x with the diagonal of U on the diagonal of l(n,n) and its strictly upper part transposed in the strictly lower part of ut(n,n). More...
logical function, public	hecmw_mf_kernel_blr_available ()
	Whether the BLR compression is available (LAPACK build). More...
subroutine, public	hecmw_mf_kernel_compress (m, n, lda, a, eps, ldv, v, rank, rcap)
	Truncated rank revealing QR of a(m,n) with the truncation |R(k,k)| <= eps |R(1,1)|: on success the leading rank columns of a hold U and v(n,rank) holds V with a ~ U V^T. rank is -1, with a destroyed, when the low rank form would not take fewer than m*n words (the caller keeps its full rank copy) or without LAPACK. The column pivoted Householder QR stops right at the truncation or at the word bound, so the cost is O(m*n*rank) where dgeqp3 pays the full decomposition. The pivot column is selected by downdated norms with the dgeqp3 recomputation guard, but the truncation is decided on the freshly computed norm so a stale estimate cannot end the sweep early. rcap tightens the word bound: the sweep gives up (rank = -1) beyond min(rlim, rcap). The pivoted sweep with the downdated column norms is adapted from LAPACK's dlaqp2 (with the norm recomputation guard of LAPACK Working Note 176) and the explicit formation of the Q columns follows dorg2r. LAPACK is distributed under the modified BSD license: More...
subroutine, public	hecmw_mf_kernel_mult_nn (m, n, k, lda, a, ldb, b, ldc, c)
	c(m,n) <- a(m,k) * b(k,n) More...
subroutine, public	hecmw_mf_kernel_mult_tn (m, n, k, lda, a, ldb, b, ldc, c)
	c(m,n) <- a(k,m)^T * b(k,n) More...
subroutine, public	hecmw_mf_kernel_mult_tv (m, n, lda, a, x, y)
	y(n) <- a(m,n)^T * x(m) More...
subroutine, public	hecmw_mf_kernel_scale_rows (n, r, ldl, l, ptype, dsub, ldv, v, ldw, w)
	w(n,r) <- D * v(n,r) with the block diagonal D of the factored tile l(n,n). More...

Detailed Description

Dense kernels of the multifrontal solver, symmetric (LDLt) and unsymmetric (LU) mode.

A tile or panel is a column major block a(lda,*); only the part on or below the diagonal of its leading square is referenced. Factored columns hold the unit lower triangle of L below the diagonal and D on the diagonal. D is block diagonal: ptype(j) is 1 for a 1x1 pivot, 2 and 3 for the first and second column of a 2x2 pivot whose off-diagonal entry is dsub(j) of the first column (the L entry at that position is 0). The BLAS3 path is used when HECMW_WITH_LAPACK is defined, otherwise plain loops.

In LU mode the part above the diagonal is held transposed in a second block b of the same shape, b(i,j) = A(j,i) for i > j, so that the row of U of a pivot is a column of b. Factored columns then hold L below the diagonal of a, U on the diagonal of a and in the columns of b.

Function/Subroutine Documentation

hecmw_mf_kernel_blr_available()

logical function, public hecmw_mf_kernel::hecmw_mf_kernel_blr_available

Whether the BLR compression is available (LAPACK build).

Definition at line 787 of file hecmw_mf_kernel.F90.

Here is the caller graph for this function:

hecmw_mf_kernel_compress()

subroutine, public hecmw_mf_kernel::hecmw_mf_kernel_compress	(	integer(kind=kint), intent(in)	m,
		integer(kind=kint), intent(in)	n,
		integer(kind=kint), intent(in)	lda,
		real(kind=kreal), dimension(lda,*), intent(inout)	a,
		real(kind=kreal), intent(in)	eps,
		integer(kind=kint), intent(in)	ldv,
		real(kind=kreal), dimension(ldv,*), intent(out)	v,
		integer(kind=kint), intent(out)	rank,
		integer(kind=kint), intent(in), optional	rcap
	)

Truncated rank revealing QR of a(m,n) with the truncation |R(k,k)| <= eps |R(1,1)|: on success the leading rank columns of a hold U and v(n,rank) holds V with a ~ U V^T. rank is -1, with a destroyed, when the low rank form would not take fewer than m*n words (the caller keeps its full rank copy) or without LAPACK. The column pivoted Householder QR stops right at the truncation or at the word bound, so the cost is O(m*n*rank) where dgeqp3 pays the full decomposition. The pivot column is selected by downdated norms with the dgeqp3 recomputation guard, but the truncation is decided on the freshly computed norm so a stale estimate cannot end the sweep early. rcap tightens the word bound: the sweep gives up (rank = -1) beyond min(rlim, rcap). The pivoted sweep with the downdated column norms is adapted from LAPACK's dlaqp2 (with the norm recomputation guard of LAPACK Working Note 176) and the explicit formation of the Q columns follows dorg2r. LAPACK is distributed under the modified BSD license:

Copyright (c) 1992-2025 The University of Tennessee and The University of Tennessee Research Foundation. All rights reserved. Copyright (c) 2000-2025 The University of California Berkeley. All rights reserved. Copyright (c) 2006-2025 The University of Colorado Denver. All rights reserved.

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

• Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
• Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer listed in this license in the documentation and/or other materials provided with the distribution.
• Neither the name of the copyright holders nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. The copyright holders provide no reassurances that the source code provided does not infringe any patent, copyright, or any other intellectual property rights of third parties. The copyright holders disclaim any liability to any recipient for claims brought against recipient by any third party for infringement of that parties intellectual property rights. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

Definition at line 840 of file hecmw_mf_kernel.F90.

hecmw_mf_kernel_dsolve()

subroutine, public hecmw_mf_kernel::hecmw_mf_kernel_dsolve	(	integer(kind=kint), intent(in)	n,
		integer(kind=kint), intent(in)	ldl,
		real(kind=kreal), dimension(ldl,*), intent(in)	l,
		integer(kind=kint), dimension(n), intent(in)	ptype,
		real(kind=kreal), dimension(n), intent(in)	dsub,
		real(kind=kreal), dimension(n), intent(inout)	x
	)

x <- D^-1 x with the block diagonal D of the factored tile l(n,n).

Definition at line 435 of file hecmw_mf_kernel.F90.

hecmw_mf_kernel_gemm()

subroutine, public hecmw_mf_kernel::hecmw_mf_kernel_gemm	(	integer(kind=kint), intent(in)	m,
		integer(kind=kint), intent(in)	n,
		integer(kind=kint), intent(in)	k,
		integer(kind=kint), intent(in)	ldw,
		real(kind=kreal), dimension(ldw,*), intent(in)	w,
		integer(kind=kint), intent(in)	ldb,
		real(kind=kreal), dimension(ldb,*), intent(in)	b,
		integer(kind=kint), intent(in)	ldc,
		real(kind=kreal), dimension(ldc,*), intent(inout)	c
	)

c(m,n) <- c - w(m,k) * b(n,k)^T

Definition at line 381 of file hecmw_mf_kernel.F90.

Here is the caller graph for this function:

hecmw_mf_kernel_gemv()

subroutine, public hecmw_mf_kernel::hecmw_mf_kernel_gemv	(	integer(kind=kint), intent(in)	m,
		integer(kind=kint), intent(in)	n,
		integer(kind=kint), intent(in)	lda,
		real(kind=kreal), dimension(lda,*), intent(in)	a,
		real(kind=kreal), dimension(n), intent(in)	x,
		real(kind=kreal), dimension(m), intent(inout)	y
	)

y(m) <- y - a(m,n) * x(n)

Definition at line 462 of file hecmw_mf_kernel.F90.

hecmw_mf_kernel_gemv_t()

subroutine, public hecmw_mf_kernel::hecmw_mf_kernel_gemv_t	(	integer(kind=kint), intent(in)	m,
		integer(kind=kint), intent(in)	n,
		integer(kind=kint), intent(in)	lda,
		real(kind=kreal), dimension(lda,*), intent(in)	a,
		real(kind=kreal), dimension(m), intent(in)	x,
		real(kind=kreal), dimension(n), intent(inout)	y
	)

y(n) <- y - a(m,n)^T * x(m)

Definition at line 478 of file hecmw_mf_kernel.F90.

hecmw_mf_kernel_ldlt()

subroutine, public hecmw_mf_kernel::hecmw_mf_kernel_ldlt	(	integer(kind=kint), intent(in)	n,
		integer(kind=kint), intent(in)	lda,
		real(kind=kreal), dimension(lda,*), intent(inout)	a,
		real(kind=kreal), intent(in)	zero,
		integer(kind=kint), intent(out)	info
	)

In place LDLt of the lower triangle of a(n,n) without pivoting; info is the index of the first pivot whose magnitude is not above zero, 0 on success.

Definition at line 49 of file hecmw_mf_kernel.F90.

Here is the caller graph for this function:

hecmw_mf_kernel_lu()

subroutine, public hecmw_mf_kernel::hecmw_mf_kernel_lu	(	integer(kind=kint), intent(in)	n,
		integer(kind=kint), intent(in)	lda,
		real(kind=kreal), dimension(lda,*), intent(inout)	a,
		integer(kind=kint), intent(in)	ldb,
		real(kind=kreal), dimension(ldb,*), intent(inout)	b,
		real(kind=kreal), intent(in)	zero,
		integer(kind=kint), intent(out)	info
	)

In place LU of the n x n block held in a (diagonal and below) and b (above, transposed) without pivoting; info is the index of the first pivot whose magnitude is not above zero, 0 on success.

Definition at line 496 of file hecmw_mf_kernel.F90.

Here is the caller graph for this function:

hecmw_mf_kernel_mult_nn()

subroutine, public hecmw_mf_kernel::hecmw_mf_kernel_mult_nn	(	integer(kind=kint), intent(in)	m,
		integer(kind=kint), intent(in)	n,
		integer(kind=kint), intent(in)	k,
		integer(kind=kint), intent(in)	lda,
		real(kind=kreal), dimension(lda,*), intent(in)	a,
		integer(kind=kint), intent(in)	ldb,
		real(kind=kreal), dimension(ldb,*), intent(in)	b,
		integer(kind=kint), intent(in)	ldc,
		real(kind=kreal), dimension(ldc,*), intent(out)	c
	)

c(m,n) <- a(m,k) * b(k,n)

Definition at line 950 of file hecmw_mf_kernel.F90.

Here is the caller graph for this function:

hecmw_mf_kernel_mult_tn()

subroutine, public hecmw_mf_kernel::hecmw_mf_kernel_mult_tn	(	integer(kind=kint), intent(in)	m,
		integer(kind=kint), intent(in)	n,
		integer(kind=kint), intent(in)	k,
		integer(kind=kint), intent(in)	lda,
		real(kind=kreal), dimension(lda,*), intent(in)	a,
		integer(kind=kint), intent(in)	ldb,
		real(kind=kreal), dimension(ldb,*), intent(in)	b,
		integer(kind=kint), intent(in)	ldc,
		real(kind=kreal), dimension(ldc,*), intent(out)	c
	)

c(m,n) <- a(k,m)^T * b(k,n)

Definition at line 976 of file hecmw_mf_kernel.F90.

Here is the caller graph for this function:

hecmw_mf_kernel_mult_tv()

subroutine, public hecmw_mf_kernel::hecmw_mf_kernel_mult_tv	(	integer(kind=kint), intent(in)	m,
		integer(kind=kint), intent(in)	n,
		integer(kind=kint), intent(in)	lda,
		real(kind=kreal), dimension(lda,*), intent(in)	a,
		real(kind=kreal), dimension(m), intent(in)	x,
		real(kind=kreal), dimension(n), intent(out)	y
	)

y(n) <- a(m,n)^T * x(m)

Definition at line 1000 of file hecmw_mf_kernel.F90.

hecmw_mf_kernel_panel_lu_nopiv()

subroutine, public hecmw_mf_kernel::hecmw_mf_kernel_panel_lu_nopiv	(	integer(kind=kint), intent(in)	m,
		integer(kind=kint), intent(in)	n,
		integer(kind=kint), intent(in)	lda,
		real(kind=kreal), dimension(lda,*), intent(inout)	a,
		integer(kind=kint), intent(in)	ldb,
		real(kind=kreal), dimension(ldb,*), intent(inout)	b,
		real(kind=kreal), intent(in)	u,
		real(kind=kreal), intent(in)	zero,
		integer(kind=kint), intent(out)	info
	)

LU of the panel a(m,n), b(m,n) (leading n x n block, rows below by the panel solves) without pivoting and the threshold check afterwards, as panel_nopiv. The diagonal of b receives the diagonal of U.

Definition at line 564 of file hecmw_mf_kernel.F90.

Here is the call graph for this function:

hecmw_mf_kernel_panel_lu_piv()

subroutine, public hecmw_mf_kernel::hecmw_mf_kernel_panel_lu_piv	(	integer(kind=kint), intent(in)	m,
		integer(kind=kint), intent(in)	n,
		integer(kind=kint), intent(in)	lda,
		real(kind=kreal), dimension(lda,*), intent(inout)	a,
		integer(kind=kint), intent(in)	ldb,
		real(kind=kreal), dimension(ldb,*), intent(inout)	b,
		integer(kind=kint), dimension(n), intent(inout)	blk,
		integer(kind=kint), dimension(n), intent(inout)	blkr,
		real(kind=kreal), intent(in)	u,
		real(kind=kreal), intent(in)	zero,
		logical, intent(in)	allow_delay,
		integer(kind=kint), intent(out)	npiv,
		integer(kind=kint), dimension(n), intent(out)	permc,
		integer(kind=kint), dimension(n), intent(out)	permr,
		integer(kind=kint), intent(out)	nswap,
		integer(kind=kint), intent(out)	info
	)

LU of the panel a(m,n), b(m,n) with threshold partial pivoting among its n rows: column p takes the row of largest magnitude among the rows of the same block (blkr against blk(p)), else among the other panel rows, when it reaches u times the largest magnitude of the whole column. Rows are exchanged, columns are not. Columns without an acceptable pivot are moved with their rows to the end of the panel (allow_delay) or stop the factorization (info = column). On return the first npiv columns are factored, permc(j) and permr(j) are the original column and row at position j, and blk, blkr are permuted alike.

Definition at line 600 of file hecmw_mf_kernel.F90.

hecmw_mf_kernel_panel_nopiv()

subroutine, public hecmw_mf_kernel::hecmw_mf_kernel_panel_nopiv	(	integer(kind=kint), intent(in)	m,
		integer(kind=kint), intent(in)	n,
		integer(kind=kint), intent(in)	lda,
		real(kind=kreal), dimension(lda,*), intent(inout)	a,
		real(kind=kreal), intent(in)	u,
		real(kind=kreal), intent(in)	zero,
		integer(kind=kint), intent(out)	info
	)

Factor the panel a(m,n) (leading n x n block LDLt, rows below by the panel solve) without pivoting and check the threshold u afterwards: info is 0 when every pivot magnitude is above zero and every entry of L is bounded by 1/u, otherwise the first column that fails.

Definition at line 115 of file hecmw_mf_kernel.F90.

Here is the call graph for this function:

hecmw_mf_kernel_panel_piv()

subroutine, public hecmw_mf_kernel::hecmw_mf_kernel_panel_piv	(	integer(kind=kint), intent(in)	m,
		integer(kind=kint), intent(in)	n,
		integer(kind=kint), intent(in)	lda,
		real(kind=kreal), dimension(lda,*), intent(inout)	a,
		integer(kind=kint), dimension(n), intent(inout)	blk,
		real(kind=kreal), intent(in)	u,
		real(kind=kreal), intent(in)	alpha,
		real(kind=kreal), intent(in)	zero,
		logical, intent(in)	allow_delay,
		real(kind=kreal), dimension(2*m), intent(inout)	wk,
		integer(kind=kint), intent(out)	npiv,
		integer(kind=kint), dimension(n), intent(out)	perm,
		integer(kind=kint), dimension(n), intent(out)	ptype,
		real(kind=kreal), dimension(n), intent(out)	dsub,
		integer(kind=kint), intent(out)	nswap,
		integer(kind=kint), intent(out)	n2x2,
		integer(kind=kint), intent(out)	info
	)

Factor the panel a(m,n) with 1x1 and 2x2 pivots chosen among its n columns. A column is accepted as a 1x1 pivot when it satisfies the threshold u against the whole column; else a partner is searched, first among the columns of the same block (blk), then among the others, and the Bunch-Kaufman rule with alpha decides between a 1x1 pivot on the partner and a 2x2 pivot, the latter accepted when the entries of L stay bounded by 1/u. Columns without an acceptable pivot are moved to the end of the panel (allow_delay) or stop the factorization (info = column). On return the first npiv columns are factored, perm(j) is the original column at position j, and blk is permuted alike. wk holds 2*m words.

Definition at line 146 of file hecmw_mf_kernel.F90.

hecmw_mf_kernel_scale()

subroutine, public hecmw_mf_kernel::hecmw_mf_kernel_scale	(	integer(kind=kint), intent(in)	m,
		integer(kind=kint), intent(in)	n,
		integer(kind=kint), intent(in)	ldl,
		real(kind=kreal), dimension(ldl,*), intent(in)	l,
		integer(kind=kint), dimension(n), intent(in)	ptype,
		real(kind=kreal), dimension(n), intent(in)	dsub,
		integer(kind=kint), intent(in)	lda,
		real(kind=kreal), dimension(lda,*), intent(in)	a,
		real(kind=kreal), dimension(m,n), intent(out)	w
	)

w(m,n) <- a * D with the block diagonal D of the factored tile l(n,n).

Definition at line 352 of file hecmw_mf_kernel.F90.

hecmw_mf_kernel_scale_rows()

subroutine, public hecmw_mf_kernel::hecmw_mf_kernel_scale_rows	(	integer(kind=kint), intent(in)	n,
		integer(kind=kint), intent(in)	r,
		integer(kind=kint), intent(in)	ldl,
		real(kind=kreal), dimension(ldl,*), intent(in)	l,
		integer(kind=kint), dimension(n), intent(in)	ptype,
		real(kind=kreal), dimension(n), intent(in)	dsub,
		integer(kind=kint), intent(in)	ldv,
		real(kind=kreal), dimension(ldv,*), intent(in)	v,
		integer(kind=kint), intent(in)	ldw,
		real(kind=kreal), dimension(ldw,*), intent(out)	w
	)

w(n,r) <- D * v(n,r) with the block diagonal D of the factored tile l(n,n).

Definition at line 1017 of file hecmw_mf_kernel.F90.

hecmw_mf_kernel_trsm()

subroutine, public hecmw_mf_kernel::hecmw_mf_kernel_trsm	(	integer(kind=kint), intent(in)	m,
		integer(kind=kint), intent(in)	n,
		integer(kind=kint), intent(in)	ldl,
		real(kind=kreal), dimension(ldl,*), intent(in)	l,
		integer(kind=kint), intent(in)	lda,
		real(kind=kreal), dimension(lda,*), intent(inout)	a
	)

a(m,n) <- a * L^-T * D^-1 with L, D taken from the factored tile l(n,n) (1x1 pivots only).

Definition at line 78 of file hecmw_mf_kernel.F90.

Here is the caller graph for this function:

hecmw_mf_kernel_trsm_rt()

subroutine, public hecmw_mf_kernel::hecmw_mf_kernel_trsm_rt	(	integer(kind=kint), intent(in)	m,
		integer(kind=kint), intent(in)	n,
		integer(kind=kint), intent(in)	ldt,
		real(kind=kreal), dimension(ldt,*), intent(in)	t,
		logical, intent(in)	unit,
		integer(kind=kint), intent(in)	lda,
		real(kind=kreal), dimension(lda,*), intent(inout)	a
	)

a(m,n) <- a * T^-T with the lower triangle of t(n,n), unit diagonal when unit.

Definition at line 529 of file hecmw_mf_kernel.F90.

Here is the caller graph for this function:

hecmw_mf_kernel_trsv()

subroutine, public hecmw_mf_kernel::hecmw_mf_kernel_trsv	(	integer(kind=kint), intent(in)	n,
		integer(kind=kint), intent(in)	ldl,
		real(kind=kreal), dimension(ldl,*), intent(in)	l,
		real(kind=kreal), dimension(n), intent(inout)	x
	)

x <- L^-1 x with the unit lower triangle of the tile l(n,n).

Definition at line 405 of file hecmw_mf_kernel.F90.

hecmw_mf_kernel_trsv_t()

subroutine, public hecmw_mf_kernel::hecmw_mf_kernel_trsv_t	(	integer(kind=kint), intent(in)	n,
		integer(kind=kint), intent(in)	ldl,
		real(kind=kreal), dimension(ldl,*), intent(in)	l,
		real(kind=kreal), dimension(n), intent(inout)	x
	)

x <- L^-T x with the unit lower triangle of the tile l(n,n).

Definition at line 420 of file hecmw_mf_kernel.F90.

hecmw_mf_kernel_usolve()

subroutine, public hecmw_mf_kernel::hecmw_mf_kernel_usolve	(	integer(kind=kint), intent(in)	n,
		integer(kind=kint), intent(in)	ldl,
		real(kind=kreal), dimension(ldl,*), intent(in)	l,
		integer(kind=kint), intent(in)	ldu,
		real(kind=kreal), dimension(ldu,*), intent(in)	ut,
		real(kind=kreal), dimension(n), intent(inout)	x
	)

x <- U^-1 x with the diagonal of U on the diagonal of l(n,n) and its strictly upper part transposed in the strictly lower part of ut(n,n).

Definition at line 771 of file hecmw_mf_kernel.F90.