d_bplus_factor Module Reference

Functions/Subroutines
subroutine	d_full_lu (blocks, option, stats)
subroutine	d_full_add_multiply (block3, chara, block1, block2, h_mat, option, stats, ptree, msh)
subroutine	d_full_add (block3, chara, block1, ptree, stats, option)
subroutine	d_lr_minusbc (ho_bf1, level_c, rowblock, ptree, stats)
subroutine	d_lr_smw (block_o, Memory, ptree, stats, pgno)
subroutine	d_lr_sblock (ho_bf1, level_c, rowblock, ptree, stats)
subroutine	d_lr_a_minusbdinvc (partitioned_block, ptree, option, stats)
subroutine	d_bf_inverse_schur_partitionedinverse (ho_bf1, level_c, rowblock, error_inout, option, stats, ptree, msh)
subroutine	d_bf_inverse_schulziteration_iplusbutter (block_o, error_inout, option, stats, ptree, msh)
recursive subroutine	d_bf_bdiag_approximation_precompute (recurlevel, bidx, bdiags, option, stats, ptree, msh, pgno)
recursive subroutine	d_bf_bdiag_approximation (recurlevel, bidx, blocks_io, bdiags, option, stats, ptree, msh, pgno)
subroutine	d_bf_compute_schulz_init (schulz_op, option, ptree, stats, msh)
recursive subroutine	d_bf_inverse_partitionedinverse_iplusbutter (blocks_io, level_butterfly_target, recurlevel, option, error_inout, stats, ptree, msh, pgno)
subroutine	d_lr_abcdinverse (partitioned_block, blocks_o, ptree, stats, option, msh)
	**** Merge four child LR into a bigger one More...
recursive subroutine	d_lr_buildabcd (blocks, partitioned_block, option, msh, stats, ptree, pgno, cridx)
	**** Use low-rank arithmetic to form the four child LRs in inverse_ABCD More...
subroutine	d_bf_aggregate (partitioned_block, blocks_o, ptree, stats, option, msh)
	**** Merge four child butterflies (of the same level) into a bigger one More...
subroutine	d_bf_split (blocks_i, blocks_o, ptree, stats, msh, option, splitpg)
subroutine	d_bf_split_checkerror (blocks_i, blocks_o, ptree, stats, option)
subroutine	d_bf_get_rank_abcd (partitioned_block, rankmax)
subroutine	d_bplus_sblock_randomized_memfree (ho_bf1, level_c, rowblock, option, stats, ptree, msh)
	**** Update one off-diagonal block in HODLR/HODBF compressed as More...
subroutine	d_bplus_inverse_schur_partitionedinverse (ho_bf1, level_c, rowblock, option, stats, ptree, msh)
subroutine	d_bplus_inverse_schur_partitionedinverse_hss (bplus, option, stats, ptree, msh)

Function/Subroutine Documentation

d_bf_aggregate()

subroutine d_bplus_factor::d_bf_aggregate	(	type(d_matrixblock)	partitioned_block,
		type(d_matrixblock)	blocks_o,
		type(d_proctree)	ptree,
		type(d_hstat)	stats,
		type(d_hoption)	option,
		type(d_mesh)	msh
	)

**** Merge four child butterflies (of the same level) into a bigger one

****** row-wise ordering from right side

****** column-wise ordering from left side

Here is the call graph for this function:

d_bf_bdiag_approximation()

recursive subroutine d_bplus_factor::d_bf_bdiag_approximation	(	integer	recurlevel,
		integer	bidx,
		type(d_matrixblock)	blocks_io,
		type(d_bdiag)	bdiags,
		type(d_hoption)	option,
		type(d_hstat)	stats,
		type(d_proctree)	ptree,
		type(d_mesh)	msh,
		integer	pgno
	)

Here is the call graph for this function:

d_bf_bdiag_approximation_precompute()

recursive subroutine d_bplus_factor::d_bf_bdiag_approximation_precompute	(	integer	recurlevel,
		integer	bidx,
		type(d_bdiag)	bdiags,
		type(d_hoption)	option,
		type(d_hstat)	stats,
		type(d_proctree)	ptree,
		type(d_mesh)	msh,
		integer	pgno
	)

*** split process groups row-wise

Here is the call graph for this function:

d_bf_compute_schulz_init()

subroutine d_bplus_factor::d_bf_compute_schulz_init	(	type(d_schulz_operand)	schulz_op,
		type(d_hoption)	option,
		type(d_proctree)	ptree,
		type(d_hstat)	stats,
		type(d_mesh)	msh
	)

Here is the call graph for this function:

d_bf_get_rank_abcd()

subroutine d_bplus_factor::d_bf_get_rank_abcd	(	type(d_matrixblock)	partitioned_block,
		integer	rankmax
	)

d_bf_inverse_partitionedinverse_iplusbutter()

recursive subroutine d_bplus_factor::d_bf_inverse_partitionedinverse_iplusbutter	(	type(d_matrixblock)	blocks_io,
		integer	level_butterfly_target,
		integer	recurlevel,
		type(d_hoption)	option,
		real(kind=8)	error_inout,
		type(d_hstat)	stats,
		type(d_proctree)	ptree,
		type(d_mesh)	msh,
		integer	pgno
	)

**** Check the estimated norm of the operator, if too small skip the randomized construction

Here is the call graph for this function:

d_bf_inverse_schulziteration_iplusbutter()

subroutine d_bplus_factor::d_bf_inverse_schulziteration_iplusbutter	(	type(d_matrixblock)	block_o,
		real(kind=8)	error_inout,
		type(d_hoption)	option,
		type(d_hstat)	stats,
		type(d_proctree)	ptree,
		type(d_mesh)	msh
	)

Here is the call graph for this function:

d_bf_inverse_schur_partitionedinverse()

subroutine d_bplus_factor::d_bf_inverse_schur_partitionedinverse	(	type(d_hobf)	ho_bf1,
		integer	level_c,
		integer	rowblock,
		real(kind=8)	error_inout,
		type(d_hoption)	option,
		type(d_hstat)	stats,
		type(d_proctree)	ptree,
		type(d_mesh)	msh
	)

Here is the call graph for this function:

d_bf_split()

subroutine d_bplus_factor::d_bf_split	(	type(d_matrixblock), target	blocks_i,
		type(d_matrixblock)	blocks_o,
		type(d_proctree)	ptree,
		type(d_hstat)	stats,
		type(d_mesh)	msh,
		type(d_hoption)	option,
		integer, optional	splitpg
	)

*** split process groups row-wise

*** try to use the same process group as blocks_i

**** first redistribute blocks_i into blocks_dummysons of the same butterfly levels

**** next convert blocks_dummysons into blocks_osons

Here is the call graph for this function:

d_bf_split_checkerror()

subroutine d_bplus_factor::d_bf_split_checkerror	(	type(d_matrixblock)	blocks_i,
		type(d_matrixblock)	blocks_o,
		type(d_proctree)	ptree,
		type(d_hstat)	stats,
		type(d_hoption)	option
	)

Here is the call graph for this function:

d_bplus_inverse_schur_partitionedinverse()

subroutine d_bplus_factor::d_bplus_inverse_schur_partitionedinverse	(	type(d_hobf)	ho_bf1,
		integer	level_c,
		integer	rowblock,
		type(d_hoption)	option,
		type(d_hstat)	stats,
		type(d_proctree)	ptree,
		type(d_mesh)	msh
	)

Here is the call graph for this function:

d_bplus_inverse_schur_partitionedinverse_hss()

subroutine d_bplus_factor::d_bplus_inverse_schur_partitionedinverse_hss	(	type(d_blockplus)	bplus,
		type(d_hoption)	option,
		type(d_hstat)	stats,
		type(d_proctree)	ptree,
		type(d_mesh)	msh
	)

Here is the call graph for this function:

d_bplus_sblock_randomized_memfree()

subroutine d_bplus_factor::d_bplus_sblock_randomized_memfree	(	type(d_hobf)	ho_bf1,
		integer	level_c,
		integer	rowblock,
		type(d_hoption)	option,
		type(d_hstat)	stats,
		type(d_proctree)	ptree,
		type(d_mesh)	msh
	)

**** Update one off-diagonal block in HODLR/HODBF compressed as

Here is the call graph for this function:

d_full_add()

subroutine d_bplus_factor::d_full_add	(	type(d_matrixblock)	block3,
		character	chara,
		type(d_matrixblock)	block1,
		type(d_proctree)	ptree,
		type(d_hstat)	stats,
		type(d_hoption)	option
	)

Here is the call graph for this function:

d_full_add_multiply()

subroutine d_bplus_factor::d_full_add_multiply	(	type(d_matrixblock)	block3,
		character	chara,
		type(d_matrixblock)	block1,
		type(d_matrixblock)	block2,
		type(d_hmat)	h_mat,
		type(d_hoption)	option,
		type(d_hstat)	stats,
		type(d_proctree)	ptree,
		type(d_mesh)	msh
	)

Here is the call graph for this function:

d_full_lu()

subroutine d_bplus_factor::d_full_lu	(	type(d_matrixblock)	blocks,
		type(d_hoption)	option,
		type(d_hstat)	stats
	)

d_lr_a_minusbdinvc()

subroutine d_bplus_factor::d_lr_a_minusbdinvc	(	type(d_matrixblock)	partitioned_block,
		type(d_proctree)	ptree,
		type(d_hoption)	option,
		type(d_hstat)	stats
	)

Here is the call graph for this function:

d_lr_abcdinverse()

subroutine d_bplus_factor::d_lr_abcdinverse	(	type(d_matrixblock)	partitioned_block,
		type(d_matrixblock)	blocks_o,
		type(d_proctree)	ptree,
		type(d_hstat)	stats,
		type(d_hoption)	option,
		type(d_mesh)	msh
	)

**** Merge four child LR into a bigger one

Here is the call graph for this function:

d_lr_buildabcd()

recursive subroutine d_bplus_factor::d_lr_buildabcd	(	type(d_matrixblock)	blocks,
		type(d_matrixblock)	partitioned_block,
		type(d_hoption)	option,
		type(d_mesh)	msh,
		type(d_hstat)	stats,
		type(d_proctree)	ptree,
		integer	pgno,
		integer	cridx
	)

**** Use low-rank arithmetic to form the four child LRs in inverse_ABCD

Here is the call graph for this function:

d_lr_minusbc()

subroutine d_bplus_factor::d_lr_minusbc	(	type(d_hobf)	ho_bf1,
		integer	level_c,
		integer	rowblock,
		type(d_proctree)	ptree,
		type(d_hstat)	stats
	)

Here is the call graph for this function:

d_lr_sblock()

subroutine d_bplus_factor::d_lr_sblock	(	type(d_hobf)	ho_bf1,
		integer	level_c,
		integer	rowblock,
		type(d_proctree)	ptree,
		type(d_hstat)	stats
	)

Here is the call graph for this function:

d_lr_smw()

subroutine d_bplus_factor::d_lr_smw	(	type(d_matrixblock)	block_o,
		real(kind=8)	Memory,
		type(d_proctree)	ptree,
		type(d_hstat)	stats,
		integer	pgno
	)

Here is the call graph for this function: