This module implements common operations on batches of mesh functions. More...

Detailed Description

This module implements common operations on batches of mesh functions.

Data Types
interface	batch_add_with_map

interface	batch_axpby
	batchified axpby: \( y = ax + by \) More...

interface	batch_axpy
	batchified version of the BLAS axpy routine: \( y = a*x + y \) More...

interface	batch_copy_with_map

interface	batch_get_points

interface	batch_get_state

interface	batch_mul_mf
	batchified multiplication by mesh function with optional conjugation: \( y_i = f(r_i) * CJ(x_i) \) More...

interface	batch_pointwise_mul

interface	batch_scal
	scale a batch by a constant or vector \( y = a*x \) More...

interface	batch_scal2v
	batchified scale with optional conjugation: \( y = a*CJ(x) \) More...

interface	batch_set_points

interface	batch_set_state
	There are several ways how to call batch_set_state and batch_get_state: More...

interface	batch_xpay
	batchified version of \( y = x + a*y \) More...

Functions/Subroutines
subroutine, public	batch_set_zero (this, np, async)
	fill all mesh functions of the batch with zero More...

subroutine	batch_get_points_accel (this, sp, ep, psi, ldpsi1, ldpsi2)
	GPU version of batch_get_points. More...

subroutine	batch_set_points_accel (this, sp, ep, psi, ldpsi1, ldpsi2)
	GPU version of batch_set_points. More...

integer pure function, public	batch_points_block_size ()
	determine the device block size More...

subroutine	batch_mul_cj (np, xx, yy, zz, conjugate_yy)
	Point-wise multiply two batches with optional conjugation on yy: zz_i = xx_i * CJ(yy_i) More...

subroutine	batch_add_with_map_cpu (np, map, xx, yy, zz)

subroutine	batch_add_with_map_accel (np, map, xx, yy, zz)

subroutine	batch_copy_with_map_cpu (np, map, xx, yy)

subroutine	batch_copy_with_map_accel (np, map, xx, yy)

subroutine, public	batch_split_complex (np, xx, yy, zz)
	extract the real and imaginary parts of a complex batch More...

subroutine	dbatch_axpy_const (np, aa, xx, yy)
	This routine applies a 'pair-wise' axpy operation to all functions of the batches xx and yy, where the same constant aa is used for all functions. More...

subroutine	dbatch_axpy_vec_generic (np, aa, xx, yy, a_start, a_full)
	This routine applies an 'pair-wise' axpy operation to all functions of the batches xx and yy, where the constant aa(ist) is used for the mesh functions in the batch. More...

subroutine, public	dbatch_axpy_function (np, aa, xx, psi, nst)
	This routine performs a set of axpy operations for each function x of a batch (xx), and accumulate the result to y (psi in this case), a single function. More...

subroutine, public	dbatch_ax_function_py (np, aa, psi, yy)
	This routine performs a set of axpy operations adding the same function psi to all functions of a batch (yy),. More...

subroutine	dbatch_scal_const (np, aa, xx)
	scale all functions in a batch by constant aa More...

subroutine	dbatch_scal_vec_generic (np, aa, xx, a_start, a_full)
	scale all functions in a batch by state dependent constant More...

subroutine	dbatch_xpay_vec (np, xx, aa, yy, a_start, a_full)
	calculate yy(ist,:) = xx(ist,:) + aa(ist)*yy(ist,:) for a batch More...

subroutine	dbatch_xpay_const (np, xx, aa, yy)
	calculate yy(ist) = xx(ist) + aa*yy(ist) for a batch More...

subroutine	dbatch_axpby (np, aa, xx, bb, yy)
	calculate yy(ist,:) = aaxx(ist,:) + bbyy(ist,:) for a batch More...

subroutine	dbatch_scal2v (np, aa, xx, yy, conjugate_xx)
	calculate yy(ist,:) = aa*CJ(xx(ist,:)) for a batch More...

subroutine	dbatch_mul_mf (np, ff, xx, yy, conjugate_xx)
	calculate yy(ist,:) = ff(:) * CJ(xx(ist,:)) for a batch More...

subroutine	dbatch_set_state1 (this, ist, np, psi)
	Write a single state with np points into a batch at position ist. More...

subroutine	dbatch_set_state2 (this, index, np, psi)
	Write a single state with np points into a batch at position defined by index. More...

subroutine	dbatch_set_state3 (this, ii, np, psi)
	Write a set of state with np points into a batch. More...

subroutine	dbatch_get_state1 (this, ist, np, psi, async)
	Write a get of state with np points from a batch. More...

subroutine	dbatch_get_state2 (this, index, np, psi, async)

subroutine	dbatch_get_state3 (this, ii, np, psi, async)

subroutine	dbatch_get_points (this, sp, ep, psi)
	copy a set of points into a mesh function More...

subroutine	dbatch_set_points (this, sp, ep, psi)
	copy a set of points into a mesh function More...

subroutine	dbatch_add_with_map (np, map, xx, yy, zz)

subroutine	dbatch_copy_with_map (np, map, xx, yy)

subroutine, public	dbatch_copy_with_map_to_array (np, map, xx, array)
	Transfer a batch from the mesh to an array on the submesh (defined by a map) More...

subroutine	dbatch_axpy_vec (np, aa, xx, yy, a_start, a_full)
	A simple switch between specialized kernels and generic kernels. More...

subroutine	dbatch_scal_vec (np, aa, xx, a_start, a_full)

subroutine	zbatch_axpy_const (np, aa, xx, yy)
	This routine applies a 'pair-wise' axpy operation to all functions of the batches xx and yy, where the same constant aa is used for all functions. More...

subroutine	zbatch_axpy_vec_generic (np, aa, xx, yy, a_start, a_full)
	This routine applies an 'pair-wise' axpy operation to all functions of the batches xx and yy, where the constant aa(ist) is used for the mesh functions in the batch. More...

subroutine, public	zbatch_axpy_function (np, aa, xx, psi, nst)
	This routine performs a set of axpy operations for each function x of a batch (xx), and accumulate the result to y (psi in this case), a single function. More...

subroutine, public	zbatch_ax_function_py (np, aa, psi, yy)
	This routine performs a set of axpy operations adding the same function psi to all functions of a batch (yy),. More...

subroutine	zbatch_scal_const (np, aa, xx)
	scale all functions in a batch by constant aa More...

subroutine	zbatch_scal_vec_generic (np, aa, xx, a_start, a_full)
	scale all functions in a batch by state dependent constant More...

subroutine	zbatch_xpay_vec (np, xx, aa, yy, a_start, a_full)
	calculate yy(ist,:) = xx(ist,:) + aa(ist)*yy(ist,:) for a batch More...

subroutine	zbatch_xpay_const (np, xx, aa, yy)
	calculate yy(ist) = xx(ist) + aa*yy(ist) for a batch More...

subroutine	zbatch_axpby (np, aa, xx, bb, yy)
	calculate yy(ist,:) = aaxx(ist,:) + bbyy(ist,:) for a batch More...

subroutine	zbatch_scal2v (np, aa, xx, yy, conjugate_xx)
	calculate yy(ist,:) = aa*CJ(xx(ist,:)) for a batch More...

subroutine	zbatch_mul_mf (np, ff, xx, yy, conjugate_xx)
	calculate yy(ist,:) = ff(:) * CJ(xx(ist,:)) for a batch More...

subroutine	zbatch_set_state1 (this, ist, np, psi)
	Write a single state with np points into a batch at position ist. More...

subroutine	zbatch_set_state2 (this, index, np, psi)
	Write a single state with np points into a batch at position defined by index. More...

subroutine	zbatch_set_state3 (this, ii, np, psi)
	Write a set of state with np points into a batch. More...

subroutine	zbatch_get_state1 (this, ist, np, psi, async)
	Write a get of state with np points from a batch. More...

subroutine	zbatch_get_state2 (this, index, np, psi, async)

subroutine	zbatch_get_state3 (this, ii, np, psi, async)

subroutine	zbatch_get_points (this, sp, ep, psi)
	copy a set of points into a mesh function More...

subroutine	zbatch_set_points (this, sp, ep, psi)
	copy a set of points into a mesh function More...

subroutine	zbatch_add_with_map (np, map, xx, yy, zz)

subroutine	zbatch_copy_with_map (np, map, xx, yy)

subroutine, public	zbatch_copy_with_map_to_array (np, map, xx, array)
	Transfer a batch from the mesh to an array on the submesh (defined by a map) More...

subroutine	zbatch_axpy_vec (np, aa, xx, yy, a_start, a_full)
	A simple switch between specialized kernels and generic kernels. More...

subroutine	zbatch_scal_vec (np, aa, xx, a_start, a_full)

subroutine	dbatch_axpy_vec_2 (np, aa, xx, yy, a_start, a_full)
	This routine applies an 'pair-wise' axpy operation to all functions of the batches xx and yy, where the constant aa(ist) is used for the mesh functions in the batch. More...

subroutine	dbatch_scal_vec_2 (np, aa, xx, a_start, a_full)
	scale all functions in a batch by state dependent constant More...

subroutine	zbatch_axpy_vec_2 (np, aa, xx, yy, a_start, a_full)
	This routine applies an 'pair-wise' axpy operation to all functions of the batches xx and yy, where the constant aa(ist) is used for the mesh functions in the batch. More...

subroutine	zbatch_scal_vec_2 (np, aa, xx, a_start, a_full)
	scale all functions in a batch by state dependent constant More...

subroutine	dbatch_axpy_vec_3 (np, aa, xx, yy, a_start, a_full)
	This routine applies an 'pair-wise' axpy operation to all functions of the batches xx and yy, where the constant aa(ist) is used for the mesh functions in the batch. More...

subroutine	dbatch_scal_vec_3 (np, aa, xx, a_start, a_full)
	scale all functions in a batch by state dependent constant More...

subroutine	zbatch_axpy_vec_3 (np, aa, xx, yy, a_start, a_full)
	This routine applies an 'pair-wise' axpy operation to all functions of the batches xx and yy, where the constant aa(ist) is used for the mesh functions in the batch. More...

subroutine	zbatch_scal_vec_3 (np, aa, xx, a_start, a_full)
	scale all functions in a batch by state dependent constant More...

subroutine	dbatch_axpy_vec_4 (np, aa, xx, yy, a_start, a_full)
	This routine applies an 'pair-wise' axpy operation to all functions of the batches xx and yy, where the constant aa(ist) is used for the mesh functions in the batch. More...

subroutine	dbatch_scal_vec_4 (np, aa, xx, a_start, a_full)
	scale all functions in a batch by state dependent constant More...

subroutine	zbatch_axpy_vec_4 (np, aa, xx, yy, a_start, a_full)
	This routine applies an 'pair-wise' axpy operation to all functions of the batches xx and yy, where the constant aa(ist) is used for the mesh functions in the batch. More...

subroutine	zbatch_scal_vec_4 (np, aa, xx, a_start, a_full)
	scale all functions in a batch by state dependent constant More...

subroutine	dbatch_axpy_vec_6 (np, aa, xx, yy, a_start, a_full)
	This routine applies an 'pair-wise' axpy operation to all functions of the batches xx and yy, where the constant aa(ist) is used for the mesh functions in the batch. More...

subroutine	dbatch_scal_vec_6 (np, aa, xx, a_start, a_full)
	scale all functions in a batch by state dependent constant More...

subroutine	zbatch_axpy_vec_6 (np, aa, xx, yy, a_start, a_full)
	This routine applies an 'pair-wise' axpy operation to all functions of the batches xx and yy, where the constant aa(ist) is used for the mesh functions in the batch. More...

subroutine	zbatch_scal_vec_6 (np, aa, xx, a_start, a_full)
	scale all functions in a batch by state dependent constant More...

subroutine	dbatch_axpy_vec_8 (np, aa, xx, yy, a_start, a_full)
	This routine applies an 'pair-wise' axpy operation to all functions of the batches xx and yy, where the constant aa(ist) is used for the mesh functions in the batch. More...

subroutine	dbatch_scal_vec_8 (np, aa, xx, a_start, a_full)
	scale all functions in a batch by state dependent constant More...

subroutine	zbatch_axpy_vec_8 (np, aa, xx, yy, a_start, a_full)
	This routine applies an 'pair-wise' axpy operation to all functions of the batches xx and yy, where the constant aa(ist) is used for the mesh functions in the batch. More...

subroutine	zbatch_scal_vec_8 (np, aa, xx, a_start, a_full)
	scale all functions in a batch by state dependent constant More...

Function/Subroutine Documentation

◆ batch_set_zero()

subroutine, public batch_ops_oct_m::batch_set_zero	(	class(batch_t), intent(inout)	this,
		integer, intent(in), optional	np,
		logical, intent(in), optional	async
	)

fill all mesh functions of the batch with zero

Parameters

[in] np number of mesh points to consider. By deafult, all points are set to zero, meaning that np = np_part. This allows to set the batch to zero only for points up to np

Definition at line 264 of file batch_ops.F90.

◆ batch_get_points_accel()

subroutine batch_ops_oct_m::batch_get_points_accel	(	class(batch_t), intent(in)	this,
		integer, intent(in)	sp,
		integer, intent(in)	ep,
		type(accel_mem_t), intent(inout)	psi,
		integer, intent(in)	ldpsi1,
		integer, intent(in)	ldpsi2
	)

private

GPU version of batch_get_points.

Parameters

[in]	this	the batch
[in]	sp	starting point
[in]	ep	end point
[in,out]	psi	device buffer for mesh function
[in]	ldpsi1	number of states: stnst
[in]	ldpsi2	states dimensions: ddim

Definition at line 340 of file batch_ops.F90.

◆ batch_set_points_accel()

subroutine batch_ops_oct_m::batch_set_points_accel	(	class(batch_t), intent(inout)	this,
		integer, intent(in)	sp,
		integer, intent(in)	ep,
		type(accel_mem_t), intent(in)	psi,
		integer, intent(in)	ldpsi1,
		integer, intent(in)	ldpsi2
	)

private

GPU version of batch_set_points.

Parameters

[in,out]	this	the batch
[in]	sp	starting point
[in]	ep	end point
[in]	psi	device buffer of mesh function
[in]	ldpsi1	number of states: stnst
[in]	ldpsi2	state dimensions ddim

Definition at line 407 of file batch_ops.F90.

◆ batch_points_block_size()

integer pure function, public batch_ops_oct_m::batch_points_block_size

determine the device block size

Currently, this is just set to a constant.

Definition at line 476 of file batch_ops.F90.

◆ batch_mul_cj()

subroutine batch_ops_oct_m::batch_mul_cj	(	integer, intent(in)	np,
		class(batch_t), intent(in)	xx,
		class(batch_t), intent(in)	yy,
		class(batch_t), intent(inout)	zz,
		logical, intent(in), optional	conjugate_yy
	)

private

Point-wise multiply two batches with optional conjugation on yy: zz_i = xx_i * CJ(yy_i)

Definition at line 485 of file batch_ops.F90.

◆ batch_add_with_map_cpu()

subroutine batch_ops_oct_m::batch_add_with_map_cpu	(	integer, intent(in)	np,
		integer, dimension(:), intent(in)	map,
		class(batch_t), intent(in)	xx,
		class(batch_t), intent(in)	yy,
		class(batch_t), intent(inout)	zz
	)

private

Definition at line 612 of file batch_ops.F90.

◆ batch_add_with_map_accel()

subroutine batch_ops_oct_m::batch_add_with_map_accel	(	integer, intent(in)	np,
		class(accel_mem_t), intent(in)	map,
		class(batch_t), intent(in)	xx,
		class(batch_t), intent(in)	yy,
		class(batch_t), intent(inout)	zz
	)

private

Definition at line 640 of file batch_ops.F90.

◆ batch_copy_with_map_cpu()

subroutine batch_ops_oct_m::batch_copy_with_map_cpu	(	integer, intent(in)	np,
		integer, dimension(:), intent(in)	map,
		class(batch_t), intent(in)	xx,
		class(batch_t), intent(inout)	yy
	)

private

Definition at line 672 of file batch_ops.F90.

◆ batch_copy_with_map_accel()

subroutine batch_ops_oct_m::batch_copy_with_map_accel	(	integer, intent(in)	np,
		class(accel_mem_t), intent(in)	map,
		class(batch_t), intent(in)	xx,
		class(batch_t), intent(inout)	yy
	)

private

Definition at line 699 of file batch_ops.F90.

◆ batch_split_complex()

subroutine, public batch_ops_oct_m::batch_split_complex	(	integer, intent(in)	np,
		class(batch_t), intent(in)	xx,
		class(batch_t), intent(inout)	yy,
		class(batch_t), intent(inout)	zz
	)

extract the real and imaginary parts of a complex batch

Note: all batches must be of the same status.

Parameters

[in]	np	number of mesh points to consider
[in]	xx	original batch (must be of type TYPE_CMPLX)
[in,out]	yy	batch containing real part of xx (must be of type TYPE_FLOAT)
[in,out]	zz	batch containing imaginary part of xx (must be of type TYPE_FLOAT)

Definition at line 735 of file batch_ops.F90.

◆ dbatch_axpy_const()

subroutine batch_ops_oct_m::dbatch_axpy_const	(	integer, intent(in)	np,
		real(real64), intent(in)	aa,
		class(batch_t), intent(in)	xx,
		class(batch_t), intent(inout)	yy
	)

private

This routine applies a 'pair-wise' axpy operation to all functions of the batches xx and yy, where the same constant aa is used for all functions.

Parameters

[in]	np	number of points
[in,out]	yy	yy(:,:) = aa*xx(:,:) + yy(:,:)

Definition at line 863 of file batch_ops.F90.

◆ dbatch_axpy_vec_generic()

subroutine batch_ops_oct_m::dbatch_axpy_vec_generic	(	integer, intent(in)	np,
		real(real64), dimension(:), intent(in)	aa,
		class(batch_t), intent(in)	xx,
		class(batch_t), intent(inout)	yy,
		integer, intent(in), optional	a_start,
		logical, intent(in), optional	a_full
	)

private

This routine applies an 'pair-wise' axpy operation to all functions of the batches xx and yy, where the constant aa(ist) is used for the mesh functions in the batch.

Parameters

[in]	np	number of points
[in]	aa	array of multipliers
[in,out]	yy	y(ist,:) = aa(ist) * x(ist,:) + y(ist,:)
[in]	a_start	first state to operate on (default = 1)
[in]	a_full	Is aa of size st:nst?

By default, aa is expected to be of size stnst, i.e., an array of the size of all states. The correct states will be picked from the indices stored in each batch. This is used, for example, for computing residuals given the eigenvalues. For a_full=.false., aa is expected to be of size yynst_linear, i.e. it has the size of the batch only.

Definition at line 949 of file batch_ops.F90.

◆ dbatch_axpy_function()

subroutine, public batch_ops_oct_m::dbatch_axpy_function	(	integer, intent(in)	np,
		real(real64), dimension(:), intent(in), contiguous	aa,
		class(batch_t), intent(in)	xx,
		real(real64), dimension(:,:), intent(inout), contiguous	psi,
		integer, intent(in), optional	nst
	)

This routine performs a set of axpy operations for each function x of a batch (xx), and accumulate the result to y (psi in this case), a single function.

Parameters

[in]	np	number of points
[in]	xx	input batch
[in,out]	psi	result: \( psi = \sum_{ist=1}^{nst} aa(ist) * xx(ist) \)
[in]	aa	array of multipliers
[in]	nst	optional upper bound of sum

Definition at line 1098 of file batch_ops.F90.

◆ dbatch_ax_function_py()

subroutine, public batch_ops_oct_m::dbatch_ax_function_py	(	integer, intent(in)	np,
		real(real64), dimension(:), intent(in), contiguous	aa,
		real(real64), dimension(:,:), intent(in), contiguous	psi,
		class(batch_t), intent(inout)	yy
	)

This routine performs a set of axpy operations adding the same function psi to all functions of a batch (yy),.

Parameters

[in]	np	number of points
[in]	aa	array of multipliers
[in]	psi	mesh functions psi
[in,out]	yy	resulting batch yy(ist) = yy(ist) + aa(ist) * psi

Definition at line 1208 of file batch_ops.F90.

◆ dbatch_scal_const()

subroutine batch_ops_oct_m::dbatch_scal_const	(	integer, intent(in)	np,
		real(real64), intent(in)	aa,
		class(batch_t), intent(inout)	xx
	)

private

scale all functions in a batch by constant aa

Parameters

[in]	np	number of points
[in,out]	xx	xx(ist) = xx(ist) * aa

Definition at line 1298 of file batch_ops.F90.

◆ dbatch_scal_vec_generic()

subroutine batch_ops_oct_m::dbatch_scal_vec_generic	(	integer, intent(in)	np,
		real(real64), dimension(:), intent(in)	aa,
		class(batch_t), intent(inout)	xx,
		integer, intent(in), optional	a_start,
		logical, intent(in), optional	a_full
	)

private

scale all functions in a batch by state dependent constant

Parameters

[in]	np	number of points
[in,out]	xx	xx(ist) = xx(ist) * aa(ist)

Definition at line 1336 of file batch_ops.F90.

◆ dbatch_xpay_vec()

subroutine batch_ops_oct_m::dbatch_xpay_vec	(	integer, intent(in)	np,
		class(batch_t), intent(in)	xx,
		real(real64), dimension(:), intent(in)	aa,
		class(batch_t), intent(inout)	yy,
		integer, intent(in), optional	a_start,
		logical, intent(in), optional	a_full
	)

private

calculate yy(ist,:) = xx(ist,:) + aa(ist)*yy(ist,:) for a batch

Parameters

[in]	np	number of points
[in]	aa	array of constants aa(ist)
[in,out]	yy	yy(ist,:) = xx(ist,:) + aa(ist)*yy(ist,:)

Definition at line 1471 of file batch_ops.F90.

◆ dbatch_xpay_const()

subroutine batch_ops_oct_m::dbatch_xpay_const	(	integer, intent(in)	np,
		class(batch_t), intent(in)	xx,
		real(real64), intent(in)	aa,
		class(batch_t), intent(inout)	yy
	)

private

calculate yy(ist) = xx(ist) + aa*yy(ist) for a batch

Parameters

[in]	np	number of points
[in,out]	yy	yy(ist) = xx(ist) + a*yy(ist)

Definition at line 1614 of file batch_ops.F90.

◆ dbatch_axpby()

subroutine batch_ops_oct_m::dbatch_axpby	(	integer, intent(in)	np,
		real(real64), intent(in)	aa,
		class(batch_t), intent(in)	xx,
		real(real64), intent(in)	bb,
		class(batch_t), intent(inout)	yy
	)

private

calculate yy(ist,:) = aa*xx(ist,:) + bb*yy(ist,:) for a batch

Definition at line 1645 of file batch_ops.F90.

◆ dbatch_scal2v()

subroutine batch_ops_oct_m::dbatch_scal2v	(	integer, intent(in)	np,
		real(real64), intent(in)	aa,
		class(batch_t), intent(in)	xx,
		class(batch_t), intent(inout)	yy,
		logical, intent(in), optional	conjugate_xx
	)

private

calculate yy(ist,:) = aa*CJ(xx(ist,:)) for a batch

Definition at line 1768 of file batch_ops.F90.

◆ dbatch_mul_mf()

subroutine batch_ops_oct_m::dbatch_mul_mf	(	integer, intent(in)	np,
		real(real64), dimension(:), intent(in)	ff,
		class(batch_t), intent(in)	xx,
		class(batch_t), intent(inout)	yy,
		logical, intent(in), optional	conjugate_xx
	)

private

calculate yy(ist,:) = ff(:) * CJ(xx(ist,:)) for a batch

Definition at line 1917 of file batch_ops.F90.

◆ dbatch_set_state1()

subroutine batch_ops_oct_m::dbatch_set_state1	(	class(batch_t), intent(inout)	this,
		integer, intent(in)	ist,
		integer, intent(in)	np,
		real(real64), dimension(:), intent(in), contiguous	psi
	)

private

Write a single state with np points into a batch at position ist.

Parameters

[in,out]	this	batch to write the state to
[in]	ist	position where to write
[in]	np	number of points
[in]	psi	the state to write

Definition at line 2076 of file batch_ops.F90.

◆ dbatch_set_state2()

subroutine batch_ops_oct_m::dbatch_set_state2	(	class(batch_t), intent(inout)	this,
		integer, dimension(:), intent(in)	index,
		integer, intent(in)	np,
		real(real64), dimension(:), intent(in), contiguous	psi
	)

private

Write a single state with np points into a batch at position defined by index.

Parameters

[in,out]	this	batch to write the state into
[in]	index	how to access the state. For further information see batch_ops_oct_m::batch_set_state
[in]	np	number of points
[in]	psi	state to write to the batch

Definition at line 2189 of file batch_ops.F90.

◆ dbatch_set_state3()

subroutine batch_ops_oct_m::dbatch_set_state3	(	class(batch_t), intent(inout)	this,
		integer, intent(in)	ii,
		integer, intent(in)	np,
		real(real64), dimension(:, :), intent(in), contiguous	psi
	)

private

Write a set of state with np points into a batch.

Parameters

[in,out]	this	batch to write the states into
[in]	ii	position
[in]	np	number of points
[in]	psi	states to write

Definition at line 2207 of file batch_ops.F90.

◆ dbatch_get_state1()

subroutine batch_ops_oct_m::dbatch_get_state1	(	class(batch_t), intent(in)	this,
		integer, intent(in)	ist,
		integer, intent(in)	np,
		real(real64), dimension(:), intent(out), contiguous	psi,
		logical, intent(in), optional	async
	)

private

Write a get of state with np points from a batch.

Parameters

[in] async only working with pinned memory

Definition at line 2227 of file batch_ops.F90.

◆ dbatch_get_state2()

subroutine batch_ops_oct_m::dbatch_get_state2	(	class(batch_t), intent(in)	this,
		integer, dimension(:), intent(in)	index,
		integer, intent(in)	np,
		real(real64), dimension(:), intent(out), contiguous	psi,
		logical, intent(in), optional	async
	)

private

Parameters

[in] async only working with pinned memory

Definition at line 2348 of file batch_ops.F90.

◆ dbatch_get_state3()

subroutine batch_ops_oct_m::dbatch_get_state3	(	class(batch_t), intent(in)	this,
		integer, intent(in)	ii,
		integer, intent(in)	np,
		real(real64), dimension(:, :), intent(out), contiguous	psi,
		logical, intent(in), optional	async
	)

private

Parameters

[in] async only working with pinned memory

Definition at line 2366 of file batch_ops.F90.

◆ dbatch_get_points()

subroutine batch_ops_oct_m::dbatch_get_points	(	class(batch_t), intent(in)	this,
		integer, intent(in)	sp,
		integer, intent(in)	ep,
		real(real64), dimension(:, :, sp:), intent(inout), contiguous	psi
	)

private

copy a set of points into a mesh function

Parameters

[in]	this	the batch to get points from
[in]	sp	starting point
[in]	ep	end point
[in,out]	psi	mesh function into which to write the points; dimensions (1:nst, 1:dim, sp:ep)

Definition at line 2387 of file batch_ops.F90.

◆ dbatch_set_points()

subroutine batch_ops_oct_m::dbatch_set_points	(	class(batch_t), intent(inout)	this,
		integer, intent(in)	sp,
		integer, intent(in)	ep,
		real(real64), dimension(:, :, sp:), intent(in), contiguous	psi
	)

private

copy a set of points into a mesh function

Parameters

[in,out]	this	the batch to write points into
[in]	sp	starting point
[in]	ep	end point
[in]	psi	mesh function into which to write the points; dimensions (1:nst, 1:dim, sp:ep)

Definition at line 2467 of file batch_ops.F90.

◆ dbatch_add_with_map()

subroutine batch_ops_oct_m::dbatch_add_with_map	(	integer, intent(in)	np,
		integer, dimension(:), intent(in)	map,
		class(batch_t), intent(in)	xx,
		class(batch_t), intent(in)	yy,
		class(batch_t), intent(inout)	zz
	)

private

Definition at line 2552 of file batch_ops.F90.

◆ dbatch_copy_with_map()

subroutine batch_ops_oct_m::dbatch_copy_with_map	(	integer, intent(in)	np,
		integer, dimension(:), intent(in)	map,
		class(batch_t), intent(in)	xx,
		class(batch_t), intent(inout)	yy
	)

private

Definition at line 2594 of file batch_ops.F90.

◆ dbatch_copy_with_map_to_array()

subroutine, public batch_ops_oct_m::dbatch_copy_with_map_to_array	(	integer, intent(in)	np,
		integer, dimension(:), intent(in)	map,
		class(batch_t), intent(in)	xx,
		real(real64), dimension(:,:), intent(inout)	array
	)

Transfer a batch from the mesh to an array on the submesh (defined by a map)

Parameters

[in,out] array (psibnst_linear, submeshnp)

Definition at line 2637 of file batch_ops.F90.

◆ dbatch_axpy_vec()

subroutine batch_ops_oct_m::dbatch_axpy_vec	(	integer, intent(in)	np,
		real(real64), dimension(:), intent(in)	aa,
		class(batch_t), intent(in)	xx,
		class(batch_t), intent(inout)	yy,
		integer, intent(in), optional	a_start,
		logical, intent(in), optional	a_full
	)

private

A simple switch between specialized kernels and generic kernels.

Parameters

[in]	np	number of points
[in]	aa	array of multipliers
[in,out]	yy	y(ist,:) = aa(ist) * x(ist,:) + y(ist,:)
[in]	a_start	first state to operate on (default = 1)
[in]	a_full	Is aa of size st:nst?

Definition at line 2683 of file batch_ops.F90.

◆ dbatch_scal_vec()

subroutine batch_ops_oct_m::dbatch_scal_vec	(	integer, intent(in)	np,
		real(real64), dimension(:), intent(in)	aa,
		class(batch_t), intent(inout)	xx,
		integer, intent(in), optional	a_start,
		logical, intent(in), optional	a_full
	)

private

Parameters

[in]	np	number of points
[in,out]	xx	xx(ist) = xx(ist) * aa(ist)

Definition at line 2707 of file batch_ops.F90.

◆ zbatch_axpy_const()

subroutine batch_ops_oct_m::zbatch_axpy_const	(	integer, intent(in)	np,
		complex(real64), intent(in)	aa,
		class(batch_t), intent(in)	xx,
		class(batch_t), intent(inout)	yy
	)

private

This routine applies a 'pair-wise' axpy operation to all functions of the batches xx and yy, where the same constant aa is used for all functions.

Parameters

[in]	np	number of points
[in,out]	yy	yy(:,:) = aa*xx(:,:) + yy(:,:)

Definition at line 2809 of file batch_ops.F90.

◆ zbatch_axpy_vec_generic()

subroutine batch_ops_oct_m::zbatch_axpy_vec_generic	(	integer, intent(in)	np,
		complex(real64), dimension(:), intent(in)	aa,
		class(batch_t), intent(in)	xx,
		class(batch_t), intent(inout)	yy,
		integer, intent(in), optional	a_start,
		logical, intent(in), optional	a_full
	)

private

This routine applies an 'pair-wise' axpy operation to all functions of the batches xx and yy, where the constant aa(ist) is used for the mesh functions in the batch.

Parameters

[in]	np	number of points
[in]	aa	array of multipliers
[in,out]	yy	y(ist,:) = aa(ist) * x(ist,:) + y(ist,:)
[in]	a_start	first state to operate on (default = 1)
[in]	a_full	Is aa of size st:nst?

By default, aa is expected to be of size stnst, i.e., an array of the size of all states. The correct states will be picked from the indices stored in each batch. This is used, for example, for computing residuals given the eigenvalues. For a_full=.false., aa is expected to be of size yynst_linear, i.e. it has the size of the batch only.

Definition at line 2895 of file batch_ops.F90.

◆ zbatch_axpy_function()

subroutine, public batch_ops_oct_m::zbatch_axpy_function	(	integer, intent(in)	np,
		complex(real64), dimension(:), intent(in), contiguous	aa,
		class(batch_t), intent(in)	xx,
		complex(real64), dimension(:,:), intent(inout), contiguous	psi,
		integer, intent(in), optional	nst
	)

This routine performs a set of axpy operations for each function x of a batch (xx), and accumulate the result to y (psi in this case), a single function.

Parameters

[in]	np	number of points
[in]	xx	input batch
[in,out]	psi	result: \( psi = \sum_{ist=1}^{nst} aa(ist) * xx(ist) \)
[in]	aa	array of multipliers
[in]	nst	optional upper bound of sum

Definition at line 3027 of file batch_ops.F90.

◆ zbatch_ax_function_py()

subroutine, public batch_ops_oct_m::zbatch_ax_function_py	(	integer, intent(in)	np,
		complex(real64), dimension(:), intent(in), contiguous	aa,
		complex(real64), dimension(:,:), intent(in), contiguous	psi,
		class(batch_t), intent(inout)	yy
	)

This routine performs a set of axpy operations adding the same function psi to all functions of a batch (yy),.

Parameters

[in]	np	number of points
[in]	aa	array of multipliers
[in]	psi	mesh functions psi
[in,out]	yy	resulting batch yy(ist) = yy(ist) + aa(ist) * psi

Definition at line 3137 of file batch_ops.F90.

◆ zbatch_scal_const()

subroutine batch_ops_oct_m::zbatch_scal_const	(	integer, intent(in)	np,
		complex(real64), intent(in)	aa,
		class(batch_t), intent(inout)	xx
	)

private

scale all functions in a batch by constant aa

Parameters

[in]	np	number of points
[in,out]	xx	xx(ist) = xx(ist) * aa

Definition at line 3227 of file batch_ops.F90.

◆ zbatch_scal_vec_generic()

subroutine batch_ops_oct_m::zbatch_scal_vec_generic	(	integer, intent(in)	np,
		complex(real64), dimension(:), intent(in)	aa,
		class(batch_t), intent(inout)	xx,
		integer, intent(in), optional	a_start,
		logical, intent(in), optional	a_full
	)

private

scale all functions in a batch by state dependent constant

Parameters

[in]	np	number of points
[in,out]	xx	xx(ist) = xx(ist) * aa(ist)

Definition at line 3265 of file batch_ops.F90.

◆ zbatch_xpay_vec()

subroutine batch_ops_oct_m::zbatch_xpay_vec	(	integer, intent(in)	np,
		class(batch_t), intent(in)	xx,
		complex(real64), dimension(:), intent(in)	aa,
		class(batch_t), intent(inout)	yy,
		integer, intent(in), optional	a_start,
		logical, intent(in), optional	a_full
	)

private

calculate yy(ist,:) = xx(ist,:) + aa(ist)*yy(ist,:) for a batch

Parameters

[in]	np	number of points
[in]	aa	array of constants aa(ist)
[in,out]	yy	yy(ist,:) = xx(ist,:) + aa(ist)*yy(ist,:)

Definition at line 3383 of file batch_ops.F90.

◆ zbatch_xpay_const()

subroutine batch_ops_oct_m::zbatch_xpay_const	(	integer, intent(in)	np,
		class(batch_t), intent(in)	xx,
		complex(real64), intent(in)	aa,
		class(batch_t), intent(inout)	yy
	)

private

calculate yy(ist) = xx(ist) + aa*yy(ist) for a batch

Parameters

[in]	np	number of points
[in,out]	yy	yy(ist) = xx(ist) + a*yy(ist)

Definition at line 3501 of file batch_ops.F90.

◆ zbatch_axpby()

subroutine batch_ops_oct_m::zbatch_axpby	(	integer, intent(in)	np,
		complex(real64), intent(in)	aa,
		class(batch_t), intent(in)	xx,
		complex(real64), intent(in)	bb,
		class(batch_t), intent(inout)	yy
	)

private

calculate yy(ist,:) = aa*xx(ist,:) + bb*yy(ist,:) for a batch

Definition at line 3532 of file batch_ops.F90.

◆ zbatch_scal2v()

subroutine batch_ops_oct_m::zbatch_scal2v	(	integer, intent(in)	np,
		complex(real64), intent(in)	aa,
		class(batch_t), intent(in)	xx,
		class(batch_t), intent(inout)	yy,
		logical, intent(in), optional	conjugate_xx
	)

private

calculate yy(ist,:) = aa*CJ(xx(ist,:)) for a batch

Definition at line 3622 of file batch_ops.F90.

◆ zbatch_mul_mf()

subroutine batch_ops_oct_m::zbatch_mul_mf	(	integer, intent(in)	np,
		complex(real64), dimension(:), intent(in)	ff,
		class(batch_t), intent(in)	xx,
		class(batch_t), intent(inout)	yy,
		logical, intent(in), optional	conjugate_xx
	)

private

calculate yy(ist,:) = ff(:) * CJ(xx(ist,:)) for a batch

Definition at line 3739 of file batch_ops.F90.

◆ zbatch_set_state1()

subroutine batch_ops_oct_m::zbatch_set_state1	(	class(batch_t), intent(inout)	this,
		integer, intent(in)	ist,
		integer, intent(in)	np,
		complex(real64), dimension(:), intent(in), contiguous	psi
	)

private

Write a single state with np points into a batch at position ist.

Parameters

[in,out]	this	batch to write the state to
[in]	ist	position where to write
[in]	np	number of points
[in]	psi	the state to write

Definition at line 3864 of file batch_ops.F90.

◆ zbatch_set_state2()

subroutine batch_ops_oct_m::zbatch_set_state2	(	class(batch_t), intent(inout)	this,
		integer, dimension(:), intent(in)	index,
		integer, intent(in)	np,
		complex(real64), dimension(:), intent(in), contiguous	psi
	)

private

Write a single state with np points into a batch at position defined by index.

Parameters

[in,out]	this	batch to write the state into
[in]	index	how to access the state. For further information see batch_ops_oct_m::batch_set_state
[in]	np	number of points
[in]	psi	state to write to the batch

Definition at line 3964 of file batch_ops.F90.

◆ zbatch_set_state3()

subroutine batch_ops_oct_m::zbatch_set_state3	(	class(batch_t), intent(inout)	this,
		integer, intent(in)	ii,
		integer, intent(in)	np,
		complex(real64), dimension(:, :), intent(in), contiguous	psi
	)

private

Write a set of state with np points into a batch.

Parameters

[in,out]	this	batch to write the states into
[in]	ii	position
[in]	np	number of points
[in]	psi	states to write

Definition at line 3982 of file batch_ops.F90.

◆ zbatch_get_state1()

subroutine batch_ops_oct_m::zbatch_get_state1	(	class(batch_t), intent(in)	this,
		integer, intent(in)	ist,
		integer, intent(in)	np,
		complex(real64), dimension(:), intent(out), contiguous	psi,
		logical, intent(in), optional	async
	)

private

Write a get of state with np points from a batch.

Parameters

[in] async only working with pinned memory

Definition at line 4002 of file batch_ops.F90.

◆ zbatch_get_state2()

subroutine batch_ops_oct_m::zbatch_get_state2	(	class(batch_t), intent(in)	this,
		integer, dimension(:), intent(in)	index,
		integer, intent(in)	np,
		complex(real64), dimension(:), intent(out), contiguous	psi,
		logical, intent(in), optional	async
	)

private

Parameters

[in] async only working with pinned memory

Definition at line 4136 of file batch_ops.F90.

◆ zbatch_get_state3()

subroutine batch_ops_oct_m::zbatch_get_state3	(	class(batch_t), intent(in)	this,
		integer, intent(in)	ii,
		integer, intent(in)	np,
		complex(real64), dimension(:, :), intent(out), contiguous	psi,
		logical, intent(in), optional	async
	)

private

Parameters

[in] async only working with pinned memory

Definition at line 4154 of file batch_ops.F90.

◆ zbatch_get_points()

subroutine batch_ops_oct_m::zbatch_get_points	(	class(batch_t), intent(in)	this,
		integer, intent(in)	sp,
		integer, intent(in)	ep,
		complex(real64), dimension(:, :, sp:), intent(inout), contiguous	psi
	)

private

copy a set of points into a mesh function

Parameters

[in]	this	the batch to get points from
[in]	sp	starting point
[in]	ep	end point
[in,out]	psi	mesh function into which to write the points; dimensions (1:nst, 1:dim, sp:ep)

Definition at line 4175 of file batch_ops.F90.

◆ zbatch_set_points()

subroutine batch_ops_oct_m::zbatch_set_points	(	class(batch_t), intent(inout)	this,
		integer, intent(in)	sp,
		integer, intent(in)	ep,
		complex(real64), dimension(:, :, sp:), intent(in), contiguous	psi
	)

private

copy a set of points into a mesh function

Parameters

[in,out]	this	the batch to write points into
[in]	sp	starting point
[in]	ep	end point
[in]	psi	mesh function into which to write the points; dimensions (1:nst, 1:dim, sp:ep)

Definition at line 4267 of file batch_ops.F90.

◆ zbatch_add_with_map()

subroutine batch_ops_oct_m::zbatch_add_with_map	(	integer, intent(in)	np,
		integer, dimension(:), intent(in)	map,
		class(batch_t), intent(in)	xx,
		class(batch_t), intent(in)	yy,
		class(batch_t), intent(inout)	zz
	)

private

Definition at line 4341 of file batch_ops.F90.

◆ zbatch_copy_with_map()

subroutine batch_ops_oct_m::zbatch_copy_with_map	(	integer, intent(in)	np,
		integer, dimension(:), intent(in)	map,
		class(batch_t), intent(in)	xx,
		class(batch_t), intent(inout)	yy
	)

private

Definition at line 4383 of file batch_ops.F90.

◆ zbatch_copy_with_map_to_array()

subroutine, public batch_ops_oct_m::zbatch_copy_with_map_to_array	(	integer, intent(in)	np,
		integer, dimension(:), intent(in)	map,
		class(batch_t), intent(in)	xx,
		complex(real64), dimension(:,:), intent(inout)	array
	)

Transfer a batch from the mesh to an array on the submesh (defined by a map)

Parameters

[in,out] array (psibnst_linear, submeshnp)

Definition at line 4426 of file batch_ops.F90.

◆ zbatch_axpy_vec()

subroutine batch_ops_oct_m::zbatch_axpy_vec	(	integer, intent(in)	np,
		complex(real64), dimension(:), intent(in)	aa,
		class(batch_t), intent(in)	xx,
		class(batch_t), intent(inout)	yy,
		integer, intent(in), optional	a_start,
		logical, intent(in), optional	a_full
	)

private

A simple switch between specialized kernels and generic kernels.

Parameters

[in]	np	number of points
[in]	aa	array of multipliers
[in,out]	yy	y(ist,:) = aa(ist) * x(ist,:) + y(ist,:)
[in]	a_start	first state to operate on (default = 1)
[in]	a_full	Is aa of size st:nst?

Definition at line 4472 of file batch_ops.F90.

◆ zbatch_scal_vec()

subroutine batch_ops_oct_m::zbatch_scal_vec	(	integer, intent(in)	np,
		complex(real64), dimension(:), intent(in)	aa,
		class(batch_t), intent(inout)	xx,
		integer, intent(in), optional	a_start,
		logical, intent(in), optional	a_full
	)

private

Parameters

[in]	np	number of points
[in,out]	xx	xx(ist) = xx(ist) * aa(ist)

Definition at line 4496 of file batch_ops.F90.

◆ dbatch_axpy_vec_2()

subroutine batch_ops_oct_m::dbatch_axpy_vec_2	(	integer, intent(in)	np,
		real(real64), dimension(:), intent(in)	aa,
		class(batch_t), intent(in)	xx,
		class(batch_t), intent(inout)	yy,
		integer, intent(in), optional	a_start,
		logical, intent(in), optional	a_full
	)

private

This routine applies an 'pair-wise' axpy operation to all functions of the batches xx and yy, where the constant aa(ist) is used for the mesh functions in the batch.

Parameters

[in]	np	number of points
[in]	aa	array of multipliers
[in,out]	yy	y(ist,:) = aa(ist) * x(ist,:) + y(ist,:)
[in]	a_start	first state to operate on (default = 1)
[in]	a_full	Is aa of size st:nst?

By default, aa is expected to be of size stnst, i.e., an array of the size of all states. The correct states will be picked from the indices stored in each batch. This is used, for example, for computing residuals given the eigenvalues. For a_full=.false., aa is expected to be of size yynst_linear, i.e. it has the size of the batch only.

Definition at line 4600 of file batch_ops.F90.

◆ dbatch_scal_vec_2()

subroutine batch_ops_oct_m::dbatch_scal_vec_2	(	integer, intent(in)	np,
		real(real64), dimension(:), intent(in)	aa,
		class(batch_t), intent(inout)	xx,
		integer, intent(in), optional	a_start,
		logical, intent(in), optional	a_full
	)

private

scale all functions in a batch by state dependent constant

Parameters

[in]	np	number of points
[in,out]	xx	xx(ist) = xx(ist) * aa(ist)

Definition at line 4746 of file batch_ops.F90.

◆ zbatch_axpy_vec_2()

subroutine batch_ops_oct_m::zbatch_axpy_vec_2	(	integer, intent(in)	np,
		complex(real64), dimension(:), intent(in)	aa,
		class(batch_t), intent(in)	xx,
		class(batch_t), intent(inout)	yy,
		integer, intent(in), optional	a_start,
		logical, intent(in), optional	a_full
	)

private

This routine applies an 'pair-wise' axpy operation to all functions of the batches xx and yy, where the constant aa(ist) is used for the mesh functions in the batch.

Parameters

[in]	np	number of points
[in]	aa	array of multipliers
[in,out]	yy	y(ist,:) = aa(ist) * x(ist,:) + y(ist,:)
[in]	a_start	first state to operate on (default = 1)
[in]	a_full	Is aa of size st:nst?

By default, aa is expected to be of size stnst, i.e., an array of the size of all states. The correct states will be picked from the indices stored in each batch. This is used, for example, for computing residuals given the eigenvalues. For a_full=.false., aa is expected to be of size yynst_linear, i.e. it has the size of the batch only.

Definition at line 4954 of file batch_ops.F90.

◆ zbatch_scal_vec_2()

subroutine batch_ops_oct_m::zbatch_scal_vec_2	(	integer, intent(in)	np,
		complex(real64), dimension(:), intent(in)	aa,
		class(batch_t), intent(inout)	xx,
		integer, intent(in), optional	a_start,
		logical, intent(in), optional	a_full
	)

private

scale all functions in a batch by state dependent constant

Parameters

[in]	np	number of points
[in,out]	xx	xx(ist) = xx(ist) * aa(ist)

Definition at line 5083 of file batch_ops.F90.

◆ dbatch_axpy_vec_3()

subroutine batch_ops_oct_m::dbatch_axpy_vec_3	(	integer, intent(in)	np,
		real(real64), dimension(:), intent(in)	aa,
		class(batch_t), intent(in)	xx,
		class(batch_t), intent(inout)	yy,
		integer, intent(in), optional	a_start,
		logical, intent(in), optional	a_full
	)

private

This routine applies an 'pair-wise' axpy operation to all functions of the batches xx and yy, where the constant aa(ist) is used for the mesh functions in the batch.

Parameters

[in]	np	number of points
[in]	aa	array of multipliers
[in,out]	yy	y(ist,:) = aa(ist) * x(ist,:) + y(ist,:)
[in]	a_start	first state to operate on (default = 1)
[in]	a_full	Is aa of size st:nst?

By default, aa is expected to be of size stnst, i.e., an array of the size of all states. The correct states will be picked from the indices stored in each batch. This is used, for example, for computing residuals given the eigenvalues. For a_full=.false., aa is expected to be of size yynst_linear, i.e. it has the size of the batch only.

Definition at line 5277 of file batch_ops.F90.

◆ dbatch_scal_vec_3()

subroutine batch_ops_oct_m::dbatch_scal_vec_3	(	integer, intent(in)	np,
		real(real64), dimension(:), intent(in)	aa,
		class(batch_t), intent(inout)	xx,
		integer, intent(in), optional	a_start,
		logical, intent(in), optional	a_full
	)

private

scale all functions in a batch by state dependent constant

Parameters

[in]	np	number of points
[in,out]	xx	xx(ist) = xx(ist) * aa(ist)

Definition at line 5423 of file batch_ops.F90.

◆ zbatch_axpy_vec_3()

subroutine batch_ops_oct_m::zbatch_axpy_vec_3	(	integer, intent(in)	np,
		complex(real64), dimension(:), intent(in)	aa,
		class(batch_t), intent(in)	xx,
		class(batch_t), intent(inout)	yy,
		integer, intent(in), optional	a_start,
		logical, intent(in), optional	a_full
	)

private

This routine applies an 'pair-wise' axpy operation to all functions of the batches xx and yy, where the constant aa(ist) is used for the mesh functions in the batch.

Parameters

[in]	np	number of points
[in]	aa	array of multipliers
[in,out]	yy	y(ist,:) = aa(ist) * x(ist,:) + y(ist,:)
[in]	a_start	first state to operate on (default = 1)
[in]	a_full	Is aa of size st:nst?

By default, aa is expected to be of size stnst, i.e., an array of the size of all states. The correct states will be picked from the indices stored in each batch. This is used, for example, for computing residuals given the eigenvalues. For a_full=.false., aa is expected to be of size yynst_linear, i.e. it has the size of the batch only.

Definition at line 5631 of file batch_ops.F90.

◆ zbatch_scal_vec_3()

subroutine batch_ops_oct_m::zbatch_scal_vec_3	(	integer, intent(in)	np,
		complex(real64), dimension(:), intent(in)	aa,
		class(batch_t), intent(inout)	xx,
		integer, intent(in), optional	a_start,
		logical, intent(in), optional	a_full
	)

private

scale all functions in a batch by state dependent constant

Parameters

[in]	np	number of points
[in,out]	xx	xx(ist) = xx(ist) * aa(ist)

Definition at line 5760 of file batch_ops.F90.

◆ dbatch_axpy_vec_4()

subroutine batch_ops_oct_m::dbatch_axpy_vec_4	(	integer, intent(in)	np,
		real(real64), dimension(:), intent(in)	aa,
		class(batch_t), intent(in)	xx,
		class(batch_t), intent(inout)	yy,
		integer, intent(in), optional	a_start,
		logical, intent(in), optional	a_full
	)

private

This routine applies an 'pair-wise' axpy operation to all functions of the batches xx and yy, where the constant aa(ist) is used for the mesh functions in the batch.

Parameters

[in]	np	number of points
[in]	aa	array of multipliers
[in,out]	yy	y(ist,:) = aa(ist) * x(ist,:) + y(ist,:)
[in]	a_start	first state to operate on (default = 1)
[in]	a_full	Is aa of size st:nst?

By default, aa is expected to be of size stnst, i.e., an array of the size of all states. The correct states will be picked from the indices stored in each batch. This is used, for example, for computing residuals given the eigenvalues. For a_full=.false., aa is expected to be of size yynst_linear, i.e. it has the size of the batch only.

Definition at line 5954 of file batch_ops.F90.

◆ dbatch_scal_vec_4()

subroutine batch_ops_oct_m::dbatch_scal_vec_4	(	integer, intent(in)	np,
		real(real64), dimension(:), intent(in)	aa,
		class(batch_t), intent(inout)	xx,
		integer, intent(in), optional	a_start,
		logical, intent(in), optional	a_full
	)

private

scale all functions in a batch by state dependent constant

Parameters

[in]	np	number of points
[in,out]	xx	xx(ist) = xx(ist) * aa(ist)

Definition at line 6100 of file batch_ops.F90.

◆ zbatch_axpy_vec_4()

subroutine batch_ops_oct_m::zbatch_axpy_vec_4	(	integer, intent(in)	np,
		complex(real64), dimension(:), intent(in)	aa,
		class(batch_t), intent(in)	xx,
		class(batch_t), intent(inout)	yy,
		integer, intent(in), optional	a_start,
		logical, intent(in), optional	a_full
	)

private

This routine applies an 'pair-wise' axpy operation to all functions of the batches xx and yy, where the constant aa(ist) is used for the mesh functions in the batch.

Parameters

[in]	np	number of points
[in]	aa	array of multipliers
[in,out]	yy	y(ist,:) = aa(ist) * x(ist,:) + y(ist,:)
[in]	a_start	first state to operate on (default = 1)
[in]	a_full	Is aa of size st:nst?

By default, aa is expected to be of size stnst, i.e., an array of the size of all states. The correct states will be picked from the indices stored in each batch. This is used, for example, for computing residuals given the eigenvalues. For a_full=.false., aa is expected to be of size yynst_linear, i.e. it has the size of the batch only.

Definition at line 6308 of file batch_ops.F90.

◆ zbatch_scal_vec_4()

subroutine batch_ops_oct_m::zbatch_scal_vec_4	(	integer, intent(in)	np,
		complex(real64), dimension(:), intent(in)	aa,
		class(batch_t), intent(inout)	xx,
		integer, intent(in), optional	a_start,
		logical, intent(in), optional	a_full
	)

private

scale all functions in a batch by state dependent constant

Parameters

[in]	np	number of points
[in,out]	xx	xx(ist) = xx(ist) * aa(ist)

Definition at line 6437 of file batch_ops.F90.

◆ dbatch_axpy_vec_6()

subroutine batch_ops_oct_m::dbatch_axpy_vec_6	(	integer, intent(in)	np,
		real(real64), dimension(:), intent(in)	aa,
		class(batch_t), intent(in)	xx,
		class(batch_t), intent(inout)	yy,
		integer, intent(in), optional	a_start,
		logical, intent(in), optional	a_full
	)

private

This routine applies an 'pair-wise' axpy operation to all functions of the batches xx and yy, where the constant aa(ist) is used for the mesh functions in the batch.

Parameters

[in]	np	number of points
[in]	aa	array of multipliers
[in,out]	yy	y(ist,:) = aa(ist) * x(ist,:) + y(ist,:)
[in]	a_start	first state to operate on (default = 1)
[in]	a_full	Is aa of size st:nst?

By default, aa is expected to be of size stnst, i.e., an array of the size of all states. The correct states will be picked from the indices stored in each batch. This is used, for example, for computing residuals given the eigenvalues. For a_full=.false., aa is expected to be of size yynst_linear, i.e. it has the size of the batch only.

Definition at line 6631 of file batch_ops.F90.

◆ dbatch_scal_vec_6()

subroutine batch_ops_oct_m::dbatch_scal_vec_6	(	integer, intent(in)	np,
		real(real64), dimension(:), intent(in)	aa,
		class(batch_t), intent(inout)	xx,
		integer, intent(in), optional	a_start,
		logical, intent(in), optional	a_full
	)

private

scale all functions in a batch by state dependent constant

Parameters

[in]	np	number of points
[in,out]	xx	xx(ist) = xx(ist) * aa(ist)

Definition at line 6777 of file batch_ops.F90.

◆ zbatch_axpy_vec_6()

subroutine batch_ops_oct_m::zbatch_axpy_vec_6	(	integer, intent(in)	np,
		complex(real64), dimension(:), intent(in)	aa,
		class(batch_t), intent(in)	xx,
		class(batch_t), intent(inout)	yy,
		integer, intent(in), optional	a_start,
		logical, intent(in), optional	a_full
	)

private

This routine applies an 'pair-wise' axpy operation to all functions of the batches xx and yy, where the constant aa(ist) is used for the mesh functions in the batch.

Parameters

[in]	np	number of points
[in]	aa	array of multipliers
[in,out]	yy	y(ist,:) = aa(ist) * x(ist,:) + y(ist,:)
[in]	a_start	first state to operate on (default = 1)
[in]	a_full	Is aa of size st:nst?

By default, aa is expected to be of size stnst, i.e., an array of the size of all states. The correct states will be picked from the indices stored in each batch. This is used, for example, for computing residuals given the eigenvalues. For a_full=.false., aa is expected to be of size yynst_linear, i.e. it has the size of the batch only.

Definition at line 6985 of file batch_ops.F90.

◆ zbatch_scal_vec_6()

subroutine batch_ops_oct_m::zbatch_scal_vec_6	(	integer, intent(in)	np,
		complex(real64), dimension(:), intent(in)	aa,
		class(batch_t), intent(inout)	xx,
		integer, intent(in), optional	a_start,
		logical, intent(in), optional	a_full
	)

private

scale all functions in a batch by state dependent constant

Parameters

[in]	np	number of points
[in,out]	xx	xx(ist) = xx(ist) * aa(ist)

Definition at line 7114 of file batch_ops.F90.

◆ dbatch_axpy_vec_8()

subroutine batch_ops_oct_m::dbatch_axpy_vec_8	(	integer, intent(in)	np,
		real(real64), dimension(:), intent(in)	aa,
		class(batch_t), intent(in)	xx,
		class(batch_t), intent(inout)	yy,
		integer, intent(in), optional	a_start,
		logical, intent(in), optional	a_full
	)

private

This routine applies an 'pair-wise' axpy operation to all functions of the batches xx and yy, where the constant aa(ist) is used for the mesh functions in the batch.

Parameters

[in]	np	number of points
[in]	aa	array of multipliers
[in,out]	yy	y(ist,:) = aa(ist) * x(ist,:) + y(ist,:)
[in]	a_start	first state to operate on (default = 1)
[in]	a_full	Is aa of size st:nst?

By default, aa is expected to be of size stnst, i.e., an array of the size of all states. The correct states will be picked from the indices stored in each batch. This is used, for example, for computing residuals given the eigenvalues. For a_full=.false., aa is expected to be of size yynst_linear, i.e. it has the size of the batch only.

Definition at line 7308 of file batch_ops.F90.

◆ dbatch_scal_vec_8()

subroutine batch_ops_oct_m::dbatch_scal_vec_8	(	integer, intent(in)	np,
		real(real64), dimension(:), intent(in)	aa,
		class(batch_t), intent(inout)	xx,
		integer, intent(in), optional	a_start,
		logical, intent(in), optional	a_full
	)

private

scale all functions in a batch by state dependent constant

Parameters

[in]	np	number of points
[in,out]	xx	xx(ist) = xx(ist) * aa(ist)

Definition at line 7454 of file batch_ops.F90.

◆ zbatch_axpy_vec_8()

subroutine batch_ops_oct_m::zbatch_axpy_vec_8	(	integer, intent(in)	np,
		complex(real64), dimension(:), intent(in)	aa,
		class(batch_t), intent(in)	xx,
		class(batch_t), intent(inout)	yy,
		integer, intent(in), optional	a_start,
		logical, intent(in), optional	a_full
	)

private

This routine applies an 'pair-wise' axpy operation to all functions of the batches xx and yy, where the constant aa(ist) is used for the mesh functions in the batch.

Parameters

[in]	np	number of points
[in]	aa	array of multipliers
[in,out]	yy	y(ist,:) = aa(ist) * x(ist,:) + y(ist,:)
[in]	a_start	first state to operate on (default = 1)
[in]	a_full	Is aa of size st:nst?

By default, aa is expected to be of size stnst, i.e., an array of the size of all states. The correct states will be picked from the indices stored in each batch. This is used, for example, for computing residuals given the eigenvalues. For a_full=.false., aa is expected to be of size yynst_linear, i.e. it has the size of the batch only.

Definition at line 7662 of file batch_ops.F90.

◆ zbatch_scal_vec_8()

subroutine batch_ops_oct_m::zbatch_scal_vec_8	(	integer, intent(in)	np,
		complex(real64), dimension(:), intent(in)	aa,
		class(batch_t), intent(inout)	xx,
		integer, intent(in), optional	a_start,
		logical, intent(in), optional	a_full
	)

private

scale all functions in a batch by state dependent constant

Parameters

[in]	np	number of points
[in,out]	xx	xx(ist) = xx(ist) * aa(ist)

Definition at line 7791 of file batch_ops.F90.

Detailed Description

Data Types

Functions/Subroutines

Function/Subroutine Documentation

◆ batch_set_zero()

◆ batch_get_points_accel()

◆ batch_set_points_accel()

◆ batch_points_block_size()

◆ batch_mul_cj()

◆ batch_add_with_map_cpu()

◆ batch_add_with_map_accel()

◆ batch_copy_with_map_cpu()

◆ batch_copy_with_map_accel()

◆ batch_split_complex()

◆ dbatch_axpy_const()

◆ dbatch_axpy_vec_generic()

◆ dbatch_axpy_function()

◆ dbatch_ax_function_py()

◆ dbatch_scal_const()

◆ dbatch_scal_vec_generic()

◆ dbatch_xpay_vec()

◆ dbatch_xpay_const()

◆ dbatch_axpby()

◆ dbatch_scal2v()

◆ dbatch_mul_mf()

◆ dbatch_set_state1()

◆ dbatch_set_state2()

◆ dbatch_set_state3()

◆ dbatch_get_state1()

◆ dbatch_get_state2()

◆ dbatch_get_state3()

◆ dbatch_get_points()

◆ dbatch_set_points()

◆ dbatch_add_with_map()

◆ dbatch_copy_with_map()

◆ dbatch_copy_with_map_to_array()

◆ dbatch_axpy_vec()

◆ dbatch_scal_vec()

◆ zbatch_axpy_const()

◆ zbatch_axpy_vec_generic()

◆ zbatch_axpy_function()

◆ zbatch_ax_function_py()

◆ zbatch_scal_const()

◆ zbatch_scal_vec_generic()

◆ zbatch_xpay_vec()

◆ zbatch_xpay_const()

◆ zbatch_axpby()

◆ zbatch_scal2v()

◆ zbatch_mul_mf()

◆ zbatch_set_state1()

◆ zbatch_set_state2()

◆ zbatch_set_state3()

◆ zbatch_get_state1()

◆ zbatch_get_state2()

◆ zbatch_get_state3()

◆ zbatch_get_points()

◆ zbatch_set_points()

◆ zbatch_add_with_map()

◆ zbatch_copy_with_map()

◆ zbatch_copy_with_map_to_array()

◆ zbatch_axpy_vec()

◆ zbatch_scal_vec()

◆ dbatch_axpy_vec_2()

◆ dbatch_scal_vec_2()

◆ zbatch_axpy_vec_2()

◆ zbatch_scal_vec_2()

◆ dbatch_axpy_vec_3()

◆ dbatch_scal_vec_3()

◆ zbatch_axpy_vec_3()

◆ zbatch_scal_vec_3()

◆ dbatch_axpy_vec_4()

◆ dbatch_scal_vec_4()

◆ zbatch_axpy_vec_4()

◆ zbatch_scal_vec_4()

◆ dbatch_axpy_vec_6()

◆ dbatch_scal_vec_6()

◆ zbatch_axpy_vec_6()

◆ zbatch_scal_vec_6()

◆ dbatch_axpy_vec_8()

◆ dbatch_scal_vec_8()