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

subroutine	z_linspacei (startI, endI, N, array)

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

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

subroutine	z_copymatt (A, B, m, n)

logical function	z_myisnan (a)

logical function	z_isnanmat (A, m, n)

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

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

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

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

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

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

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

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

subroutine	z_checkrandomizedlr (M, N, mat, tolerance)

subroutine	z_rperm (N, p)

subroutine	z_init_random_seed ()

subroutine	z_random_dp_number (val)

complex(kind=8) function	z_c8_normal_01 (seed)

real(kind=8) function	z_r8_normal_01 (seed)

real(kind=8) function	z_r8_uniform_01 (seed)

subroutine	z_assert (statement, msg)

integer function	z_floor_safe (input)

integer function	z_ceiling_safe (input)

integer function	z_int_safe (input)

subroutine	z_cscalar (a, b, c)

subroutine	z_scalar (a, b, c)

subroutine	z_rrcurl (a, b, c)

subroutine	z_rccurl (a, b, c)

subroutine	z_cccurl (a, b, c)

subroutine	z_cscalar_sp (a, b, c)

subroutine	z_scalar_sp (a, b, c)

subroutine	z_rrcurl_sp (a, b, c)

subroutine	z_rccurl_sp (a, b, c)

subroutine	z_cccurl_sp (a, b, c)

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

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

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

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

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

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

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

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

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

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

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

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

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

subroutine	z_piksrt_dble_multi (N, M, ARR)

subroutine	z_piksrt_int_multi (N, M, ARR)

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

subroutine	z_binary_search (N, x, val, mid)

subroutine	quick_sort (z_list, order, n)

subroutine	quick_sort_int (z_list, order, n)

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

complex(kind=8) function	z_hankel02_func (x)

real(kind=8) function	z_besselj0_func (x)

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

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

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

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

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

subroutine	z_blacs_exit_wrp (flag)

subroutine	z_blacs_gridexit_wrp (ctxt)

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

integer function	z_sys2blacs_handle_wrp (comm)

subroutine	z_createptree (nmpi, groupmembers, MPI_Comm_base, ptree)

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

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

subroutine	z_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	z_gettreelevel (gno)

logical function	z_iownpgrp (ptree, pgno)

integer function	z_lcm (a, b)

integer function	z_gcd (a, b)

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

subroutine	z_gridinfo_2d (pmap, MyID, myrow, mycol)

subroutine	z_array1dtopointer2d (x, p, n1, n2)

subroutine	z_logmemory (stats, mem)

subroutine	z_get_graph_colors_jp (rows, ia, ja, colors)

integer function	z_bit_reverse (n, bits)

Variables
integer, parameter	int64 = selected_int_kind(18)

Function/Subroutine Documentation

◆ beschb()

subroutine z_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 z_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 z_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 z_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 z_misc_utilities::quick_sort	(	real(kind=8), dimension(n)	z_list,
		integer, dimension(n)	order,
		integer	n
	)

Here is the call graph for this function:

◆ quick_sort_int()

subroutine z_misc_utilities::quick_sort_int	(	integer, dimension(n)	z_list,
		integer, dimension(n)	order,
		integer	n
	)

Here is the call graph for this function:

◆ z_aca_compressionfull()

subroutine z_misc_utilities::z_aca_compressionfull	(	complex(kind=8), dimension(rankmax_r, rankmax_c)	mat,
		complex(kind=8), dimension(rankmax_r, rmax)	matU,
		complex(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:

◆ z_array1dtopointer2d()

subroutine z_misc_utilities::z_array1dtopointer2d	(	complex(kind=8), dimension(n1, n2), target	x,
		complex(kind=8), dimension(:,:), pointer	p,
		integer	n1,
		integer	n2
	)

◆ z_assert()

subroutine z_misc_utilities::z_assert	(	logical	statement,
		character(*)	msg
	)

◆ z_besselj0_func()

real(kind=8) function z_misc_utilities::z_besselj0_func ( real(kind=8) x )

◆ z_bessely0_func()

real(kind=8) function z_misc_utilities::z_bessely0_func ( real(kind=8) x )

Here is the call graph for this function:

◆ z_binary_search()

subroutine z_misc_utilities::z_binary_search	(	integer	N,
		integer, dimension(n)	x,
		integer	val,
		integer	mid
	)

◆ z_bit_reverse()

integer function z_misc_utilities::z_bit_reverse	(	integer, intent(in)	n,
		integer, intent(in)	bits
	)

◆ z_blacs_exit_wrp()

subroutine z_misc_utilities::z_blacs_exit_wrp ( integer flag )

◆ z_blacs_gridexit_wrp()

subroutine z_misc_utilities::z_blacs_gridexit_wrp ( integer ctxt )

◆ z_blacs_gridmap_wrp()

subroutine z_misc_utilities::z_blacs_gridmap_wrp	(	integer	ctxt,
		integer, dimension(:,:)	pmap,
		integer	ldu,
		integer	nprow,
		integer	npcol
	)

◆ z_blacs_pnum_wp()

integer function z_misc_utilities::z_blacs_pnum_wp	(	integer	NPROW,
		integer	NPCOL,
		integer	PROW,
		integer	PCOL
	)

◆ z_c8_normal_01()

complex(kind=8) function z_misc_utilities::z_c8_normal_01 ( integer(kind=4) seed )

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

Here is the call graph for this function:

◆ z_cart2sph()

subroutine z_misc_utilities::z_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
	)

◆ z_cart2sph_loc()

subroutine z_misc_utilities::z_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:

◆ z_cccurl()

subroutine z_misc_utilities::z_cccurl	(	complex(kind=8), dimension(3)	a,
		complex(kind=8), dimension(3)	b,
		complex(kind=8), dimension(3)	c
	)

◆ z_cccurl_sp()

subroutine z_misc_utilities::z_cccurl_sp	(	complex(kind=4), dimension(3)	a,
		complex(kind=4), dimension(3)	b,
		complex(kind=4), dimension(3)	c
	)

◆ z_ceiling_safe()

integer function z_misc_utilities::z_ceiling_safe ( real(kind=8) input )

◆ z_checkrandomizedlr()

subroutine z_misc_utilities::z_checkrandomizedlr	(	integer	M,
		integer	N,
		complex(kind=8), dimension(m, n)	mat,
		real(kind=8)	tolerance
	)

Here is the call graph for this function:

◆ z_computerange()

subroutine z_misc_utilities::z_computerange	(	integer	M,
		integer	N,
		complex(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:

◆ z_copymatt()

subroutine z_misc_utilities::z_copymatt	(	complex(kind=8), dimension(:, :)	A,
		complex(kind=8), dimension(:, :)	B,
		integer	m,
		integer	n
	)

◆ z_copysubmat()

subroutine z_misc_utilities::z_copysubmat	(	complex(kind=8), dimension(:, :)	A,
		integer	ais,
		integer	ajs,
		complex(kind=8), dimension(:, :)	B,
		integer	bis,
		integer	bjs,
		integer	m,
		integer	n,
		character	trans
	)

◆ z_copysubmat_assumeshape()

subroutine z_misc_utilities::z_copysubmat_assumeshape	(	complex(kind=8), dimension(m, n)	A,
		complex(kind=8), dimension(m, n)	B,
		integer	m,
		integer	n,
		character	trans
	)

◆ z_createleaf_natural()

recursive subroutine z_misc_utilities::z_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)

◆ z_createptree()

subroutine z_misc_utilities::z_createptree	(	integer	nmpi,
		integer, dimension(nmpi)	groupmembers,
		integer	MPI_Comm_base,
		type(z_proctree)	ptree
	)

Here is the call graph for this function:

◆ z_cscalar()

subroutine z_misc_utilities::z_cscalar	(	complex(kind=8), dimension(3)	a,
		real(kind=8), dimension(3)	b,
		complex(kind=8)	c
	)

◆ z_cscalar_sp()

subroutine z_misc_utilities::z_cscalar_sp	(	complex(kind=4), dimension(3)	a,
		real(kind=4), dimension(3)	b,
		complex(kind=4)	c
	)

◆ z_floor_safe()

integer function z_misc_utilities::z_floor_safe ( real(kind=8) input )

◆ z_gcd()

integer function z_misc_utilities::z_gcd	(	integer	a,
		integer	b
	)

◆ z_generalinverse()

subroutine z_misc_utilities::z_generalinverse	(	integer	m,
		integer	n,
		complex(kind=8), dimension(:, :)	A,
		complex(kind=8), dimension(:, :)	A_inv,
		real(kind=8)	eps_r,
		real(kind=8), optional	Flops
	)

Here is the call graph for this function:

◆ z_get_graph_colors_jp()

subroutine z_misc_utilities::z_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:

◆ z_getblockpid()

subroutine z_misc_utilities::z_getblockpid	(	type(z_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:

◆ z_getblockpid_md()

subroutine z_misc_utilities::z_getblockpid_md	(	type(z_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:

◆ z_getlocalblockrange()

subroutine z_misc_utilities::z_getlocalblockrange	(	type(z_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:

◆ z_getlocalblockrange_md()

subroutine z_misc_utilities::z_getlocalblockrange_md	(	type(z_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:

◆ z_getmshgroup_pgno()

integer function z_misc_utilities::z_getmshgroup_pgno	(	type(z_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:

◆ z_getpgno_sub()

subroutine z_misc_utilities::z_getpgno_sub	(	type(z_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:

◆ z_getrank()

subroutine z_misc_utilities::z_getrank	(	integer	M,
		integer	N,
		complex(kind=8), dimension(:, :)	mat,
		integer	rank,
		real(kind=8)	eps,
		real(kind=8), optional	flop
	)

Here is the call graph for this function:

◆ z_gettreelevel()

integer function z_misc_utilities::z_gettreelevel ( integer gno )

◆ z_gridinfo_2d()

subroutine z_misc_utilities::z_gridinfo_2d	(	integer, dimension(3)	pmap,
		integer	MyID,
		integer	myrow,
		integer	mycol
	)

◆ z_hankel02_func()

complex(kind=8) function z_misc_utilities::z_hankel02_func ( real(kind=8) x )

Here is the call graph for this function:

◆ z_id_selection()

subroutine z_misc_utilities::z_id_selection	(	complex(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:

◆ z_init_random_seed()

subroutine z_misc_utilities::z_init_random_seed ( )

Here is the call graph for this function:

◆ z_int_safe()

integer function z_misc_utilities::z_int_safe ( real(kind=8) input )

◆ z_iownpgrp()

logical function z_misc_utilities::z_iownpgrp	(	type(z_proctree)	ptree,
		integer	pgno
	)

◆ z_isnanmat()

logical function z_misc_utilities::z_isnanmat	(	complex(kind=8), dimension(:, :)	A,
		integer	m,
		integer	n
	)

Here is the call graph for this function:

◆ z_lcm()

integer function z_misc_utilities::z_lcm	(	integer	a,
		integer	b
	)

Here is the call graph for this function:

◆ z_linearsolve()

subroutine z_misc_utilities::z_linearsolve	(	integer	m,
		integer	n,
		integer	k,
		complex(kind=8), dimension(m, n)	A,
		complex(kind=8), dimension(m, k)	b,
		complex(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:

◆ z_linspacei()

subroutine z_misc_utilities::z_linspacei	(	integer	startI,
		integer	endI,
		integer	N,
		integer, dimension(1:n)	array
	)

◆ z_logmemory()

subroutine z_misc_utilities::z_logmemory	(	type(z_hstat)	stats,
		real(kind=8)	mem
	)

◆ z_lr_add()

subroutine z_misc_utilities::z_lr_add	(	character	chara,
		complex(kind=8), dimension(m,rank1)	U1,
		complex(kind=8), dimension(n,rank1)	V1,
		complex(kind=8), dimension(m,rank2)	U2,
		complex(kind=8), dimension(n,rank2)	V2,
		integer	rank1,
		integer	rank2,
		integer	ranknew,
		complex(kind=8), dimension(m,rank1+rank2)	matU,
		complex(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:

◆ z_lr_add_aca()

subroutine z_misc_utilities::z_lr_add_aca	(	complex(kind=8), dimension(rankmax_r, rmax)	matU,
		complex(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:

◆ z_lr_fnorm()

subroutine z_misc_utilities::z_lr_fnorm	(	complex(kind=8), dimension(:, :)	matU,
		complex(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:

◆ z_lr_fnormup()

subroutine z_misc_utilities::z_lr_fnormup	(	complex(kind=8), dimension(:, :)	matU,
		complex(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
	)

◆ z_lr_recompression()

subroutine z_misc_utilities::z_lr_recompression	(	complex(kind=8), dimension(:, :)	matU,
		complex(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:

◆ z_multiindextosingleindex()

subroutine z_misc_utilities::z_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:

◆ z_myisnan()

logical function z_misc_utilities::z_myisnan ( real(kind=8) a )

◆ z_norm_vector()

real(kind=8) function z_misc_utilities::z_norm_vector	(	complex(kind=8), dimension(n)	vector,
		integer	n
	)

◆ z_numberingptree()

subroutine z_misc_utilities::z_numberingptree ( type(z_proctree) ptree )

◆ z_pcomputerange()

subroutine z_misc_utilities::z_pcomputerange	(	integer, dimension(:, :)	M_p,
		integer	N,
		complex(kind=8), dimension(:, :)	mat,
		integer	rank,
		real(kind=8)	eps,
		type(z_proctree)	ptree,
		integer	pgno,
		real(kind=8), optional	Flops,
		real(kind=8), optional	norm_tol
	)

Here is the call graph for this function:

◆ z_pgeneralinverse()

subroutine z_misc_utilities::z_pgeneralinverse	(	integer	m,
		integer	n,
		complex(kind=8), dimension(:,:)	A,
		complex(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:

◆ z_piksrt_dble_multi()

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

◆ z_piksrt_int_multi()

subroutine z_misc_utilities::z_piksrt_int_multi	(	integer	N,
		integer	M,
		integer, dimension(n, m)	ARR
	)

◆ z_psvd_truncate()

subroutine z_misc_utilities::z_psvd_truncate	(	integer	mm,
		integer	nn,
		complex(kind=8), dimension(:, :)	mat,
		integer, dimension(9)	descMat,
		complex(kind=8), dimension(:, :)	UU,
		complex(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:

◆ z_r8_normal_01()

real(kind=8) function z_misc_utilities::z_r8_normal_01 ( integer(kind=4) seed )

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

Here is the call graph for this function:

◆ z_r8_uniform_01()

real(kind=8) function z_misc_utilities::z_r8_uniform_01 ( integer(kind=4) seed )

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

◆ z_random_dp_number()

subroutine z_misc_utilities::z_random_dp_number ( complex(kind=8) val )

◆ z_randomizedsvd()

subroutine z_misc_utilities::z_randomizedsvd	(	complex(kind=8), dimension(rankmax_c, rmax)	matRcol,
		complex(kind=8), dimension(rankmax_r, rmax)	matZRcol,
		complex(kind=8), dimension(rankmax_r, rmax)	matRrow,
		complex(kind=8), dimension(rankmax_c, rmax)	matZcRrow,
		complex(kind=8), dimension(rankmax_r, rmax)	matU,
		complex(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:

◆ z_randommat()

subroutine z_misc_utilities::z_randommat	(	integer	m,
		integer	n,
		integer	k,
		complex(kind=8), dimension(:, :)	A,
		integer	Oflag
	)

Here is the call graph for this function:

◆ z_randomsubmat()

subroutine z_misc_utilities::z_randomsubmat	(	integer	ms,
		integer	me,
		integer	ns,
		integer	ne,
		integer	k,
		complex(kind=8), dimension(:, :)	A,
		integer	Oflag
	)

Here is the call graph for this function:

◆ z_rccurl()

subroutine z_misc_utilities::z_rccurl	(	real(kind=8), dimension(3)	a,
		complex(kind=8), dimension(3)	b,
		complex(kind=8), dimension(3)	c
	)

◆ z_rccurl_sp()

subroutine z_misc_utilities::z_rccurl_sp	(	real(kind=4), dimension(3)	a,
		complex(kind=4), dimension(3)	b,
		complex(kind=4), dimension(3)	c
	)

◆ z_redistribute1dto1d()

subroutine z_misc_utilities::z_redistribute1dto1d	(	complex(kind=8), dimension(ldi, *)	dat_i,
		integer	ldi,
		integer, dimension(:, :)	M_p_i,
		integer	head_i,
		integer	pgno_i,
		complex(kind=8), dimension(ldo, *)	dat_o,
		integer	ldo,
		integer, dimension(:, :)	M_p_o,
		integer	head_o,
		integer	pgno_o,
		integer	N,
		type(z_proctree)	ptree,
		integer, optional	addflag
	)

Here is the call graph for this function:

◆ z_redistribute1dto1d_md()

subroutine z_misc_utilities::z_redistribute1dto1d_md	(	integer	Ndim,
		complex(kind=8), dimension(product(ldi), *)	dat_i,
		integer, dimension(ndim)	ldi,
		integer, dimension(:, :, :)	M_p_i,
		integer, dimension(ndim)	head_i,
		integer	pgno_i,
		complex(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(z_proctree)	ptree,
		integer, optional	addflag
	)

Here is the call graph for this function:

◆ z_redistribute1dto1d_onetotwo()

subroutine z_misc_utilities::z_redistribute1dto1d_onetotwo	(	complex(kind=8), dimension(ldi, *)	dat_i,
		integer	ldi,
		integer, dimension(:, :)	M_p_i,
		integer	head_i,
		integer	pgno_i,
		complex(kind=8), dimension(ldo1, *)	dat_o1,
		integer	ldo1,
		integer, dimension(:, :)	M_p_o1,
		integer	head_o1,
		integer	pgno_o1,
		complex(kind=8), dimension(ldo2, *)	dat_o2,
		integer	ldo2,
		integer, dimension(:, :)	M_p_o2,
		integer	head_o2,
		integer	pgno_o2,
		integer	N,
		type(z_proctree)	ptree
	)

Here is the call graph for this function:

◆ z_redistribute1dto1d_twotoone()

subroutine z_misc_utilities::z_redistribute1dto1d_twotoone	(	complex(kind=8), dimension(ldi1, *)	dat_i1,
		integer	ldi1,
		integer, dimension(:, :)	M_p_i1,
		integer	head_i1,
		integer	pgno_i1,
		complex(kind=8), dimension(ldi2, *)	dat_i2,
		integer	ldi2,
		integer, dimension(:, :)	M_p_i2,
		integer	head_i2,
		integer	pgno_i2,
		complex(kind=8), dimension(ldo, *)	dat_o,
		integer	ldo,
		integer, dimension(:, :)	M_p_o,
		integer	head_o,
		integer	pgno_o,
		integer	N,
		type(z_proctree)	ptree
	)

Here is the call graph for this function:

◆ z_redistribute1dto2d()

subroutine z_misc_utilities::z_redistribute1dto2d	(	complex(kind=8), dimension(:, :)	dat_i,
		integer, dimension(:, :)	M_p_i,
		integer	head_i,
		integer	pgno_i,
		complex(kind=8), dimension(:, :)	dat_o,
		integer	M,
		integer	head_o,
		integer	pgno_o,
		integer	N,
		type(z_proctree)	ptree
	)

Here is the call graph for this function:

◆ z_redistribute2dto1d()

subroutine z_misc_utilities::z_redistribute2dto1d	(	complex(kind=8), dimension(:, :)	dat_i,
		integer	M,
		integer	head_i,
		integer	pgno_i,
		complex(kind=8), dimension(:, :)	dat_o,
		integer, dimension(:, :)	M_p_o,
		integer	head_o,
		integer	pgno_o,
		integer	N,
		type(z_proctree)	ptree
	)

Here is the call graph for this function:

◆ z_remove_dup_int()

subroutine z_misc_utilities::z_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:

◆ z_rperm()

subroutine z_misc_utilities::z_rperm	(	integer, intent(in)	N,
		integer, dimension(n)	p
	)

Here is the call graph for this function:

◆ z_rrcurl()

subroutine z_misc_utilities::z_rrcurl	(	real(kind=8), dimension(3)	a,
		real(kind=8), dimension(3)	b,
		real(kind=8), dimension(3)	c
	)

◆ z_rrcurl_sp()

subroutine z_misc_utilities::z_rrcurl_sp	(	real(kind=4), dimension(3)	a,
		real(kind=4), dimension(3)	b,
		real(kind=4), dimension(3)	c
	)

◆ z_rrqr_lq()

recursive subroutine z_misc_utilities::z_rrqr_lq	(	complex(kind=8), dimension(mm, nn)	mat,
		integer	mm,
		integer	nn,
		integer	mn,
		complex(kind=8), dimension(mm, mn)	UU,
		complex(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:

◆ z_rrqr_svd()

subroutine z_misc_utilities::z_rrqr_svd	(	complex(kind=8), dimension(mm, nn)	mat,
		integer	mm,
		integer	nn,
		integer	mn,
		integer	rmax,
		complex(kind=8), dimension(mm, rmax)	UU,
		complex(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:

◆ z_scalar()

subroutine z_misc_utilities::z_scalar	(	real(kind=8), dimension(3)	a,
		real(kind=8), dimension(3)	b,
		real(kind=8)	c
	)

◆ z_scalar_sp()

subroutine z_misc_utilities::z_scalar_sp	(	real(kind=4), dimension(3)	a,
		real(kind=4), dimension(3)	b,
		real(kind=4)	c
	)

◆ z_seq_wtime()

real ( kind = 8 ) function z_misc_utilities::z_seq_wtime ( )

◆ z_singleindextomultiindex()

subroutine z_misc_utilities::z_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:

◆ z_svd_truncate()

subroutine z_misc_utilities::z_svd_truncate	(	complex(kind=8), dimension(mm, nn)	mat,
		integer	mm,
		integer	nn,
		integer	mn,
		complex(kind=8), dimension(mm, mn)	UU,
		complex(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:

◆ z_sys2blacs_handle_wrp()

integer function z_misc_utilities::z_sys2blacs_handle_wrp ( integer comm )

◆ z_tensorunfoldingreshape()

subroutine z_misc_utilities::z_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,
		complex(kind=8), dimension(:,:)	data_in,
		character	trans_in,
		complex(kind=8), dimension(:,:), allocatable	data_out,
		character	trans_out,
		integer	loopnew
	)

Here is the call graph for this function:

Variable Documentation

◆ int64

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

Functions/Subroutines

Variables

Function/Subroutine Documentation

◆ beschb()

◆ bessjy()

◆ bessjyv()

◆ chebev()

◆ quick_sort()

◆ quick_sort_int()

◆ z_aca_compressionfull()

◆ z_array1dtopointer2d()

◆ z_assert()

◆ z_besselj0_func()

◆ z_bessely0_func()

◆ z_binary_search()

◆ z_bit_reverse()

◆ z_blacs_exit_wrp()

◆ z_blacs_gridexit_wrp()

◆ z_blacs_gridmap_wrp()

◆ z_blacs_pnum_wp()

◆ z_c8_normal_01()

◆ z_cart2sph()

◆ z_cart2sph_loc()

◆ z_cccurl()

◆ z_cccurl_sp()

◆ z_ceiling_safe()

◆ z_checkrandomizedlr()

◆ z_computerange()

◆ z_copymatt()

◆ z_copysubmat()

◆ z_copysubmat_assumeshape()

◆ z_createleaf_natural()

◆ z_createptree()

◆ z_cscalar()

◆ z_cscalar_sp()

◆ z_floor_safe()

◆ z_gcd()

◆ z_generalinverse()

◆ z_get_graph_colors_jp()

◆ z_getblockpid()

◆ z_getblockpid_md()

◆ z_getlocalblockrange()

◆ z_getlocalblockrange_md()

◆ z_getmshgroup_pgno()

◆ z_getpgno_sub()

◆ z_getrank()

◆ z_gettreelevel()

◆ z_gridinfo_2d()

◆ z_hankel02_func()

◆ z_id_selection()

◆ z_init_random_seed()

◆ z_int_safe()

◆ z_iownpgrp()

◆ z_isnanmat()

◆ z_lcm()

◆ z_linearsolve()

◆ z_linspacei()

◆ z_logmemory()

◆ z_lr_add()

◆ z_lr_add_aca()

◆ z_lr_fnorm()

◆ z_lr_fnormup()

◆ z_lr_recompression()

◆ z_multiindextosingleindex()

◆ z_myisnan()

◆ z_norm_vector()

◆ z_numberingptree()

◆ z_pcomputerange()

◆ z_pgeneralinverse()

◆ z_piksrt_dble_multi()

◆ z_piksrt_int_multi()

◆ z_psvd_truncate()

◆ z_r8_normal_01()

◆ z_r8_uniform_01()

◆ z_random_dp_number()

◆ z_randomizedsvd()

◆ z_randommat()

◆ z_randomsubmat()

◆ z_rccurl()

◆ z_rccurl_sp()