d_bplus_randomizedop Module Reference

Functions/Subroutines
subroutine	d_bf_block_mvp_inverse_dat (ho_bf1, level, ii, trans, N, num_vect_sub, Vin, ldi, Vout, ldo, ptree, stats)
subroutine	d_bf_delete_randvect (chara, random, level_butterfly)
subroutine	d_bf_init_randomized (level_butterfly, rankmax, groupm, groupn, block, block_rand, msh, ptree, option, nodataflag)
subroutine	d_bf_zero (level_butterfly, groupm, groupn, block, block_rand, msh, ptree, option)
subroutine	d_bf_resolving_butterfly_ll_dat (num_vect_sub, nth_s, nth_e, Ng, level, blocks, RandVectIn, RandVectOut, option, ptree, msh, stats, norm_tol)
subroutine	d_bf_getnumvectestimate_ll (num_vect, nth_s, nth_e, Ng, level, blocks, option, ptree, msh, stats)
subroutine	d_bf_oneblock_ll (index_i, index_j, level, num_vect_sub, mm, nth, nth_s, blocks, BFvec, option, stats, norm_tol)
subroutine	d_bf_resolving_butterfly_rr_dat (num_vect_sub, nth_s, nth_e, Ng, level, blocks, RandVectIn, RandVectOut, option, ptree, msh, stats, norm_tol)
subroutine	d_bf_getnumvectestimate_rr (num_vect, nth_s, nth_e, Ng, level, blocks, option, ptree, msh, stats)
subroutine	d_bf_oneblock_rr (index_i, index_j, level, num_vect_sub, mm, nth, nth_s, blocks, BFvec, BFvec1, option, stats, norm_tol)
subroutine	d_bf_randomized_old (pgno_large, level_butterfly, rank0, rankrate, blocks_o, operand, blackbox_MVP_dat, error_inout, strings, option, stats, ptree, msh, operand1, uskip, vskip)
subroutine	d_bf_randomized (pgno_large, level_butterfly, rank0, rankrate, blocks_o, operand, blackbox_MVP_dat, error_inout, strings, option, stats, ptree, msh, operand1, uskip, vskip)
subroutine	d_bf_reconstruction_lowrank (block_rand, blocks_o, operand, blackbox_MVP_dat, operand1, option, stats, ptree, msh)
subroutine	d_pqxsvdtruncate (block_rand, matQ, matQcA_trans, rmax, rank, option, stats, ptree, tolerance_abs, flops)
subroutine	d_psvdtruncatesigma (block_rand, matQcA_trans, rmax, rank, Singular, option, stats, ptree, flops)
subroutine	d_bf_reconstruction_ll (block_rand, blocks_o, operand, blackbox_MVP_dat, operand1, option, stats, ptree, msh, levels, levele, vskip)
subroutine	d_bf_reconstruction_rr (block_rand, blocks_o, operand, blackbox_MVP_dat, operand1, option, stats, ptree, msh, levels, levele, uskip)
subroutine	d_bf_test_reconstruction_error (block_rand, block_o, operand, blackbox_MVP_dat, error, ptree, stats, operand1)
subroutine	d_bf_randomized_vectors_dat (side, block_rand, RandVectIn, RandVectOut, blocks_o, operand, blackbox_MVP_dat, nth_s, nth_e, num_vect_sub, unique_nth, ptree, msh, stats, operand1)
subroutine	d_bf_block_mvp_inverse_abcd_dat (partitioned_block, block_o, trans, M_loc, N_loc, num_vect_sub, Vinin, ldi, Voutout, ldo, a, b, ptree, stats, operand1)
subroutine	d_bf_block_mvp_inverse_a_minusbdinvc_dat (partitioned_block, block_o, trans, M, N, num_vect_sub, Vin, ldi, Vout, ldo, a, b, ptree, stats, operand1)
subroutine	d_bf_block_mvp_inverse_minusbc_dat (ho_bf1, block_o, trans, M, N, num_vect_sub, Vin, ldi, Vout, ldo, a, b, ptree, stats, operand1)
subroutine	d_bf_block_mvp_schulz_dat (schulz_op, block_Xn, trans, M, N, num_vect_sub, Vin, ldi, Vout, ldo, a, b, ptree, stats, operand1)
subroutine	d_bf_block_mvp_schulz_xn_dat (schulz_op, block_Xn, trans, M, N, num_vect_sub, Vin, ldi, Vout, ldo, a, b, ptree, stats, operand1)
subroutine	d_bf_block_mvp_sblock_dat (ho_bf1, block_o, trans, M, N, num_vect_sub, Vin, ldi, Vout, ldo, a, b, ptree, stats, msh)
subroutine	d_bf_block_mvp_sblock_sml_dat (ho_bf1, block_o, trans, M, N, num_vect_sub, Vin, ldi, Vout, ldo, a, b, ptree, stats, msh)
subroutine	d_bf_block_mvp_add_multiply_dat (h_mat, block_o, trans, M, N, num_vect_sub, Vin, ldi, Vout, ldo, a, b, ptree, stats, chara)
subroutine	d_bf_block_mvp_xlm_dat (blocks_l, block_o, trans, M, N, num_vect_sub, Vin, ldi, Vout, ldo, a, b, ptree, stats, operand1)
subroutine	d_bf_block_mvp_xum_dat (blocks_u, block_o, trans, M, N, num_vect_sub, Vin, ldi, Vout, ldo, a, b, ptree, stats, operand1)
subroutine	d_bplus_block_mvp_exact_dat (bplus, block_o, trans, M, N, num_vect_sub, Vin, ldi, Vout, ldo, a, b, ptree, stats, operand1)
subroutine	d_bplus_block_mvp_outter_exact_dat (bplus, block_o, trans, M, N, num_vect_sub, Vin, ldi, Vout, ldo, a, b, ptree, stats, operand1)
subroutine	d_bplus_block_mvp_minusbc_dat (ho_bf1, block_o, trans, M, N, num_vect_sub, Vin, ldi, Vout, ldo, a, b, ptree, stats, operand1)
subroutine	d_bplus_block_mvp_outter_minusbc_dat (ho_bf1, block_o, trans, M, N, num_vect_sub, Vin, ldi, Vout, ldo, a, b, ptree, stats, operand1)
subroutine	d_bplus_block_mvp_sblock_dat (ho_bf1, block_o, trans, M, N, num_vect_sub, Vin, ldi, Vout, ldo, a, b, ptree, stats, operand1)
subroutine	d_bplus_block_mvp_outter_sblock_dat (ho_bf1, block_o, trans, M, N, num_vect_sub, Vin, ldi, Vout, ldo, a, b, ptree, stats, operand1)
subroutine	d_bplus_block_mvp_inverse_dat (ho_bf1, level, ii, trans, N, num_vect_sub, Vin, ldi, Vout, ldo, ptree, stats)
subroutine	d_bplus_block_mvp_twoforward_dat (ho_bf1, level, ii, trans, N, num_vect_sub, Vin, ldi, Vout, ldo, a, b, ptree, stats)
subroutine	d_bf_block_mvp_twoforward_dat (ho_bf1, level, ii, block_rand, trans, N, num_vect_sub, Vin, ldi, Vout, ldo, a, b, ptree, stats)
subroutine	d_bplus_block_mvp_bplusb_dat (bplus, block_o, trans, M, N, num_vect_sub, Vin, ldi, Vout, ldo, a, b, ptree, stats, operand1)
subroutine	d_bplus_block_mvp_diagbinvb_dat (bplus, block_o, trans, M, N, num_vect_sub, Vin, ldi, Vout, ldo, a, b, ptree, stats, msh)
subroutine	d_bplus_block_mvp_diagbinvbhss_dat (bplus, block_o, trans, M, N, num_vect_sub, Vin, ldi, Vout, ldo, a, b, ptree, stats, msh)
subroutine	d_bplus_block_mvp_bbplus_dat (bplus, block_o, trans, M, N, num_vect_sub, Vin, ldi, Vout, ldo, a, b, ptree, stats, operand1)
subroutine	d_bplus_block_mvp_bdiagbinv_dat (bplus, block_o, trans, M, N, num_vect_sub, Vin, ldi, Vout, ldo, a, b, ptree, stats, msh)
subroutine	d_bplus_block_mvp_bdiagbinvhss_dat (bplus, block_o, trans, M, N, num_vect_sub, Vin, ldi, Vout, ldo, a, b, ptree, stats, msh)
subroutine	d_bplus_multilrandomized_onesubblock (rank0, rankrate, blocks, operand, blackbox_MVP_dat, error_inout, strings, option, stats, ptree, msh, operand1)
subroutine	d_bplus_randomized_constr (level_butterfly, bplus_o, operand, rank0_inner, rankrate_inner, blackbox_MVP_dat_inner, rank0_outter, rankrate_outter, blackbox_MVP_dat_outter, error_inout, strings, option, stats, ptree, msh)
subroutine	d_bplus_init_frominput (Bplus, Bplus_randomized, msh, ptree, option)

Function/Subroutine Documentation

d_bf_block_mvp_add_multiply_dat()

subroutine d_bplus_randomizedop::d_bf_block_mvp_add_multiply_dat	(	class(*)	h_mat,
		type(d_matrixblock)	block_o,
		character	trans,
		integer	M,
		integer	N,
		integer	num_vect_sub,
		real(kind=8), dimension(ldi, *)	Vin,
		integer	ldi,
		real(kind=8), dimension(ldo, *)	Vout,
		integer	ldo,
		real(kind=8)	a,
		real(kind=8)	b,
		type(d_proctree)	ptree,
		type(d_hstat)	stats,
		class(*), optional	chara
	)

Here is the call graph for this function:

d_bf_block_mvp_inverse_a_minusbdinvc_dat()

subroutine d_bplus_randomizedop::d_bf_block_mvp_inverse_a_minusbdinvc_dat	(	class(*)	partitioned_block,
		type(d_matrixblock)	block_o,
		character	trans,
		integer	M,
		integer	N,
		integer	num_vect_sub,
		real(kind=8), dimension(ldi, *)	Vin,
		integer	ldi,
		real(kind=8), dimension(ldo, *)	Vout,
		integer	ldo,
		real(kind=8)	a,
		real(kind=8)	b,
		type(d_proctree)	ptree,
		type(d_hstat)	stats,
		class(*), optional	operand1
	)

Here is the call graph for this function:

d_bf_block_mvp_inverse_abcd_dat()

subroutine d_bplus_randomizedop::d_bf_block_mvp_inverse_abcd_dat	(	class(*)	partitioned_block,
		type(d_matrixblock)	block_o,
		character	trans,
		integer	M_loc,
		integer	N_loc,
		integer	num_vect_sub,
		real(kind=8), dimension(ldi, *)	Vinin,
		integer	ldi,
		real(kind=8), dimension(ldo, *)	Voutout,
		integer	ldo,
		real(kind=8)	a,
		real(kind=8)	b,
		type(d_proctree)	ptree,
		type(d_hstat)	stats,
		class(*), optional	operand1
	)

Here is the call graph for this function:

d_bf_block_mvp_inverse_dat()

subroutine d_bplus_randomizedop::d_bf_block_mvp_inverse_dat	(	type(d_hobf)	ho_bf1,
		integer	level,
		integer	ii,
		character	trans,
		integer	N,
		integer	num_vect_sub,
		real(kind=8), dimension(ldi, *)	Vin,
		integer	ldi,
		real(kind=8), dimension(ldo, *)	Vout,
		integer	ldo,
		type(d_proctree)	ptree,
		type(d_hstat)	stats
	)

Here is the call graph for this function:

d_bf_block_mvp_inverse_minusbc_dat()

subroutine d_bplus_randomizedop::d_bf_block_mvp_inverse_minusbc_dat	(	class(*)	ho_bf1,
		type(d_matrixblock)	block_o,
		character	trans,
		integer	M,
		integer	N,
		integer	num_vect_sub,
		real(kind=8), dimension(ldi, *)	Vin,
		integer	ldi,
		real(kind=8), dimension(ldo, *)	Vout,
		integer	ldo,
		real(kind=8)	a,
		real(kind=8)	b,
		type(d_proctree)	ptree,
		type(d_hstat)	stats,
		class(*), optional	operand1
	)

d_bf_block_mvp_sblock_dat()

subroutine d_bplus_randomizedop::d_bf_block_mvp_sblock_dat	(	class(*)	ho_bf1,
		type(d_matrixblock)	block_o,
		character	trans,
		integer	M,
		integer	N,
		integer	num_vect_sub,
		real(kind=8), dimension(ldi, *)	Vin,
		integer	ldi,
		real(kind=8), dimension(ldo, *)	Vout,
		integer	ldo,
		real(kind=8)	a,
		real(kind=8)	b,
		type(d_proctree)	ptree,
		type(d_hstat)	stats,
		class(*), optional	msh
	)

Here is the call graph for this function:

d_bf_block_mvp_sblock_sml_dat()

subroutine d_bplus_randomizedop::d_bf_block_mvp_sblock_sml_dat	(	class(*)	ho_bf1,
		type(d_matrixblock)	block_o,
		character	trans,
		integer	M,
		integer	N,
		integer	num_vect_sub,
		real(kind=8), dimension(ldi, *)	Vin,
		integer	ldi,
		real(kind=8), dimension(ldo, *)	Vout,
		integer	ldo,
		real(kind=8)	a,
		real(kind=8)	b,
		type(d_proctree)	ptree,
		type(d_hstat)	stats,
		class(*), optional	msh
	)

Here is the call graph for this function:

d_bf_block_mvp_schulz_dat()

subroutine d_bplus_randomizedop::d_bf_block_mvp_schulz_dat	(	class(*)	schulz_op,
		type(d_matrixblock)	block_Xn,
		character	trans,
		integer	M,
		integer	N,
		integer	num_vect_sub,
		real(kind=8), dimension(ldi, *)	Vin,
		integer	ldi,
		real(kind=8), dimension(ldo, *)	Vout,
		integer	ldo,
		real(kind=8)	a,
		real(kind=8)	b,
		type(d_proctree)	ptree,
		type(d_hstat)	stats,
		class(*), optional	operand1
	)

Here is the call graph for this function:

d_bf_block_mvp_schulz_xn_dat()

subroutine d_bplus_randomizedop::d_bf_block_mvp_schulz_xn_dat	(	class(*)	schulz_op,
		type(d_matrixblock)	block_Xn,
		character	trans,
		integer	M,
		integer	N,
		integer	num_vect_sub,
		real(kind=8), dimension(ldi, *)	Vin,
		integer	ldi,
		real(kind=8), dimension(ldo, *)	Vout,
		integer	ldo,
		real(kind=8)	a,
		real(kind=8)	b,
		type(d_proctree)	ptree,
		type(d_hstat)	stats,
		class(*), optional	operand1
	)

d_bf_block_mvp_twoforward_dat()

subroutine d_bplus_randomizedop::d_bf_block_mvp_twoforward_dat	(	type(d_hobf)	ho_bf1,
		integer	level,
		integer	ii,
		type(d_matrixblock), dimension(:)	block_rand,
		character	trans,
		integer	N,
		integer	num_vect_sub,
		real(kind=8), dimension(ldi, *)	Vin,
		integer	ldi,
		real(kind=8), dimension(ldo, *)	Vout,
		integer	ldo,
		real(kind=8)	a,
		real(kind=8)	b,
		type(d_proctree)	ptree,
		type(d_hstat)	stats
	)

Here is the call graph for this function:

d_bf_block_mvp_xlm_dat()

subroutine d_bplus_randomizedop::d_bf_block_mvp_xlm_dat	(	class(*)	blocks_l,
		type(d_matrixblock)	block_o,
		character	trans,
		integer	M,
		integer	N,
		integer	num_vect_sub,
		real(kind=8), dimension(ldi, *)	Vin,
		integer	ldi,
		real(kind=8), dimension(ldo, *)	Vout,
		integer	ldo,
		real(kind=8)	a,
		real(kind=8)	b,
		type(d_proctree)	ptree,
		type(d_hstat)	stats,
		class(*), optional	operand1
	)

d_bf_block_mvp_xum_dat()

subroutine d_bplus_randomizedop::d_bf_block_mvp_xum_dat	(	class(*)	blocks_u,
		type(d_matrixblock)	block_o,
		character	trans,
		integer	M,
		integer	N,
		integer	num_vect_sub,
		real(kind=8), dimension(ldi, *)	Vin,
		integer	ldi,
		real(kind=8), dimension(ldo, *)	Vout,
		integer	ldo,
		real(kind=8)	a,
		real(kind=8)	b,
		type(d_proctree)	ptree,
		type(d_hstat)	stats,
		class(*), optional	operand1
	)

d_bf_delete_randvect()

subroutine d_bplus_randomizedop::d_bf_delete_randvect	(	character	chara,
		type(d_randomblock)	random,
		integer	level_butterfly
	)

d_bf_getnumvectestimate_ll()

subroutine d_bplus_randomizedop::d_bf_getnumvectestimate_ll	(	integer	num_vect,
		integer	nth_s,
		integer	nth_e,
		integer	Ng,
		integer	level,
		type(d_matrixblock)	blocks,
		type(d_hoption)	option,
		type(d_proctree)	ptree,
		type(d_mesh)	msh,
		type(d_hstat)	stats
	)

********* multiply BF^C with vectors to get the local block dimensions, this can be improved

********* get the rank upper bound

********* delete BFvecvec(level), note that all the other levels have already been deleted in d_BF_block_MVP_partial

Here is the call graph for this function:

d_bf_getnumvectestimate_rr()

subroutine d_bplus_randomizedop::d_bf_getnumvectestimate_rr	(	integer	num_vect,
		integer	nth_s,
		integer	nth_e,
		integer	Ng,
		integer	level,
		type(d_matrixblock)	blocks,
		type(d_hoption)	option,
		type(d_proctree)	ptree,
		type(d_mesh)	msh,
		type(d_hstat)	stats
	)

********* multiply BF with vectors to get the local block dimensions, this can be improved

********* multiply BF^C with vectors to get the local block dimensions, this can be improved

********* get the rank upper bound

********* delete BFvecvec(level_butterfly-level+1), note that all the other levels have already been deleted in d_BF_block_MVP_partial

Here is the call graph for this function:

d_bf_init_randomized()

subroutine d_bplus_randomizedop::d_bf_init_randomized	(	integer	level_butterfly,
		integer	rankmax,
		integer	groupm,
		integer	groupn,
		type(d_matrixblock)	block,
		type(d_matrixblock)	block_rand,
		type(d_mesh)	msh,
		type(d_proctree)	ptree,
		type(d_hoption)	option,
		integer	nodataflag
	)

****** ms and ns can be computed using msh if they are not precomputed

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

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

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

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

Here is the call graph for this function:

d_bf_oneblock_ll()

subroutine d_bplus_randomizedop::d_bf_oneblock_ll	(	integer	index_i,
		integer	index_j,
		integer	level,
		integer	num_vect_sub,
		integer	mm,
		integer	nth,
		integer	nth_s,
		type(d_matrixblock)	blocks,
		type(d_butterfly_vec)	BFvec,
		type(d_hoption)	option,
		type(d_hstat)	stats,
		real(kind=8), optional	norm_tol
	)

Here is the call graph for this function:

d_bf_oneblock_rr()

subroutine d_bplus_randomizedop::d_bf_oneblock_rr	(	integer	index_i,
		integer	index_j,
		integer	level,
		integer	num_vect_sub,
		integer	mm,
		integer	nth,
		integer	nth_s,
		type(d_matrixblock)	blocks,
		type(d_butterfly_vec)	BFvec,
		type(d_butterfly_vec)	BFvec1,
		type(d_hoption)	option,
		type(d_hstat)	stats,
		real(kind=8), optional	norm_tol
	)

Here is the call graph for this function:

d_bf_randomized()

subroutine d_bplus_randomizedop::d_bf_randomized	(	integer	pgno_large,
		integer	level_butterfly,
		integer	rank0,
		real(kind=8)	rankrate,
		type(d_matrixblock)	blocks_o,
		class(*)	operand,
		procedure(d_bmatvec)	blackbox_MVP_dat,
		real(kind=8)	error_inout,
		character(*)	strings,
		type(d_hoption)	option,
		type(d_hstat)	stats,
		type(d_proctree)	ptree,
		type(d_mesh)	msh,
		class(*), optional	operand1,
		logical, optional	uskip,
		logical, optional	vskip
	)

Here is the call graph for this function:

d_bf_randomized_old()

subroutine d_bplus_randomizedop::d_bf_randomized_old	(	integer	pgno_large,
		integer	level_butterfly,
		integer	rank0,
		real(kind=8)	rankrate,
		type(d_matrixblock)	blocks_o,
		class(*)	operand,
		procedure(d_bmatvec)	blackbox_MVP_dat,
		real(kind=8)	error_inout,
		character(*)	strings,
		type(d_hoption)	option,
		type(d_hstat)	stats,
		type(d_proctree)	ptree,
		type(d_mesh)	msh,
		class(*), optional	operand1,
		logical, optional	uskip,
		logical, optional	vskip
	)

Here is the call graph for this function:

d_bf_randomized_vectors_dat()

subroutine d_bplus_randomizedop::d_bf_randomized_vectors_dat	(	character	side,
		type(d_matrixblock)	block_rand,
		real(kind=8), dimension(:, :)	RandVectIn,
		real(kind=8), dimension(:, :)	RandVectOut,
		type(d_matrixblock)	blocks_o,
		class(*)	operand,
		procedure(d_bmatvec)	blackbox_MVP_dat,
		integer	nth_s,
		integer	nth_e,
		integer	num_vect_sub,
		integer	unique_nth,
		type(d_proctree)	ptree,
		type(d_mesh)	msh,
		type(d_hstat)	stats,
		class(*), optional	operand1
	)

Here is the call graph for this function:

d_bf_reconstruction_ll()

subroutine d_bplus_randomizedop::d_bf_reconstruction_ll	(	type(d_matrixblock)	block_rand,
		type(d_matrixblock)	blocks_o,
		class(*)	operand,
		procedure(d_bmatvec)	blackbox_MVP_dat,
		class(*), optional	operand1,
		type(d_hoption)	option,
		type(d_hstat)	stats,
		type(d_proctree)	ptree,
		type(d_mesh)	msh,
		integer	levels,
		integer	levele,
		logical, optional	vskip
	)

Here is the call graph for this function:

d_bf_reconstruction_lowrank()

subroutine d_bplus_randomizedop::d_bf_reconstruction_lowrank	(	type(d_matrixblock)	block_rand,
		type(d_matrixblock)	blocks_o,
		class(*)	operand,
		procedure(d_bmatvec)	blackbox_MVP_dat,
		class(*), optional	operand1,
		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_reconstruction_rr()

subroutine d_bplus_randomizedop::d_bf_reconstruction_rr	(	type(d_matrixblock)	block_rand,
		type(d_matrixblock)	blocks_o,
		class(*)	operand,
		procedure(d_bmatvec)	blackbox_MVP_dat,
		class(*), optional	operand1,
		type(d_hoption)	option,
		type(d_hstat)	stats,
		type(d_proctree)	ptree,
		type(d_mesh)	msh,
		integer	levels,
		integer	levele,
		logical, optional	uskip
	)

Here is the call graph for this function:

d_bf_resolving_butterfly_ll_dat()

subroutine d_bplus_randomizedop::d_bf_resolving_butterfly_ll_dat	(	integer	num_vect_sub,
		integer	nth_s,
		integer	nth_e,
		integer	Ng,
		integer	level,
		type(d_matrixblock)	blocks,
		real(kind=8), dimension(:, :)	RandVectIn,
		real(kind=8), dimension(:, :)	RandVectOut,
		type(d_hoption)	option,
		type(d_proctree)	ptree,
		type(d_mesh)	msh,
		type(d_hstat)	stats,
		real(kind=8), optional	norm_tol
	)

********* multiply BF^C with vectors

********* compute row spaces and reconstruct blocks at level level

********* delete BFvecvec(level), note that all the other levels have already been deleted in d_BF_block_MVP_partial

Here is the call graph for this function:

d_bf_resolving_butterfly_rr_dat()

subroutine d_bplus_randomizedop::d_bf_resolving_butterfly_rr_dat	(	integer	num_vect_sub,
		integer	nth_s,
		integer	nth_e,
		integer	Ng,
		integer	level,
		type(d_matrixblock)	blocks,
		real(kind=8), dimension(:, :)	RandVectIn,
		real(kind=8), dimension(:, :)	RandVectOut,
		type(d_hoption)	option,
		type(d_proctree)	ptree,
		type(d_mesh)	msh,
		type(d_hstat)	stats,
		real(kind=8), optional	norm_tol
	)

********* multiply BF^C with vectors

********* compute column spaces and reconstruct blocks at level level

********* delete BFvecvec(level_butterfly-level+1), note that all the other levels have already been deleted in d_BF_block_MVP_partial

********* delete BFvec1vec(level), note that all the other levels have already been deleted in d_BF_block_MVP_partial

Here is the call graph for this function:

d_bf_test_reconstruction_error()

subroutine d_bplus_randomizedop::d_bf_test_reconstruction_error	(	type(d_matrixblock)	block_rand,
		type(d_matrixblock)	block_o,
		class(*)	operand,
		procedure(d_bmatvec)	blackbox_MVP_dat,
		real(kind=8)	error,
		type(d_proctree)	ptree,
		type(d_hstat)	stats,
		class(*), optional	operand1
	)

Here is the call graph for this function:

d_bf_zero()

subroutine d_bplus_randomizedop::d_bf_zero	(	integer	level_butterfly,
		integer	groupm,
		integer	groupn,
		type(d_matrixblock)	block,
		type(d_matrixblock)	block_rand,
		type(d_mesh)	msh,
		type(d_proctree)	ptree,
		type(d_hoption)	option
	)

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

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

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

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

Here is the call graph for this function:

d_bplus_block_mvp_bbplus_dat()

subroutine d_bplus_randomizedop::d_bplus_block_mvp_bbplus_dat	(	class(*)	bplus,
		type(d_matrixblock)	block_o,
		character	trans,
		integer	M,
		integer	N,
		integer	num_vect_sub,
		real(kind=8), dimension(ldi, *)	Vin,
		integer	ldi,
		real(kind=8), dimension(ldo, *)	Vout,
		integer	ldo,
		real(kind=8)	a,
		real(kind=8)	b,
		type(d_proctree)	ptree,
		type(d_hstat)	stats,
		class(*), optional	operand1
	)

d_bplus_block_mvp_bdiagbinv_dat()

subroutine d_bplus_randomizedop::d_bplus_block_mvp_bdiagbinv_dat	(	class(*)	bplus,
		type(d_matrixblock)	block_o,
		character	trans,
		integer	M,
		integer	N,
		integer	num_vect_sub,
		real(kind=8), dimension(ldi, *)	Vin,
		integer	ldi,
		real(kind=8), dimension(ldo, *)	Vout,
		integer	ldo,
		real(kind=8)	a,
		real(kind=8)	b,
		type(d_proctree)	ptree,
		type(d_hstat)	stats,
		class(*), optional	msh
	)

Here is the call graph for this function:

d_bplus_block_mvp_bdiagbinvhss_dat()

subroutine d_bplus_randomizedop::d_bplus_block_mvp_bdiagbinvhss_dat	(	class(*)	bplus,
		type(d_matrixblock)	block_o,
		character	trans,
		integer	M,
		integer	N,
		integer	num_vect_sub,
		real(kind=8), dimension(ldi, *)	Vin,
		integer	ldi,
		real(kind=8), dimension(ldo, *)	Vout,
		integer	ldo,
		real(kind=8)	a,
		real(kind=8)	b,
		type(d_proctree)	ptree,
		type(d_hstat)	stats,
		class(*), optional	msh
	)

Here is the call graph for this function:

d_bplus_block_mvp_bplusb_dat()

subroutine d_bplus_randomizedop::d_bplus_block_mvp_bplusb_dat	(	class(*)	bplus,
		type(d_matrixblock)	block_o,
		character	trans,
		integer	M,
		integer	N,
		integer	num_vect_sub,
		real(kind=8), dimension(ldi, *)	Vin,
		integer	ldi,
		real(kind=8), dimension(ldo, *)	Vout,
		integer	ldo,
		real(kind=8)	a,
		real(kind=8)	b,
		type(d_proctree)	ptree,
		type(d_hstat)	stats,
		class(*), optional	operand1
	)

d_bplus_block_mvp_diagbinvb_dat()

subroutine d_bplus_randomizedop::d_bplus_block_mvp_diagbinvb_dat	(	class(*)	bplus,
		type(d_matrixblock)	block_o,
		character	trans,
		integer	M,
		integer	N,
		integer	num_vect_sub,
		real(kind=8), dimension(ldi, *)	Vin,
		integer	ldi,
		real(kind=8), dimension(ldo, *)	Vout,
		integer	ldo,
		real(kind=8)	a,
		real(kind=8)	b,
		type(d_proctree)	ptree,
		type(d_hstat)	stats,
		class(*), optional	msh
	)

Here is the call graph for this function:

d_bplus_block_mvp_diagbinvbhss_dat()

subroutine d_bplus_randomizedop::d_bplus_block_mvp_diagbinvbhss_dat	(	class(*)	bplus,
		type(d_matrixblock)	block_o,
		character	trans,
		integer	M,
		integer	N,
		integer	num_vect_sub,
		real(kind=8), dimension(ldi, *)	Vin,
		integer	ldi,
		real(kind=8), dimension(ldo, *)	Vout,
		integer	ldo,
		real(kind=8)	a,
		real(kind=8)	b,
		type(d_proctree)	ptree,
		type(d_hstat)	stats,
		class(*), optional	msh
	)

Here is the call graph for this function:

d_bplus_block_mvp_exact_dat()

subroutine d_bplus_randomizedop::d_bplus_block_mvp_exact_dat	(	class(*)	bplus,
		type(d_matrixblock)	block_o,
		character	trans,
		integer	M,
		integer	N,
		integer	num_vect_sub,
		real(kind=8), dimension(ldi, *)	Vin,
		integer	ldi,
		real(kind=8), dimension(ldo, *)	Vout,
		integer	ldo,
		real(kind=8)	a,
		real(kind=8)	b,
		type(d_proctree)	ptree,
		type(d_hstat)	stats,
		class(*), optional	operand1
	)

d_bplus_block_mvp_inverse_dat()

subroutine d_bplus_randomizedop::d_bplus_block_mvp_inverse_dat	(	type(d_hobf)	ho_bf1,
		integer	level,
		integer	ii,
		character	trans,
		integer	N,
		integer	num_vect_sub,
		real(kind=8), dimension(ldi, *)	Vin,
		integer	ldi,
		real(kind=8), dimension(ldo, *)	Vout,
		integer	ldo,
		type(d_proctree)	ptree,
		type(d_hstat)	stats
	)

Here is the call graph for this function:

d_bplus_block_mvp_minusbc_dat()

subroutine d_bplus_randomizedop::d_bplus_block_mvp_minusbc_dat	(	class(*)	ho_bf1,
		type(d_matrixblock)	block_o,
		character	trans,
		integer	M,
		integer	N,
		integer	num_vect_sub,
		real(kind=8), dimension(ldi, *)	Vin,
		integer	ldi,
		real(kind=8), dimension(ldo, *)	Vout,
		integer	ldo,
		real(kind=8)	a,
		real(kind=8)	b,
		type(d_proctree)	ptree,
		type(d_hstat)	stats,
		class(*), optional	operand1
	)

d_bplus_block_mvp_outter_exact_dat()

subroutine d_bplus_randomizedop::d_bplus_block_mvp_outter_exact_dat	(	class(*)	bplus,
		type(d_matrixblock)	block_o,
		character	trans,
		integer	M,
		integer	N,
		integer	num_vect_sub,
		real(kind=8), dimension(ldi, *)	Vin,
		integer	ldi,
		real(kind=8), dimension(ldo, *)	Vout,
		integer	ldo,
		real(kind=8)	a,
		real(kind=8)	b,
		type(d_proctree)	ptree,
		type(d_hstat)	stats,
		class(*), optional	operand1
	)

Here is the call graph for this function:

d_bplus_block_mvp_outter_minusbc_dat()

subroutine d_bplus_randomizedop::d_bplus_block_mvp_outter_minusbc_dat	(	class(*)	ho_bf1,
		type(d_matrixblock)	block_o,
		character	trans,
		integer	M,
		integer	N,
		integer	num_vect_sub,
		real(kind=8), dimension(ldi, *)	Vin,
		integer	ldi,
		real(kind=8), dimension(ldo, *)	Vout,
		integer	ldo,
		real(kind=8)	a,
		real(kind=8)	b,
		type(d_proctree)	ptree,
		type(d_hstat)	stats,
		class(*), optional	operand1
	)

Here is the call graph for this function:

d_bplus_block_mvp_outter_sblock_dat()

subroutine d_bplus_randomizedop::d_bplus_block_mvp_outter_sblock_dat	(	class(*)	ho_bf1,
		type(d_matrixblock)	block_o,
		character	trans,
		integer	M,
		integer	N,
		integer	num_vect_sub,
		real(kind=8), dimension(ldi, *)	Vin,
		integer	ldi,
		real(kind=8), dimension(ldo, *)	Vout,
		integer	ldo,
		real(kind=8)	a,
		real(kind=8)	b,
		type(d_proctree)	ptree,
		type(d_hstat)	stats,
		class(*), optional	operand1
	)

Here is the call graph for this function:

d_bplus_block_mvp_sblock_dat()

subroutine d_bplus_randomizedop::d_bplus_block_mvp_sblock_dat	(	class(*)	ho_bf1,
		type(d_matrixblock)	block_o,
		character	trans,
		integer	M,
		integer	N,
		integer	num_vect_sub,
		real(kind=8), dimension(ldi, *)	Vin,
		integer	ldi,
		real(kind=8), dimension(ldo, *)	Vout,
		integer	ldo,
		real(kind=8)	a,
		real(kind=8)	b,
		type(d_proctree)	ptree,
		type(d_hstat)	stats,
		class(*), optional	operand1
	)

Here is the call graph for this function:

d_bplus_block_mvp_twoforward_dat()

subroutine d_bplus_randomizedop::d_bplus_block_mvp_twoforward_dat	(	type(d_hobf)	ho_bf1,
		integer	level,
		integer	ii,
		character	trans,
		integer	N,
		integer	num_vect_sub,
		real(kind=8), dimension(ldi, *)	Vin,
		integer	ldi,
		real(kind=8), dimension(ldo, *)	Vout,
		integer	ldo,
		real(kind=8)	a,
		real(kind=8)	b,
		type(d_proctree)	ptree,
		type(d_hstat)	stats
	)

Here is the call graph for this function:

d_bplus_init_frominput()

subroutine d_bplus_randomizedop::d_bplus_init_frominput	(	type(d_blockplus)	Bplus,
		type(d_blockplus)	Bplus_randomized,
		type(d_mesh)	msh,
		type(d_proctree)	ptree,
		type(d_hoption)	option
	)

Here is the call graph for this function:

d_bplus_multilrandomized_onesubblock()

subroutine d_bplus_randomizedop::d_bplus_multilrandomized_onesubblock	(	integer	rank0,
		real(kind=8)	rankrate,
		type(d_matrixblock)	blocks,
		class(*)	operand,
		procedure(d_bmatvec)	blackbox_MVP_dat,
		real(kind=8)	error_inout,
		character(*)	strings,
		type(d_hoption)	option,
		type(d_hstat)	stats,
		type(d_proctree)	ptree,
		type(d_mesh)	msh,
		class(*), optional	operand1
	)

Here is the call graph for this function:

d_bplus_randomized_constr()

subroutine d_bplus_randomizedop::d_bplus_randomized_constr	(	integer	level_butterfly,
		type(d_blockplus)	bplus_o,
		class(*)	operand,
		integer	rank0_inner,
		real(kind=8)	rankrate_inner,
		procedure(d_bmatvec)	blackbox_MVP_dat_inner,
		integer	rank0_outter,
		real(kind=8)	rankrate_outter,
		procedure(d_bmatvec)	blackbox_MVP_dat_outter,
		real(kind=8)	error_inout,
		character(*)	strings,
		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_pqxsvdtruncate()

subroutine d_bplus_randomizedop::d_pqxsvdtruncate	(	type(d_matrixblock)	block_rand,
		real(kind=8), dimension(:, :)	matQ,
		real(kind=8), dimension(:, :)	matQcA_trans,
		integer	rmax,
		integer	rank,
		type(d_hoption)	option,
		type(d_hstat)	stats,
		type(d_proctree)	ptree,
		real(kind=8)	tolerance_abs,
		real(kind=8), optional	flops
	)

Here is the call graph for this function:

d_psvdtruncatesigma()

subroutine d_bplus_randomizedop::d_psvdtruncatesigma	(	type(d_matrixblock)	block_rand,
		real(kind=8), dimension(:, :)	matQcA_trans,
		integer	rmax,
		integer	rank,
		real(kind=8), dimension(:)	Singular,
		type(d_hoption)	option,
		type(d_hstat)	stats,
		type(d_proctree)	ptree,
		real(kind=8), optional	flops
	)

Here is the call graph for this function: