Functions/Subroutines
real(kind=8) function	d_seq_wtime ()

subroutine	d_linspacei (startI, endI, N, array)

subroutine	d_copysubmat_assumeshape (A, B, m, n, trans)

subroutine	d_copysubmat (A, ais, ajs, B, bis, bjs, m, n, trans)

subroutine	d_copymatt (A, B, m, n)

logical function	d_myisnan (a)

logical function	d_isnanmat (A, m, n)

subroutine	d_lr_recompression (matU, matV, Singular, M, N, rmax, rank, SVD_tolerance, Flops)

subroutine	d_lr_add (chara, U1, V1, U2, V2, rank1, rank2, ranknew, matU, matV, M, N, SVD_tolerance, flops)

subroutine	d_lr_add_aca (matU, matV, rankmax_r, rankmax_c, rmax, rank, tolerance, SVD_tolerance, error, flops)

subroutine	d_lr_fnormup (matU, matV, M, N, rskip, ruv, rup, ldV, normUV, normUVupdate, tolerance, Flops)

subroutine	d_lr_fnorm (matU, matV, M, N, rmax, norm, tolerance, Flops)

subroutine	d_getrank (M, N, mat, rank, eps, flop)

subroutine	d_pcomputerange (M_p, N, mat, rank, eps, ptree, pgno, Flops, norm_tol)

subroutine	d_computerange (M, N, mat, rank, rrflag, eps, Flops, norm_tol)

subroutine	d_checkrandomizedlr (M, N, mat, tolerance)

subroutine	d_rperm (N, p)

subroutine	d_init_random_seed ()

subroutine	d_random_dp_number (val)

complex(kind=8) function	d_c8_normal_01 (seed)

real(kind=8) function	d_r8_normal_01 (seed)

real(kind=8) function	d_r8_uniform_01 (seed)

subroutine	d_assert (statement, msg)

integer function	d_floor_safe (input)

integer function	d_ceiling_safe (input)

integer function	d_int_safe (input)

subroutine	d_cscalar (a, b, c)

subroutine	d_scalar (a, b, c)

subroutine	d_rrcurl (a, b, c)

subroutine	d_rccurl (a, b, c)

subroutine	d_cccurl (a, b, c)

subroutine	d_cscalar_sp (a, b, c)

subroutine	d_scalar_sp (a, b, c)

subroutine	d_rrcurl_sp (a, b, c)

subroutine	d_rccurl_sp (a, b, c)

subroutine	d_cccurl_sp (a, b, c)

real(kind=8) function	d_norm_vector (vector, n)

subroutine	d_linearsolve (m, n, k, A, b, x, eps_r, verbose, Flops)

subroutine	d_generalinverse (m, n, A, A_inv, eps_r, Flops)

subroutine	d_pgeneralinverse (m, n, A, A_inv, eps_r, ctxt, Flops)

subroutine	d_randomizedsvd (matRcol, matZRcol, matRrow, matZcRrow, matU, matV, Singular, rankmax_r, rankmax_c, rmax, rank, tolerance, SVD_tolerance, Flops)

subroutine	d_randomsubmat (ms, me, ns, ne, k, A, Oflag)

subroutine	d_randommat (m, n, k, A, Oflag)

subroutine	d_id_selection (Mat, select_column, select_row, m, n, rank, tolerance)

subroutine	d_aca_compressionfull (mat, matU, matV, rankmax_r, rankmax_c, rmax, rank, tolerance, SVD_tolerance)

recursive subroutine	d_rrqr_lq (mat, mm, nn, mn, UU, VV, tolerance, rank, lr, flops)

subroutine	d_svd_truncate (mat, mm, nn, mn, UU, VV, Singular, tolerance_rel, tolerance_abs, rank, flop)

subroutine	d_rrqr_svd (mat, mm, nn, mn, rmax, UU, VV, Singular, tolerance, rank, flop)

subroutine	d_psvd_truncate (mm, nn, mat, descMat, UU, VV, descUU, descVV, Singular, tolerance, rank, ctxt, tolerance_abs, flop)

subroutine	d_piksrt_dble_multi (N, M, ARR)

subroutine	d_piksrt_int_multi (N, M, ARR)

subroutine	d_remove_dup_int (array, nin, nout)
	*** remove the duplicates in an integer array More...

subroutine	d_binary_search (N, x, val, mid)

subroutine	quick_sort (d_list, order, n)

subroutine	quick_sort_int (d_list, order, n)

subroutine	d_cart2sph_loc (xin, yin, zin, origin, xunit, yunit, zunit, r, theta, phi)
	******* convert from a gloal Cartesian coordinate to a local Cartesian coordinate (origin, xunit, yunit, zunit) and then convert to the local spherial coordinate More...

subroutine	d_cart2sph (xin, yin, zin, origin, r, theta, phi)

complex(kind=8) function	d_hankel02_func (x)

real(kind=8) function	d_besselj0_func (x)

real(kind=8) function	d_bessely0_func (x)

subroutine	bessjyv (Nmax, x, sjv, bf)

subroutine	bessjy (x, xnu, rj)

subroutine	beschb (x, gam1, gam2, gampl, gammi)

real *8 function	chebev (a, b, c, x)

recursive subroutine	d_createleaf_natural (nlevel, level, group, idxs, idxe, treeleaf)
	**** create a array treeleaf holding size of each leaf box of a tree with nlevel levels (0<=level<=nlevel) More...

subroutine	d_numberingptree (ptree)

subroutine	d_getlocalblockrange (ptree, pgno, level, level_butterfly, idx_r, inc_r, nr, idx_c, inc_c, nc, dir)
	**** computation of the local butterfly block ranges owned by this MPI rank More...

subroutine	d_singleindextomultiindex (Ndim, dims, single_index_in, multi_index)
	**** convert single index to multi-index, assuming first index is the fastest More...

subroutine	d_multiindextosingleindex (Ndim, dims, single_index, multi_index)
	**** convert multi-index to single-index, assuming first index is the fastest More...

subroutine	d_getlocalblockrange_md (ptree, pgno, level, level_butterfly, ndim, dim_s, idx_r, inc_r, nr, idx_c, inc_c, nc, dir)
	**** computation of the local (multi-dimensinonal) butterfly block ranges owned by this MPI rank More...

subroutine	d_tensorunfoldingreshape (Ndim, dims_ref_old, dims_ref_new, offsets_ref, ld_old, ld_new, data_in, trans_in, data_out, trans_out, loopnew)

subroutine	d_getpgno_sub (ptree, pgno, level_butterfly, pgno_sub)
	**** computation of the sub process group that handles one block of the outtermost factor of a butterfly. Note: if level_butterfly=0, then pgno_sub=pgno More...

subroutine	d_getblockpid (ptree, pgno, level, level_butterfly, index_i, index_j, dir, pgno_sub)
	**** computation of the process group number "pgno_sub" that shares the (index_i,index_j,level) block. Note for blocks in the kernels, only the head process in pgno_sub is active; for blocks in the outtermost factors, all processes could be active More...

subroutine	d_getblockpid_md (ptree, pgno, ndim, dim_s, level, level_butterfly, index_i, index_j, dir, pgno_sub)
	**** computation of the process group number "pgno_sub" that shares the multi-dimensional (index_i(ndim),index_j(ndim),level) block. Note for blocks in the kernels, only the head process in pgno_sub is active; for blocks in the outtermost factors, all processes could be active More...

integer function	d_getmshgroup_pgno (ptree, ndim, group)
	**** get the pgno for the multi-dimensinoal group in msh. More...

subroutine	d_blacs_exit_wrp (flag)

subroutine	d_blacs_gridexit_wrp (ctxt)

subroutine	d_blacs_gridmap_wrp (ctxt, pmap, ldu, nprow, npcol)

integer function	d_sys2blacs_handle_wrp (comm)

subroutine	d_createptree (nmpi, groupmembers, MPI_Comm_base, ptree)

subroutine	d_redistribute1dto1d (dat_i, ldi, M_p_i, head_i, pgno_i, dat_o, ldo, M_p_o, head_o, pgno_o, N, ptree, addflag)

subroutine	d_redistribute1dto1d_onetotwo (dat_i, ldi, M_p_i, head_i, pgno_i, dat_o1, ldo1, M_p_o1, head_o1, pgno_o1, dat_o2, ldo2, M_p_o2, head_o2, pgno_o2, N, ptree)

subroutine	d_redistribute1dto1d_twotoone (dat_i1, ldi1, M_p_i1, head_i1, pgno_i1, dat_i2, ldi2, M_p_i2, head_i2, pgno_i2, dat_o, ldo, M_p_o, head_o, pgno_o, N, ptree)

subroutine	d_redistribute1dto2d (dat_i, M_p_i, head_i, pgno_i, dat_o, M, head_o, pgno_o, N, ptree)

subroutine	d_redistribute2dto1d (dat_i, M, head_i, pgno_i, dat_o, M_p_o, head_o, pgno_o, N, ptree)

subroutine	d_redistribute1dto1d_md (Ndim, dat_i, ldi, M_p_i, head_i, pgno_i, dat_o, ldo, M_p_o, head_o, pgno_o, N, ptree, addflag)

integer function	d_gettreelevel (gno)

logical function	d_iownpgrp (ptree, pgno)

integer function	d_lcm (a, b)

integer function	d_gcd (a, b)

integer function	d_blacs_pnum_wp (NPROW, NPCOL, PROW, PCOL)

subroutine	d_gridinfo_2d (pmap, MyID, myrow, mycol)

subroutine	d_array1dtopointer2d (x, p, n1, n2)

subroutine	d_logmemory (stats, mem)

subroutine	d_get_graph_colors_jp (rows, ia, ja, colors)

integer function	d_bit_reverse (n, bits)

Variables
integer, parameter	int64 = selected_int_kind(18)

Function/Subroutine Documentation

◆ beschb()

subroutine d_misc_utilities::beschb	(	real*8, intent(in)	x,
		real*8, intent(out)	gam1,
		real*8, intent(out)	gam2,
		real*8, intent(out)	gampl,
		real*8, intent(out)	gammi
	)

Here is the call graph for this function:

◆ bessjy()

subroutine d_misc_utilities::bessjy	(	real*8, intent(in)	x,
		real*8, intent(in)	xnu,
		real*8, intent(out)	rj
	)

Here is the call graph for this function:

◆ bessjyv()

subroutine d_misc_utilities::bessjyv	(	integer	Nmax,
		real*8	x,
		real*8, dimension(nmax+1)	sjv,
		integer	bf
	)

Here is the call graph for this function:

◆ chebev()

real*8 function d_misc_utilities::chebev	(	real*8, intent(in)	a,
		real*8, intent(in)	b,
		real*8, dimension(:), intent(in)	c,
		real*8, intent(in)	x
	)

Here is the call graph for this function:

◆ d_aca_compressionfull()

subroutine d_misc_utilities::d_aca_compressionfull	(	real(kind=8), dimension(rankmax_r, rankmax_c)	mat,
		real(kind=8), dimension(rankmax_r, rmax)	matU,
		real(kind=8), dimension(rmax, rankmax_c)	matV,
		integer	rankmax_r,
		integer	rankmax_c,
		integer	rmax,
		integer	rank,
		real(kind=8)	tolerance,
		real(kind=8)	SVD_tolerance
	)

Here is the call graph for this function:

◆ d_array1dtopointer2d()

subroutine d_misc_utilities::d_array1dtopointer2d	(	real(kind=8), dimension(n1, n2), target	x,
		real(kind=8), dimension(:,:), pointer	p,
		integer	n1,
		integer	n2
	)

◆ d_assert()

subroutine d_misc_utilities::d_assert	(	logical	statement,
		character(*)	msg
	)

◆ d_besselj0_func()

real(kind=8) function d_misc_utilities::d_besselj0_func ( real(kind=8) x )

◆ d_bessely0_func()

real(kind=8) function d_misc_utilities::d_bessely0_func ( real(kind=8) x )

Here is the call graph for this function:

◆ d_binary_search()

subroutine d_misc_utilities::d_binary_search	(	integer	N,
		integer, dimension(n)	x,
		integer	val,
		integer	mid
	)

◆ d_bit_reverse()

integer function d_misc_utilities::d_bit_reverse	(	integer, intent(in)	n,
		integer, intent(in)	bits
	)

◆ d_blacs_exit_wrp()

subroutine d_misc_utilities::d_blacs_exit_wrp ( integer flag )

◆ d_blacs_gridexit_wrp()

subroutine d_misc_utilities::d_blacs_gridexit_wrp ( integer ctxt )

◆ d_blacs_gridmap_wrp()

subroutine d_misc_utilities::d_blacs_gridmap_wrp	(	integer	ctxt,
		integer, dimension(:,:)	pmap,
		integer	ldu,
		integer	nprow,
		integer	npcol
	)

◆ d_blacs_pnum_wp()

integer function d_misc_utilities::d_blacs_pnum_wp	(	integer	NPROW,
		integer	NPCOL,
		integer	PROW,
		integer	PCOL
	)

◆ d_c8_normal_01()

complex(kind=8) function d_misc_utilities::d_c8_normal_01 ( integer(kind=4) seed )

*****************************************************************************80

Here is the call graph for this function:

◆ d_cart2sph()

subroutine d_misc_utilities::d_cart2sph	(	real(kind=8), intent(in)	xin,
		real(kind=8), intent(in)	yin,
		real(kind=8), intent(in)	zin,
		real(kind=8), dimension(3), intent(in)	origin,
		real(kind=8), intent(out)	r,
		real(kind=8), intent(out)	theta,
		real(kind=8), intent(out)	phi
	)

◆ d_cart2sph_loc()

subroutine d_misc_utilities::d_cart2sph_loc	(	real(kind=8), intent(in)	xin,
		real(kind=8), intent(in)	yin,
		real(kind=8), intent(in)	zin,
		real(kind=8), dimension(3), intent(in)	origin,
		real(kind=8), dimension(3), intent(in)	xunit,
		real(kind=8), dimension(3), intent(in)	yunit,
		real(kind=8), dimension(3), intent(in)	zunit,
		real(kind=8), intent(out)	r,
		real(kind=8), intent(out)	theta,
		real(kind=8), intent(out)	phi
	)

******* convert from a gloal Cartesian coordinate to a local Cartesian coordinate (origin, xunit, yunit, zunit) and then convert to the local spherial coordinate

Here is the call graph for this function:

◆ d_cccurl()

subroutine d_misc_utilities::d_cccurl	(	complex(kind=8), dimension(3)	a,
		complex(kind=8), dimension(3)	b,
		complex(kind=8), dimension(3)	c
	)

◆ d_cccurl_sp()

subroutine d_misc_utilities::d_cccurl_sp	(	complex(kind=4), dimension(3)	a,
		complex(kind=4), dimension(3)	b,
		complex(kind=4), dimension(3)	c
	)

◆ d_ceiling_safe()

integer function d_misc_utilities::d_ceiling_safe ( real(kind=8) input )

◆ d_checkrandomizedlr()

subroutine d_misc_utilities::d_checkrandomizedlr	(	integer	M,
		integer	N,
		real(kind=8), dimension(m, n)	mat,
		real(kind=8)	tolerance
	)

Here is the call graph for this function:

◆ d_computerange()

subroutine d_misc_utilities::d_computerange	(	integer	M,
		integer	N,
		real(kind=8), dimension(:, :)	mat,
		integer	rank,
		integer	rrflag,
		real(kind=8)	eps,
		real(kind=8), optional	Flops,
		real(kind=8), optional	norm_tol
	)

Here is the call graph for this function:

◆ d_copymatt()

subroutine d_misc_utilities::d_copymatt	(	real(kind=8), dimension(:, :)	A,
		real(kind=8), dimension(:, :)	B,
		integer	m,
		integer	n
	)

◆ d_copysubmat()

subroutine d_misc_utilities::d_copysubmat	(	real(kind=8), dimension(:, :)	A,
		integer	ais,
		integer	ajs,
		real(kind=8), dimension(:, :)	B,
		integer	bis,
		integer	bjs,
		integer	m,
		integer	n,
		character	trans
	)

◆ d_copysubmat_assumeshape()

subroutine d_misc_utilities::d_copysubmat_assumeshape	(	real(kind=8), dimension(m, n)	A,
		real(kind=8), dimension(m, n)	B,
		integer	m,
		integer	n,
		character	trans
	)

◆ d_createleaf_natural()

recursive subroutine d_misc_utilities::d_createleaf_natural	(	integer	nlevel,
		integer	level,
		integer	group,
		integer	idxs,
		integer	idxe,
		integer, dimension(2**nlevel)	treeleaf
	)

**** create a array treeleaf holding size of each leaf box of a tree with nlevel levels (0<=level<=nlevel)

◆ d_createptree()

subroutine d_misc_utilities::d_createptree	(	integer	nmpi,
		integer, dimension(nmpi)	groupmembers,
		integer	MPI_Comm_base,
		type(d_proctree)	ptree
	)

Here is the call graph for this function:

◆ d_cscalar()

subroutine d_misc_utilities::d_cscalar	(	complex(kind=8), dimension(3)	a,
		real(kind=8), dimension(3)	b,
		complex(kind=8)	c
	)

◆ d_cscalar_sp()

subroutine d_misc_utilities::d_cscalar_sp	(	complex(kind=4), dimension(3)	a,
		real(kind=4), dimension(3)	b,
		complex(kind=4)	c
	)

◆ d_floor_safe()

integer function d_misc_utilities::d_floor_safe ( real(kind=8) input )

◆ d_gcd()

integer function d_misc_utilities::d_gcd	(	integer	a,
		integer	b
	)

◆ d_generalinverse()

subroutine d_misc_utilities::d_generalinverse	(	integer	m,
		integer	n,
		real(kind=8), dimension(:, :)	A,
		real(kind=8), dimension(:, :)	A_inv,
		real(kind=8)	eps_r,
		real(kind=8), optional	Flops
	)

Here is the call graph for this function:

◆ d_get_graph_colors_jp()

subroutine d_misc_utilities::d_get_graph_colors_jp	(	integer	rows,
		integer, dimension(rows+1)	ia,
		integer, dimension(:)	ja,
		integer, dimension(rows)	colors
	)

Here is the call graph for this function:

◆ d_getblockpid()

subroutine d_misc_utilities::d_getblockpid	(	type(d_proctree)	ptree,
		integer	pgno,
		integer	level,
		integer	level_butterfly,
		integer	index_i,
		integer	index_j,
		character	dir,
		integer	pgno_sub
	)

**** computation of the process group number "pgno_sub" that shares the (index_i,index_j,level) block. Note for blocks in the kernels, only the head process in pgno_sub is active; for blocks in the outtermost factors, all processes could be active

Here is the call graph for this function:

◆ d_getblockpid_md()

subroutine d_misc_utilities::d_getblockpid_md	(	type(d_proctree)	ptree,
		integer	pgno,
		integer	ndim,
		integer	dim_s,
		integer	level,
		integer	level_butterfly,
		integer, dimension(ndim)	index_i,
		integer, dimension(ndim)	index_j,
		character	dir,
		integer	pgno_sub
	)

**** computation of the process group number "pgno_sub" that shares the multi-dimensional (index_i(ndim),index_j(ndim),level) block. Note for blocks in the kernels, only the head process in pgno_sub is active; for blocks in the outtermost factors, all processes could be active

Here is the call graph for this function:

◆ d_getlocalblockrange()

subroutine d_misc_utilities::d_getlocalblockrange	(	type(d_proctree)	ptree,
		integer	pgno,
		integer	level,
		integer	level_butterfly,
		integer	idx_r,
		integer	inc_r,
		integer	nr,
		integer	idx_c,
		integer	inc_c,
		integer	nc,
		character	dir
	)

**** computation of the local butterfly block ranges owned by this MPI rank

Here is the call graph for this function:

◆ d_getlocalblockrange_md()

subroutine d_misc_utilities::d_getlocalblockrange_md	(	type(d_proctree)	ptree,
		integer	pgno,
		integer	level,
		integer	level_butterfly,
		integer	ndim,
		integer	dim_s,
		integer, dimension(ndim)	idx_r,
		integer, dimension(ndim)	inc_r,
		integer, dimension(ndim)	nr,
		integer, dimension(ndim)	idx_c,
		integer, dimension(ndim)	inc_c,
		integer, dimension(ndim)	nc,
		character	dir
	)

**** computation of the local (multi-dimensinonal) butterfly block ranges owned by this MPI rank

Here is the call graph for this function:

◆ d_getmshgroup_pgno()

integer function d_misc_utilities::d_getmshgroup_pgno	(	type(d_proctree)	ptree,
		integer	ndim,
		integer, dimension(*)	group
	)

**** get the pgno for the multi-dimensinoal group in msh.

Here is the call graph for this function:

◆ d_getpgno_sub()

subroutine d_misc_utilities::d_getpgno_sub	(	type(d_proctree)	ptree,
		integer	pgno,
		integer	level_butterfly,
		integer	pgno_sub
	)

**** computation of the sub process group that handles one block of the outtermost factor of a butterfly. Note: if level_butterfly=0, then pgno_sub=pgno

Here is the call graph for this function:

◆ d_getrank()

subroutine d_misc_utilities::d_getrank	(	integer	M,
		integer	N,
		real(kind=8), dimension(:, :)	mat,
		integer	rank,
		real(kind=8)	eps,
		real(kind=8), optional	flop
	)

Here is the call graph for this function:

◆ d_gettreelevel()

integer function d_misc_utilities::d_gettreelevel ( integer gno )

◆ d_gridinfo_2d()

subroutine d_misc_utilities::d_gridinfo_2d	(	integer, dimension(3)	pmap,
		integer	MyID,
		integer	myrow,
		integer	mycol
	)

◆ d_hankel02_func()

complex(kind=8) function d_misc_utilities::d_hankel02_func ( real(kind=8) x )

Here is the call graph for this function:

◆ d_id_selection()

subroutine d_misc_utilities::d_id_selection	(	real(kind=8), dimension(m, n)	Mat,
		integer, dimension(n)	select_column,
		integer, dimension(m)	select_row,
		integer	m,
		integer	n,
		integer	rank,
		real(kind=8)	tolerance
	)

Here is the call graph for this function:

◆ d_init_random_seed()

subroutine d_misc_utilities::d_init_random_seed ( )

Here is the call graph for this function:

◆ d_int_safe()

integer function d_misc_utilities::d_int_safe ( real(kind=8) input )

◆ d_iownpgrp()

logical function d_misc_utilities::d_iownpgrp	(	type(d_proctree)	ptree,
		integer	pgno
	)

◆ d_isnanmat()

logical function d_misc_utilities::d_isnanmat	(	real(kind=8), dimension(:, :)	A,
		integer	m,
		integer	n
	)

Here is the call graph for this function:

◆ d_lcm()

integer function d_misc_utilities::d_lcm	(	integer	a,
		integer	b
	)

Here is the call graph for this function:

◆ d_linearsolve()

subroutine d_misc_utilities::d_linearsolve	(	integer	m,
		integer	n,
		integer	k,
		real(kind=8), dimension(m, n)	A,
		real(kind=8), dimension(m, k)	b,
		real(kind=8), dimension(n, k)	x,
		real(kind=8)	eps_r,
		integer	verbose,
		real(kind=8), optional	Flops
	)

Here is the call graph for this function:

◆ d_linspacei()

subroutine d_misc_utilities::d_linspacei	(	integer	startI,
		integer	endI,
		integer	N,
		integer, dimension(1:n)	array
	)

◆ d_logmemory()

subroutine d_misc_utilities::d_logmemory	(	type(d_hstat)	stats,
		real(kind=8)	mem
	)

◆ d_lr_add()

subroutine d_misc_utilities::d_lr_add	(	character	chara,
		real(kind=8), dimension(m,rank1)	U1,
		real(kind=8), dimension(n,rank1)	V1,
		real(kind=8), dimension(m,rank2)	U2,
		real(kind=8), dimension(n,rank2)	V2,
		integer	rank1,
		integer	rank2,
		integer	ranknew,
		real(kind=8), dimension(m,rank1+rank2)	matU,
		real(kind=8), dimension(rank1+rank2,n)	matV,
		integer	M,
		integer	N,
		real(kind=8)	SVD_tolerance,
		real(kind=8), optional	flops
	)

Here is the call graph for this function:

◆ d_lr_add_aca()

subroutine d_misc_utilities::d_lr_add_aca	(	real(kind=8), dimension(rankmax_r, rmax)	matU,
		real(kind=8), dimension(rmax, rankmax_c)	matV,
		integer	rankmax_r,
		integer	rankmax_c,
		integer	rmax,
		integer	rank,
		real(kind=8)	tolerance,
		real(kind=8)	SVD_tolerance,
		real(kind=8)	error,
		real(kind=8), optional	flops
	)

Here is the call graph for this function:

◆ d_lr_fnorm()

subroutine d_misc_utilities::d_lr_fnorm	(	real(kind=8), dimension(:, :)	matU,
		real(kind=8), dimension(:, :)	matV,
		integer	M,
		integer	N,
		integer	rmax,
		real(kind=8)	norm,
		real(kind=8)	tolerance,
		real(kind=8), optional	Flops
	)

Here is the call graph for this function:

◆ d_lr_fnormup()

subroutine d_misc_utilities::d_lr_fnormup	(	real(kind=8), dimension(:, :)	matU,
		real(kind=8), dimension(:, :)	matV,
		integer	M,
		integer	N,
		integer	rskip,
		integer	ruv,
		integer	rup,
		integer	ldV,
		real(kind=8)	normUV,
		real(kind=8)	normUVupdate,
		real(kind=8)	tolerance,
		real(kind=8), optional	Flops
	)

◆ d_lr_recompression()

subroutine d_misc_utilities::d_lr_recompression	(	real(kind=8), dimension(:, :)	matU,
		real(kind=8), dimension(:, :)	matV,
		real(kind=8), dimension(:)	Singular,
		integer	M,
		integer	N,
		integer	rmax,
		integer	rank,
		real(kind=8)	SVD_tolerance,
		real(kind=8), optional	Flops
	)

Here is the call graph for this function:

◆ d_multiindextosingleindex()

subroutine d_misc_utilities::d_multiindextosingleindex	(	integer	Ndim,
		integer, dimension(ndim)	dims,
		integer	single_index,
		integer, dimension(ndim)	multi_index
	)

**** convert multi-index to single-index, assuming first index is the fastest

Here is the call graph for this function:

◆ d_myisnan()

logical function d_misc_utilities::d_myisnan ( real(kind=8) a )

◆ d_norm_vector()

real(kind=8) function d_misc_utilities::d_norm_vector	(	real(kind=8), dimension(n)	vector,
		integer	n
	)

◆ d_numberingptree()

subroutine d_misc_utilities::d_numberingptree ( type(d_proctree) ptree )

◆ d_pcomputerange()

subroutine d_misc_utilities::d_pcomputerange	(	integer, dimension(:, :)	M_p,
		integer	N,
		real(kind=8), dimension(:, :)	mat,
		integer	rank,
		real(kind=8)	eps,
		type(d_proctree)	ptree,
		integer	pgno,
		real(kind=8), optional	Flops,
		real(kind=8), optional	norm_tol
	)

Here is the call graph for this function:

◆ d_pgeneralinverse()

subroutine d_misc_utilities::d_pgeneralinverse	(	integer	m,
		integer	n,
		real(kind=8), dimension(:,:)	A,
		real(kind=8), dimension(:,:)	A_inv,
		real(kind=8)	eps_r,
		integer	ctxt,
		real(kind=8), optional	Flops
	)

Here is the call graph for this function:

◆ d_piksrt_dble_multi()

subroutine d_misc_utilities::d_piksrt_dble_multi	(	integer	N,
		integer	M,
		real(kind=8), dimension(n, m)	ARR
	)

◆ d_piksrt_int_multi()

subroutine d_misc_utilities::d_piksrt_int_multi	(	integer	N,
		integer	M,
		integer, dimension(n, m)	ARR
	)

◆ d_psvd_truncate()

subroutine d_misc_utilities::d_psvd_truncate	(	integer	mm,
		integer	nn,
		real(kind=8), dimension(:, :)	mat,
		integer, dimension(9)	descMat,
		real(kind=8), dimension(:, :)	UU,
		real(kind=8), dimension(:, :)	VV,
		integer, dimension(9)	descUU,
		integer, dimension(9)	descVV,
		real(kind=8), dimension(:)	Singular,
		real(kind=8)	tolerance,
		integer	rank,
		integer	ctxt,
		real(kind=8)	tolerance_abs,
		real(kind=8), optional	flop
	)

Here is the call graph for this function:

◆ d_r8_normal_01()

real(kind=8) function d_misc_utilities::d_r8_normal_01 ( integer(kind=4) seed )

*****************************************************************************80

Here is the call graph for this function:

◆ d_r8_uniform_01()

real(kind=8) function d_misc_utilities::d_r8_uniform_01 ( integer(kind=4) seed )

*****************************************************************************80

◆ d_random_dp_number()

subroutine d_misc_utilities::d_random_dp_number ( real(kind=8) val )

◆ d_randomizedsvd()

subroutine d_misc_utilities::d_randomizedsvd	(	real(kind=8), dimension(rankmax_c, rmax)	matRcol,
		real(kind=8), dimension(rankmax_r, rmax)	matZRcol,
		real(kind=8), dimension(rankmax_r, rmax)	matRrow,
		real(kind=8), dimension(rankmax_c, rmax)	matZcRrow,
		real(kind=8), dimension(rankmax_r, rmax)	matU,
		real(kind=8), dimension(rmax, rankmax_c)	matV,
		real(kind=8), dimension(rmax)	Singular,
		integer	rankmax_r,
		integer	rankmax_c,
		integer	rmax,
		integer	rank,
		real(kind=8)	tolerance,
		real(kind=8)	SVD_tolerance,
		real(kind=8), optional	Flops
	)

Here is the call graph for this function:

◆ d_randommat()

subroutine d_misc_utilities::d_randommat	(	integer	m,
		integer	n,
		integer	k,
		real(kind=8), dimension(:, :)	A,
		integer	Oflag
	)

Here is the call graph for this function:

◆ d_randomsubmat()

subroutine d_misc_utilities::d_randomsubmat	(	integer	ms,
		integer	me,
		integer	ns,
		integer	ne,
		integer	k,
		real(kind=8), dimension(:, :)	A,
		integer	Oflag
	)

Here is the call graph for this function:

◆ d_rccurl()

subroutine d_misc_utilities::d_rccurl	(	real(kind=8), dimension(3)	a,
		complex(kind=8), dimension(3)	b,
		complex(kind=8), dimension(3)	c
	)

◆ d_rccurl_sp()

subroutine d_misc_utilities::d_rccurl_sp	(	real(kind=4), dimension(3)	a,
		complex(kind=4), dimension(3)	b,
		complex(kind=4), dimension(3)	c
	)

◆ d_redistribute1dto1d()

subroutine d_misc_utilities::d_redistribute1dto1d	(	real(kind=8), dimension(ldi, *)	dat_i,
		integer	ldi,
		integer, dimension(:, :)	M_p_i,
		integer	head_i,
		integer	pgno_i,
		real(kind=8), dimension(ldo, *)	dat_o,
		integer	ldo,
		integer, dimension(:, :)	M_p_o,
		integer	head_o,
		integer	pgno_o,
		integer	N,
		type(d_proctree)	ptree,
		integer, optional	addflag
	)

Here is the call graph for this function:

◆ d_redistribute1dto1d_md()

subroutine d_misc_utilities::d_redistribute1dto1d_md	(	integer	Ndim,
		real(kind=8), dimension(product(ldi), *)	dat_i,
		integer, dimension(ndim)	ldi,
		integer, dimension(:, :, :)	M_p_i,
		integer, dimension(ndim)	head_i,
		integer	pgno_i,
		real(kind=8), dimension(product(ldo), *)	dat_o,
		integer, dimension(ndim)	ldo,
		integer, dimension(:, :, :)	M_p_o,
		integer, dimension(ndim)	head_o,
		integer	pgno_o,
		integer	N,
		type(d_proctree)	ptree,
		integer, optional	addflag
	)

Here is the call graph for this function:

◆ d_redistribute1dto1d_onetotwo()

subroutine d_misc_utilities::d_redistribute1dto1d_onetotwo	(	real(kind=8), dimension(ldi, *)	dat_i,
		integer	ldi,
		integer, dimension(:, :)	M_p_i,
		integer	head_i,
		integer	pgno_i,
		real(kind=8), dimension(ldo1, *)	dat_o1,
		integer	ldo1,
		integer, dimension(:, :)	M_p_o1,
		integer	head_o1,
		integer	pgno_o1,
		real(kind=8), dimension(ldo2, *)	dat_o2,
		integer	ldo2,
		integer, dimension(:, :)	M_p_o2,
		integer	head_o2,
		integer	pgno_o2,
		integer	N,
		type(d_proctree)	ptree
	)

Here is the call graph for this function:

◆ d_redistribute1dto1d_twotoone()

subroutine d_misc_utilities::d_redistribute1dto1d_twotoone	(	real(kind=8), dimension(ldi1, *)	dat_i1,
		integer	ldi1,
		integer, dimension(:, :)	M_p_i1,
		integer	head_i1,
		integer	pgno_i1,
		real(kind=8), dimension(ldi2, *)	dat_i2,
		integer	ldi2,
		integer, dimension(:, :)	M_p_i2,
		integer	head_i2,
		integer	pgno_i2,
		real(kind=8), dimension(ldo, *)	dat_o,
		integer	ldo,
		integer, dimension(:, :)	M_p_o,
		integer	head_o,
		integer	pgno_o,
		integer	N,
		type(d_proctree)	ptree
	)

Here is the call graph for this function:

◆ d_redistribute1dto2d()

subroutine d_misc_utilities::d_redistribute1dto2d	(	real(kind=8), dimension(:, :)	dat_i,
		integer, dimension(:, :)	M_p_i,
		integer	head_i,
		integer	pgno_i,
		real(kind=8), dimension(:, :)	dat_o,
		integer	M,
		integer	head_o,
		integer	pgno_o,
		integer	N,
		type(d_proctree)	ptree
	)

Here is the call graph for this function:

◆ d_redistribute2dto1d()

subroutine d_misc_utilities::d_redistribute2dto1d	(	real(kind=8), dimension(:, :)	dat_i,
		integer	M,
		integer	head_i,
		integer	pgno_i,
		real(kind=8), dimension(:, :)	dat_o,
		integer, dimension(:, :)	M_p_o,
		integer	head_o,
		integer	pgno_o,
		integer	N,
		type(d_proctree)	ptree
	)

Here is the call graph for this function:

◆ d_remove_dup_int()

subroutine d_misc_utilities::d_remove_dup_int	(	integer, dimension(nin)	array,
		integer	nin,
		integer	nout
	)

*** remove the duplicates in an integer array

Here is the call graph for this function:

◆ d_rperm()

subroutine d_misc_utilities::d_rperm	(	integer, intent(in)	N,
		integer, dimension(n)	p
	)

Here is the call graph for this function:

◆ d_rrcurl()

subroutine d_misc_utilities::d_rrcurl	(	real(kind=8), dimension(3)	a,
		real(kind=8), dimension(3)	b,
		real(kind=8), dimension(3)	c
	)

◆ d_rrcurl_sp()

subroutine d_misc_utilities::d_rrcurl_sp	(	real(kind=4), dimension(3)	a,
		real(kind=4), dimension(3)	b,
		real(kind=4), dimension(3)	c
	)

◆ d_rrqr_lq()

recursive subroutine d_misc_utilities::d_rrqr_lq	(	real(kind=8), dimension(mm, nn)	mat,
		integer	mm,
		integer	nn,
		integer	mn,
		real(kind=8), dimension(mm, mn)	UU,
		real(kind=8), dimension(mn, nn)	VV,
		real(kind=8)	tolerance,
		integer	rank,
		character	lr,
		real(kind=8), optional	flops
	)

Here is the call graph for this function:

◆ d_rrqr_svd()

subroutine d_misc_utilities::d_rrqr_svd	(	real(kind=8), dimension(mm, nn)	mat,
		integer	mm,
		integer	nn,
		integer	mn,
		integer	rmax,
		real(kind=8), dimension(mm, rmax)	UU,
		real(kind=8), dimension(rmax, nn)	VV,
		real(kind=8), dimension(rmax)	Singular,
		real(kind=8)	tolerance,
		integer	rank,
		real(kind=8), optional	flop
	)

Here is the call graph for this function:

◆ d_scalar()

subroutine d_misc_utilities::d_scalar	(	real(kind=8), dimension(3)	a,
		real(kind=8), dimension(3)	b,
		real(kind=8)	c
	)

◆ d_scalar_sp()

subroutine d_misc_utilities::d_scalar_sp	(	real(kind=4), dimension(3)	a,
		real(kind=4), dimension(3)	b,
		real(kind=4)	c
	)

◆ d_seq_wtime()

real ( kind = 8 ) function d_misc_utilities::d_seq_wtime ( )

◆ d_singleindextomultiindex()

subroutine d_misc_utilities::d_singleindextomultiindex	(	integer	Ndim,
		integer, dimension(ndim)	dims,
		integer	single_index_in,
		integer, dimension(ndim)	multi_index
	)

**** convert single index to multi-index, assuming first index is the fastest

Here is the call graph for this function:

◆ d_svd_truncate()

subroutine d_misc_utilities::d_svd_truncate	(	real(kind=8), dimension(mm, nn)	mat,
		integer	mm,
		integer	nn,
		integer	mn,
		real(kind=8), dimension(mm, mn)	UU,
		real(kind=8), dimension(mn, nn)	VV,
		real(kind=8), dimension(mn)	Singular,
		real(kind=8)	tolerance_rel,
		real(kind=8)	tolerance_abs,
		integer	rank,
		real(kind=8), optional	flop
	)

Here is the call graph for this function:

◆ d_sys2blacs_handle_wrp()

integer function d_misc_utilities::d_sys2blacs_handle_wrp ( integer comm )

◆ d_tensorunfoldingreshape()

subroutine d_misc_utilities::d_tensorunfoldingreshape	(	integer	Ndim,
		integer, dimension(ndim)	dims_ref_old,
		integer, dimension(ndim)	dims_ref_new,
		integer, dimension(ndim)	offsets_ref,
		integer	ld_old,
		integer	ld_new,
		real(kind=8), dimension(:,:)	data_in,
		character	trans_in,
		real(kind=8), dimension(:,:), allocatable	data_out,
		character	trans_out,
		integer	loopnew
	)

Here is the call graph for this function:

◆ quick_sort()

subroutine d_misc_utilities::quick_sort	(	real(kind=8), dimension(n)	d_list,
		integer, dimension(n)	order,
		integer	n
	)

Here is the call graph for this function:

◆ quick_sort_int()

subroutine d_misc_utilities::quick_sort_int	(	integer, dimension(n)	d_list,
		integer, dimension(n)	order,
		integer	n
	)

Here is the call graph for this function:

Variable Documentation

◆ int64

integer, parameter d_misc_utilities::int64 = selected_int_kind(18)

Functions/Subroutines

Variables

Function/Subroutine Documentation

◆ beschb()

◆ bessjy()

◆ bessjyv()

◆ chebev()

◆ d_aca_compressionfull()

◆ d_array1dtopointer2d()

◆ d_assert()

◆ d_besselj0_func()

◆ d_bessely0_func()

◆ d_binary_search()

◆ d_bit_reverse()

◆ d_blacs_exit_wrp()

◆ d_blacs_gridexit_wrp()

◆ d_blacs_gridmap_wrp()

◆ d_blacs_pnum_wp()

◆ d_c8_normal_01()

◆ d_cart2sph()

◆ d_cart2sph_loc()

◆ d_cccurl()

◆ d_cccurl_sp()

◆ d_ceiling_safe()

◆ d_checkrandomizedlr()

◆ d_computerange()

◆ d_copymatt()

◆ d_copysubmat()

◆ d_copysubmat_assumeshape()

◆ d_createleaf_natural()

◆ d_createptree()

◆ d_cscalar()

◆ d_cscalar_sp()

◆ d_floor_safe()

◆ d_gcd()

◆ d_generalinverse()

◆ d_get_graph_colors_jp()

◆ d_getblockpid()

◆ d_getblockpid_md()

◆ d_getlocalblockrange()

◆ d_getlocalblockrange_md()

◆ d_getmshgroup_pgno()

◆ d_getpgno_sub()

◆ d_getrank()

◆ d_gettreelevel()

◆ d_gridinfo_2d()

◆ d_hankel02_func()

◆ d_id_selection()

◆ d_init_random_seed()

◆ d_int_safe()

◆ d_iownpgrp()

◆ d_isnanmat()

◆ d_lcm()

◆ d_linearsolve()

◆ d_linspacei()

◆ d_logmemory()

◆ d_lr_add()

◆ d_lr_add_aca()

◆ d_lr_fnorm()

◆ d_lr_fnormup()

◆ d_lr_recompression()

◆ d_multiindextosingleindex()

◆ d_myisnan()

◆ d_norm_vector()

◆ d_numberingptree()

◆ d_pcomputerange()

◆ d_pgeneralinverse()

◆ d_piksrt_dble_multi()

◆ d_piksrt_int_multi()

◆ d_psvd_truncate()

◆ d_r8_normal_01()

◆ d_r8_uniform_01()

◆ d_random_dp_number()

◆ d_randomizedsvd()

◆ d_randommat()

◆ d_randomsubmat()

◆ d_rccurl()

◆ d_rccurl_sp()

◆ d_redistribute1dto1d()

◆ d_redistribute1dto1d_md()