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

subroutine	s_linspacei (startI, endI, N, array)

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

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

subroutine	s_copymatt (A, B, m, n)

logical function	s_myisnan (a)

logical function	s_isnanmat (A, m, n)

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

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

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

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

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

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

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

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

subroutine	s_checkrandomizedlr (M, N, mat, tolerance)

subroutine	s_rperm (N, p)

subroutine	s_init_random_seed ()

subroutine	s_random_dp_number (val)

complex(kind=8) function	s_c8_normal_01 (seed)

real(kind=8) function	s_r8_normal_01 (seed)

real(kind=8) function	s_r8_uniform_01 (seed)

subroutine	s_assert (statement, msg)

integer function	s_floor_safe (input)

integer function	s_ceiling_safe (input)

integer function	s_int_safe (input)

subroutine	s_cscalar (a, b, c)

subroutine	s_scalar (a, b, c)

subroutine	s_rrcurl (a, b, c)

subroutine	s_rccurl (a, b, c)

subroutine	s_cccurl (a, b, c)

subroutine	s_cscalar_sp (a, b, c)

subroutine	s_scalar_sp (a, b, c)

subroutine	s_rrcurl_sp (a, b, c)

subroutine	s_rccurl_sp (a, b, c)

subroutine	s_cccurl_sp (a, b, c)

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

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

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

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

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

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

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

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

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

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

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

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

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

subroutine	s_piksrt_dble_multi (N, M, ARR)

subroutine	s_piksrt_int_multi (N, M, ARR)

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

subroutine	s_binary_search (N, x, val, mid)

subroutine	quick_sort (s_list, order, n)

subroutine	quick_sort_int (s_list, order, n)

subroutine	s_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	s_cart2sph (xin, yin, zin, origin, r, theta, phi)

complex(kind=8) function	s_hankel02_func (x)

real(kind=8) function	s_besselj0_func (x)

real(kind=8) function	s_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	s_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	s_numberingptree (ptree)

subroutine	s_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	s_singleindextomultiindex (Ndim, dims, single_index_in, multi_index)
	**** convert single index to multi-index, assuming first index is the fastest More...

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

subroutine	s_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	s_tensorunfoldingreshape (Ndim, dims_ref_old, dims_ref_new, offsets_ref, ld_old, ld_new, data_in, trans_in, data_out, trans_out, loopnew)

subroutine	s_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	s_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	s_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	s_getmshgroup_pgno (ptree, ndim, group)
	**** get the pgno for the multi-dimensinoal group in msh. More...

subroutine	s_blacs_exit_wrp (flag)

subroutine	s_blacs_gridexit_wrp (ctxt)

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

integer function	s_sys2blacs_handle_wrp (comm)

subroutine	s_createptree (nmpi, groupmembers, MPI_Comm_base, ptree)

subroutine	s_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	s_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	s_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	s_redistribute1dto2d (dat_i, M_p_i, head_i, pgno_i, dat_o, M, head_o, pgno_o, N, ptree)

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

subroutine	s_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	s_gettreelevel (gno)

logical function	s_iownpgrp (ptree, pgno)

integer function	s_lcm (a, b)

integer function	s_gcd (a, b)

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

subroutine	s_gridinfo_2d (pmap, MyID, myrow, mycol)

subroutine	s_array1dtopointer2d (x, p, n1, n2)

subroutine	s_logmemory (stats, mem)

subroutine	s_get_graph_colors_jp (rows, ia, ja, colors)

integer function	s_bit_reverse (n, bits)

Variables
integer, parameter	int64 = selected_int_kind(18)

Function/Subroutine Documentation

◆ beschb()

subroutine s_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 s_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 s_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 s_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:

◆ quick_sort()

subroutine s_misc_utilities::quick_sort	(	real(kind=8), dimension(n)	s_list,
		integer, dimension(n)	order,
		integer	n
	)

Here is the call graph for this function:

◆ quick_sort_int()

subroutine s_misc_utilities::quick_sort_int	(	integer, dimension(n)	s_list,
		integer, dimension(n)	order,
		integer	n
	)

Here is the call graph for this function:

◆ s_aca_compressionfull()

subroutine s_misc_utilities::s_aca_compressionfull	(	real(kind=4), dimension(rankmax_r, rankmax_c)	mat,
		real(kind=4), dimension(rankmax_r, rmax)	matU,
		real(kind=4), 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:

◆ s_array1dtopointer2d()

subroutine s_misc_utilities::s_array1dtopointer2d	(	real(kind=4), dimension(n1, n2), target	x,
		real(kind=4), dimension(:,:), pointer	p,
		integer	n1,
		integer	n2
	)

◆ s_assert()

subroutine s_misc_utilities::s_assert	(	logical	statement,
		character(*)	msg
	)

◆ s_besselj0_func()

real(kind=8) function s_misc_utilities::s_besselj0_func ( real(kind=8) x )

◆ s_bessely0_func()

real(kind=8) function s_misc_utilities::s_bessely0_func ( real(kind=8) x )

Here is the call graph for this function:

◆ s_binary_search()

subroutine s_misc_utilities::s_binary_search	(	integer	N,
		integer, dimension(n)	x,
		integer	val,
		integer	mid
	)

◆ s_bit_reverse()

integer function s_misc_utilities::s_bit_reverse	(	integer, intent(in)	n,
		integer, intent(in)	bits
	)

◆ s_blacs_exit_wrp()

subroutine s_misc_utilities::s_blacs_exit_wrp ( integer flag )

◆ s_blacs_gridexit_wrp()

subroutine s_misc_utilities::s_blacs_gridexit_wrp ( integer ctxt )

◆ s_blacs_gridmap_wrp()

subroutine s_misc_utilities::s_blacs_gridmap_wrp	(	integer	ctxt,
		integer, dimension(:,:)	pmap,
		integer	ldu,
		integer	nprow,
		integer	npcol
	)

◆ s_blacs_pnum_wp()

integer function s_misc_utilities::s_blacs_pnum_wp	(	integer	NPROW,
		integer	NPCOL,
		integer	PROW,
		integer	PCOL
	)

◆ s_c8_normal_01()

complex(kind=8) function s_misc_utilities::s_c8_normal_01 ( integer(kind=4) seed )

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

Here is the call graph for this function:

◆ s_cart2sph()

subroutine s_misc_utilities::s_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
	)

◆ s_cart2sph_loc()

subroutine s_misc_utilities::s_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:

◆ s_cccurl()

subroutine s_misc_utilities::s_cccurl	(	complex(kind=8), dimension(3)	a,
		complex(kind=8), dimension(3)	b,
		complex(kind=8), dimension(3)	c
	)

◆ s_cccurl_sp()

subroutine s_misc_utilities::s_cccurl_sp	(	complex(kind=4), dimension(3)	a,
		complex(kind=4), dimension(3)	b,
		complex(kind=4), dimension(3)	c
	)

◆ s_ceiling_safe()

integer function s_misc_utilities::s_ceiling_safe ( real(kind=8) input )

◆ s_checkrandomizedlr()

subroutine s_misc_utilities::s_checkrandomizedlr	(	integer	M,
		integer	N,
		real(kind=4), dimension(m, n)	mat,
		real(kind=8)	tolerance
	)

Here is the call graph for this function:

◆ s_computerange()

subroutine s_misc_utilities::s_computerange	(	integer	M,
		integer	N,
		real(kind=4), 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:

◆ s_copymatt()

subroutine s_misc_utilities::s_copymatt	(	real(kind=4), dimension(:, :)	A,
		real(kind=4), dimension(:, :)	B,
		integer	m,
		integer	n
	)

◆ s_copysubmat()

subroutine s_misc_utilities::s_copysubmat	(	real(kind=4), dimension(:, :)	A,
		integer	ais,
		integer	ajs,
		real(kind=4), dimension(:, :)	B,
		integer	bis,
		integer	bjs,
		integer	m,
		integer	n,
		character	trans
	)

◆ s_copysubmat_assumeshape()

subroutine s_misc_utilities::s_copysubmat_assumeshape	(	real(kind=4), dimension(m, n)	A,
		real(kind=4), dimension(m, n)	B,
		integer	m,
		integer	n,
		character	trans
	)

◆ s_createleaf_natural()

recursive subroutine s_misc_utilities::s_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)

◆ s_createptree()

subroutine s_misc_utilities::s_createptree	(	integer	nmpi,
		integer, dimension(nmpi)	groupmembers,
		integer	MPI_Comm_base,
		type(s_proctree)	ptree
	)

Here is the call graph for this function:

◆ s_cscalar()

subroutine s_misc_utilities::s_cscalar	(	complex(kind=8), dimension(3)	a,
		real(kind=8), dimension(3)	b,
		complex(kind=8)	c
	)

◆ s_cscalar_sp()

subroutine s_misc_utilities::s_cscalar_sp	(	complex(kind=4), dimension(3)	a,
		real(kind=4), dimension(3)	b,
		complex(kind=4)	c
	)

◆ s_floor_safe()

integer function s_misc_utilities::s_floor_safe ( real(kind=8) input )

◆ s_gcd()

integer function s_misc_utilities::s_gcd	(	integer	a,
		integer	b
	)

◆ s_generalinverse()

subroutine s_misc_utilities::s_generalinverse	(	integer	m,
		integer	n,
		real(kind=4), dimension(:, :)	A,
		real(kind=4), dimension(:, :)	A_inv,
		real(kind=8)	eps_r,
		real(kind=8), optional	Flops
	)

Here is the call graph for this function:

◆ s_get_graph_colors_jp()

subroutine s_misc_utilities::s_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:

◆ s_getblockpid()

subroutine s_misc_utilities::s_getblockpid	(	type(s_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:

◆ s_getblockpid_md()

subroutine s_misc_utilities::s_getblockpid_md	(	type(s_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:

◆ s_getlocalblockrange()

subroutine s_misc_utilities::s_getlocalblockrange	(	type(s_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:

◆ s_getlocalblockrange_md()

subroutine s_misc_utilities::s_getlocalblockrange_md	(	type(s_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:

◆ s_getmshgroup_pgno()

integer function s_misc_utilities::s_getmshgroup_pgno	(	type(s_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:

◆ s_getpgno_sub()

subroutine s_misc_utilities::s_getpgno_sub	(	type(s_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:

◆ s_getrank()

subroutine s_misc_utilities::s_getrank	(	integer	M,
		integer	N,
		real(kind=4), dimension(:, :)	mat,
		integer	rank,
		real(kind=8)	eps,
		real(kind=8), optional	flop
	)

Here is the call graph for this function:

◆ s_gettreelevel()

integer function s_misc_utilities::s_gettreelevel ( integer gno )

◆ s_gridinfo_2d()

subroutine s_misc_utilities::s_gridinfo_2d	(	integer, dimension(3)	pmap,
		integer	MyID,
		integer	myrow,
		integer	mycol
	)

◆ s_hankel02_func()

complex(kind=8) function s_misc_utilities::s_hankel02_func ( real(kind=8) x )

Here is the call graph for this function:

◆ s_id_selection()

subroutine s_misc_utilities::s_id_selection	(	real(kind=4), 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:

◆ s_init_random_seed()

subroutine s_misc_utilities::s_init_random_seed ( )

Here is the call graph for this function:

◆ s_int_safe()

integer function s_misc_utilities::s_int_safe ( real(kind=8) input )

◆ s_iownpgrp()

logical function s_misc_utilities::s_iownpgrp	(	type(s_proctree)	ptree,
		integer	pgno
	)

◆ s_isnanmat()

logical function s_misc_utilities::s_isnanmat	(	real(kind=4), dimension(:, :)	A,
		integer	m,
		integer	n
	)

Here is the call graph for this function:

◆ s_lcm()

integer function s_misc_utilities::s_lcm	(	integer	a,
		integer	b
	)

Here is the call graph for this function:

◆ s_linearsolve()

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

Here is the call graph for this function:

◆ s_linspacei()

subroutine s_misc_utilities::s_linspacei	(	integer	startI,
		integer	endI,
		integer	N,
		integer, dimension(1:n)	array
	)

◆ s_logmemory()

subroutine s_misc_utilities::s_logmemory	(	type(s_hstat)	stats,
		real(kind=8)	mem
	)

◆ s_lr_add()

subroutine s_misc_utilities::s_lr_add	(	character	chara,
		real(kind=4), dimension(m,rank1)	U1,
		real(kind=4), dimension(n,rank1)	V1,
		real(kind=4), dimension(m,rank2)	U2,
		real(kind=4), dimension(n,rank2)	V2,
		integer	rank1,
		integer	rank2,
		integer	ranknew,
		real(kind=4), dimension(m,rank1+rank2)	matU,
		real(kind=4), 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:

◆ s_lr_add_aca()

subroutine s_misc_utilities::s_lr_add_aca	(	real(kind=4), dimension(rankmax_r, rmax)	matU,
		real(kind=4), 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:

◆ s_lr_fnorm()

subroutine s_misc_utilities::s_lr_fnorm	(	real(kind=4), dimension(:, :)	matU,
		real(kind=4), 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:

◆ s_lr_fnormup()

subroutine s_misc_utilities::s_lr_fnormup	(	real(kind=4), dimension(:, :)	matU,
		real(kind=4), 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
	)

◆ s_lr_recompression()

subroutine s_misc_utilities::s_lr_recompression	(	real(kind=4), dimension(:, :)	matU,
		real(kind=4), dimension(:, :)	matV,
		real(kind=4), 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:

◆ s_multiindextosingleindex()

subroutine s_misc_utilities::s_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:

◆ s_myisnan()

logical function s_misc_utilities::s_myisnan ( real(kind=4) a )

◆ s_norm_vector()

real(kind=8) function s_misc_utilities::s_norm_vector	(	real(kind=4), dimension(n)	vector,
		integer	n
	)

◆ s_numberingptree()

subroutine s_misc_utilities::s_numberingptree ( type(s_proctree) ptree )

◆ s_pcomputerange()

subroutine s_misc_utilities::s_pcomputerange	(	integer, dimension(:, :)	M_p,
		integer	N,
		real(kind=4), dimension(:, :)	mat,
		integer	rank,
		real(kind=8)	eps,
		type(s_proctree)	ptree,
		integer	pgno,
		real(kind=8), optional	Flops,
		real(kind=8), optional	norm_tol
	)

Here is the call graph for this function:

◆ s_pgeneralinverse()

subroutine s_misc_utilities::s_pgeneralinverse	(	integer	m,
		integer	n,
		real(kind=4), dimension(:,:)	A,
		real(kind=4), dimension(:,:)	A_inv,
		real(kind=8)	eps_r,
		integer	ctxt,
		real(kind=8), optional	Flops
	)

Here is the call graph for this function:

◆ s_piksrt_dble_multi()

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

◆ s_piksrt_int_multi()

subroutine s_misc_utilities::s_piksrt_int_multi	(	integer	N,
		integer	M,
		integer, dimension(n, m)	ARR
	)

◆ s_psvd_truncate()

subroutine s_misc_utilities::s_psvd_truncate	(	integer	mm,
		integer	nn,
		real(kind=4), dimension(:, :)	mat,
		integer, dimension(9)	descMat,
		real(kind=4), dimension(:, :)	UU,
		real(kind=4), dimension(:, :)	VV,
		integer, dimension(9)	descUU,
		integer, dimension(9)	descVV,
		real(kind=4), 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:

◆ s_r8_normal_01()

real(kind=8) function s_misc_utilities::s_r8_normal_01 ( integer(kind=4) seed )

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

Here is the call graph for this function:

◆ s_r8_uniform_01()

real(kind=8) function s_misc_utilities::s_r8_uniform_01 ( integer(kind=4) seed )

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

◆ s_random_dp_number()

subroutine s_misc_utilities::s_random_dp_number ( real(kind=4) val )

◆ s_randomizedsvd()

subroutine s_misc_utilities::s_randomizedsvd	(	real(kind=4), dimension(rankmax_c, rmax)	matRcol,
		real(kind=4), dimension(rankmax_r, rmax)	matZRcol,
		real(kind=4), dimension(rankmax_r, rmax)	matRrow,
		real(kind=4), dimension(rankmax_c, rmax)	matZcRrow,
		real(kind=4), dimension(rankmax_r, rmax)	matU,
		real(kind=4), dimension(rmax, rankmax_c)	matV,
		real(kind=4), 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:

◆ s_randommat()

subroutine s_misc_utilities::s_randommat	(	integer	m,
		integer	n,
		integer	k,
		real(kind=4), dimension(:, :)	A,
		integer	Oflag
	)

Here is the call graph for this function:

◆ s_randomsubmat()

subroutine s_misc_utilities::s_randomsubmat	(	integer	ms,
		integer	me,
		integer	ns,
		integer	ne,
		integer	k,
		real(kind=4), dimension(:, :)	A,
		integer	Oflag
	)

Here is the call graph for this function:

◆ s_rccurl()

subroutine s_misc_utilities::s_rccurl	(	real(kind=8), dimension(3)	a,
		complex(kind=8), dimension(3)	b,
		complex(kind=8), dimension(3)	c
	)

◆ s_rccurl_sp()

subroutine s_misc_utilities::s_rccurl_sp	(	real(kind=4), dimension(3)	a,
		complex(kind=4), dimension(3)	b,
		complex(kind=4), dimension(3)	c
	)

◆ s_redistribute1dto1d()

subroutine s_misc_utilities::s_redistribute1dto1d	(	real(kind=4), dimension(ldi, *)	dat_i,
		integer	ldi,
		integer, dimension(:, :)	M_p_i,
		integer	head_i,
		integer	pgno_i,
		real(kind=4), dimension(ldo, *)	dat_o,
		integer	ldo,
		integer, dimension(:, :)	M_p_o,
		integer	head_o,
		integer	pgno_o,
		integer	N,
		type(s_proctree)	ptree,
		integer, optional	addflag
	)

Here is the call graph for this function:

◆ s_redistribute1dto1d_md()

subroutine s_misc_utilities::s_redistribute1dto1d_md	(	integer	Ndim,
		real(kind=4), dimension(product(ldi), *)	dat_i,
		integer, dimension(ndim)	ldi,
		integer, dimension(:, :, :)	M_p_i,
		integer, dimension(ndim)	head_i,
		integer	pgno_i,
		real(kind=4), 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(s_proctree)	ptree,
		integer, optional	addflag
	)

Here is the call graph for this function:

◆ s_redistribute1dto1d_onetotwo()

subroutine s_misc_utilities::s_redistribute1dto1d_onetotwo	(	real(kind=4), dimension(ldi, *)	dat_i,
		integer	ldi,
		integer, dimension(:, :)	M_p_i,
		integer	head_i,
		integer	pgno_i,
		real(kind=4), dimension(ldo1, *)	dat_o1,
		integer	ldo1,
		integer, dimension(:, :)	M_p_o1,
		integer	head_o1,
		integer	pgno_o1,
		real(kind=4), dimension(ldo2, *)	dat_o2,
		integer	ldo2,
		integer, dimension(:, :)	M_p_o2,
		integer	head_o2,
		integer	pgno_o2,
		integer	N,
		type(s_proctree)	ptree
	)

Here is the call graph for this function:

◆ s_redistribute1dto1d_twotoone()

subroutine s_misc_utilities::s_redistribute1dto1d_twotoone	(	real(kind=4), dimension(ldi1, *)	dat_i1,
		integer	ldi1,
		integer, dimension(:, :)	M_p_i1,
		integer	head_i1,
		integer	pgno_i1,
		real(kind=4), dimension(ldi2, *)	dat_i2,
		integer	ldi2,
		integer, dimension(:, :)	M_p_i2,
		integer	head_i2,
		integer	pgno_i2,
		real(kind=4), dimension(ldo, *)	dat_o,
		integer	ldo,
		integer, dimension(:, :)	M_p_o,
		integer	head_o,
		integer	pgno_o,
		integer	N,
		type(s_proctree)	ptree
	)

Here is the call graph for this function:

◆ s_redistribute1dto2d()

subroutine s_misc_utilities::s_redistribute1dto2d	(	real(kind=4), dimension(:, :)	dat_i,
		integer, dimension(:, :)	M_p_i,
		integer	head_i,
		integer	pgno_i,
		real(kind=4), dimension(:, :)	dat_o,
		integer	M,
		integer	head_o,
		integer	pgno_o,
		integer	N,
		type(s_proctree)	ptree
	)

Here is the call graph for this function:

◆ s_redistribute2dto1d()

subroutine s_misc_utilities::s_redistribute2dto1d	(	real(kind=4), dimension(:, :)	dat_i,
		integer	M,
		integer	head_i,
		integer	pgno_i,
		real(kind=4), dimension(:, :)	dat_o,
		integer, dimension(:, :)	M_p_o,
		integer	head_o,
		integer	pgno_o,
		integer	N,
		type(s_proctree)	ptree
	)

Here is the call graph for this function:

◆ s_remove_dup_int()

subroutine s_misc_utilities::s_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:

◆ s_rperm()

subroutine s_misc_utilities::s_rperm	(	integer, intent(in)	N,
		integer, dimension(n)	p
	)

Here is the call graph for this function:

◆ s_rrcurl()

subroutine s_misc_utilities::s_rrcurl	(	real(kind=8), dimension(3)	a,
		real(kind=8), dimension(3)	b,
		real(kind=8), dimension(3)	c
	)

◆ s_rrcurl_sp()

subroutine s_misc_utilities::s_rrcurl_sp	(	real(kind=4), dimension(3)	a,
		real(kind=4), dimension(3)	b,
		real(kind=4), dimension(3)	c
	)

◆ s_rrqr_lq()

recursive subroutine s_misc_utilities::s_rrqr_lq	(	real(kind=4), dimension(mm, nn)	mat,
		integer	mm,
		integer	nn,
		integer	mn,
		real(kind=4), dimension(mm, mn)	UU,
		real(kind=4), 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:

◆ s_rrqr_svd()

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

Here is the call graph for this function:

◆ s_scalar()

subroutine s_misc_utilities::s_scalar	(	real(kind=8), dimension(3)	a,
		real(kind=8), dimension(3)	b,
		real(kind=8)	c
	)

◆ s_scalar_sp()

subroutine s_misc_utilities::s_scalar_sp	(	real(kind=4), dimension(3)	a,
		real(kind=4), dimension(3)	b,
		real(kind=4)	c
	)

◆ s_seq_wtime()

real ( kind = 8 ) function s_misc_utilities::s_seq_wtime ( )

◆ s_singleindextomultiindex()

subroutine s_misc_utilities::s_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:

◆ s_svd_truncate()

subroutine s_misc_utilities::s_svd_truncate	(	real(kind=4), dimension(mm, nn)	mat,
		integer	mm,
		integer	nn,
		integer	mn,
		real(kind=4), dimension(mm, mn)	UU,
		real(kind=4), dimension(mn, nn)	VV,
		real(kind=4), 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:

◆ s_sys2blacs_handle_wrp()

integer function s_misc_utilities::s_sys2blacs_handle_wrp ( integer comm )

◆ s_tensorunfoldingreshape()

subroutine s_misc_utilities::s_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=4), dimension(:,:)	data_in,
		character	trans_in,
		real(kind=4), dimension(:,:), allocatable	data_out,
		character	trans_out,
		integer	loopnew
	)

Here is the call graph for this function:

Variable Documentation

◆ int64

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

Functions/Subroutines

Variables

Function/Subroutine Documentation

◆ beschb()

◆ bessjy()

◆ bessjyv()

◆ chebev()

◆ quick_sort()

◆ quick_sort_int()

◆ s_aca_compressionfull()

◆ s_array1dtopointer2d()

◆ s_assert()

◆ s_besselj0_func()

◆ s_bessely0_func()

◆ s_binary_search()

◆ s_bit_reverse()

◆ s_blacs_exit_wrp()

◆ s_blacs_gridexit_wrp()

◆ s_blacs_gridmap_wrp()

◆ s_blacs_pnum_wp()

◆ s_c8_normal_01()

◆ s_cart2sph()

◆ s_cart2sph_loc()

◆ s_cccurl()

◆ s_cccurl_sp()

◆ s_ceiling_safe()

◆ s_checkrandomizedlr()

◆ s_computerange()

◆ s_copymatt()

◆ s_copysubmat()

◆ s_copysubmat_assumeshape()

◆ s_createleaf_natural()

◆ s_createptree()

◆ s_cscalar()

◆ s_cscalar_sp()

◆ s_floor_safe()

◆ s_gcd()

◆ s_generalinverse()

◆ s_get_graph_colors_jp()

◆ s_getblockpid()

◆ s_getblockpid_md()

◆ s_getlocalblockrange()

◆ s_getlocalblockrange_md()

◆ s_getmshgroup_pgno()

◆ s_getpgno_sub()

◆ s_getrank()

◆ s_gettreelevel()

◆ s_gridinfo_2d()

◆ s_hankel02_func()

◆ s_id_selection()

◆ s_init_random_seed()

◆ s_int_safe()

◆ s_iownpgrp()

◆ s_isnanmat()

◆ s_lcm()

◆ s_linearsolve()

◆ s_linspacei()

◆ s_logmemory()

◆ s_lr_add()

◆ s_lr_add_aca()

◆ s_lr_fnorm()

◆ s_lr_fnormup()

◆ s_lr_recompression()

◆ s_multiindextosingleindex()

◆ s_myisnan()

◆ s_norm_vector()

◆ s_numberingptree()

◆ s_pcomputerange()

◆ s_pgeneralinverse()

◆ s_piksrt_dble_multi()

◆ s_piksrt_int_multi()

◆ s_psvd_truncate()

◆ s_r8_normal_01()

◆ s_r8_uniform_01()

◆ s_random_dp_number()

◆ s_randomizedsvd()

◆ s_randommat()

◆ s_randomsubmat()

◆ s_rccurl()

◆ s_rccurl_sp()