Namespaces
namespace	detail

Classes
struct	AuxPrimitiveData
	Data for a single auxiliary primitive (single-center) More...

struct	AuxShellData
	Data for an auxiliary shell. More...

class	Boys

struct	BoysConstants

class	BoysTableGenerator

struct	BoysTableParams

struct	ECoeffs1D

struct	ECoeffs1DDynamic

struct	ECoeffs3D

class	ESPEvaluator
	High-level ESP integral evaluator. More...

struct	PrimitivePairData
	Data for a single primitive pair (precomputed at initialization) More...

struct	RInts

struct	RIntsDynamic

struct	ShellPairData
	Data for a shell pair (all primitive pairs) More...

Typedefs
using	BoysParamsDefault = BoysTableParams< 7, 16, 36, 252 >

using	BoysParamsExtended = BoysTableParams< 7, 32, 117, 819 >

using	BoysParamsHighRes = BoysTableParams< 7, 16, 36, 504 >

using	BoysDefault = Boys< BoysParamsDefault >

using	BoysExtended = Boys< BoysParamsExtended >

Functions
template<typename T , int N>
OCC_GPU_ENABLED OCC_GPU_INLINE void	boys_asymptotic (T x, int m0, T *F)
	Asymptotic expansion for Boys function: F_m(T) ~ sqrt(pi/(4T)) * prod(i-0.5)/T Valid for T > 30.

template<typename T >
OCC_GPU_ENABLED OCC_GPU_INLINE T	boys_asymptotic (T x, int m)

template<typename T , typename Params >
OCC_GPU_ENABLED OCC_GPU_INLINE T	boys_interpolate (const T *table, T x, int m)
	Interpolate F_m(x) from Chebyshev table.

template<typename T , int N, typename Params >
OCC_GPU_ENABLED OCC_GPU_INLINE void	boys_interpolate (const T table, T x, int m0, T F)

template<typename T , int N, typename Params >
OCC_GPU_ENABLED OCC_GPU_INLINE void	boys_evaluate (const T table, T x, int m0, T F)

template<typename T , typename Params >
OCC_GPU_ENABLED OCC_GPU_INLINE T	boys_evaluate (const T *table, T x, int m)

const BoysDefault &	boys ()

const BoysExtended &	boys_extended ()

constexpr int	ncart (int L)

constexpr int	ncartsum (int L)

template<typename T , int A, int B>
OCC_GPU_ENABLED OCC_GPU_INLINE void	compute_e_coeffs_1d (T a, T b, T XAB, ECoeffs1D< T, A, B > &E)

template<typename T , int LA, int LB>
OCC_GPU_ENABLED OCC_GPU_INLINE void	compute_e_coeffs_3d (T a, T b, T Ax, T Ay, T Az, T Bx, T By, T Bz, ECoeffs3D< T, LA, LB > &E)

template<typename T , int LA, int LB>
OCC_GPU_ENABLED OCC_GPU_INLINE void	compute_e_coeffs_3d (T a, T b, const T A, const T B, ECoeffs3D< T, LA, LB > &E)

template<typename T >
OCC_GPU_ENABLED void	compute_e_coeffs_1d_dynamic (int la, int lb, T a, T b, T XAB, ECoeffs1DDynamic< T > &E)

template<typename T , int LA, int LB, int LC, typename BoysParams = BoysParamsDefault>
OCC_GPU_ENABLED void	eri3c_primitive (T a, T b, T gamma, const T A, const T B, const T C, const T boys_table, T *integrals)
	3-center ERI primitive integral (μν\|P) Uses templated RInts for efficiency (no dynamic allocation)

template<typename T , int LA, int LB, int LC, typename BoysParams = BoysParamsDefault>
void	eri3c_contracted (int na_prim, int nb_prim, int nc_prim, const T exponents_a, const T exponents_b, const T exponents_c, const T coeffs_a, const T coeffs_b, const T coeffs_c, const T A, const T B, const T C, const T boys_table, T *integrals)
	3-center ERI contracted integral (μν\|P) for shell triple

template<typename T , typename BoysParams = BoysParamsDefault>
void	eri3c_dispatch (int la, int lb, int lc, int na_prim, int nb_prim, int nc_prim, const T exponents_a, const T exponents_b, const T exponents_c, const T coeffs_a, const T coeffs_b, const T coeffs_c, const T A, const T B, const T C, const T boys_table, T *integrals)
	Dispatch to templated 3c ERI kernel based on runtime angular momenta.

template<typename T >
OCC_GPU_ENABLED OCC_GPU_INLINE constexpr T	hermite_sign (int t, int u, int v)
	Compute Hermite sign factor (-1)^(t+u+v) for a given Hermite index.

template<typename T >
void	apply_hermite_signs (const T in, int L_max, T out)
	Apply Hermite signs to a vector out[h] = sign(h) * in[h] where sign(h) = (-1)^(t+u+v)

template<typename T >
void	density_to_hermite (const T D_block, const T E_ab, int na, int nb, int nherm_ab, T *X_out, bool apply_sign=true)
	Eq.

template<typename T >
void	contract_hermite_eri_forward (const T R_pq, const T X_q, int nherm_ab, int nherm_c, T *Y_p)
	Eq.

template<typename T >
void	hermite_to_aux (const T E_c, const T Y_p, int nc, int nherm_c, T *g_out)
	Eq.

template<typename Scalar >
void	aux_to_hermite (const Scalar E_c, const Scalar d_r, int nc, int nherm_c, Scalar *T_out)
	Eq.

template<typename Scalar >
void	contract_hermite_eri_backward (const Scalar R_pq, const Scalar T_p, int nherm_ab, int nherm_c, Scalar *U_q)
	Eq.

template<typename T >
void	hermite_to_orbital (const T E_ab, const T U_q, int na, int nb, int nherm_ab, T *J_block, bool apply_sign=true)
	Eq.

template<typename T , typename BoysParams = BoysParamsDefault>
void	compute_R_pq_tensor (const ShellPairData< T > &ao_pair, const AuxShellData< T > &aux_shell, const T boys_table, T R_pq_out)
	Compute the accumulated R_pq tensor for a shell pair + aux shell.

template<typename T >
void	compute_accumulated_E_ab (const ShellPairData< T > &shell_pair, T *E_ab_out)
	Compute E_ab matrix accumulated over all primitives in a shell pair This is needed for the forward and backward transformations.

template<typename T >
void	compute_accumulated_E_c (const AuxShellData< T > &aux_shell, T *E_c_out)
	Compute E_c matrix accumulated over all primitives in an aux shell.

std::tuple< size_t, size_t, size_t, size_t >	split_rij_workspace_sizes (int max_l_ao, int max_l_aux)
	Compute maximum workspace sizes for Split-RI-J.

template<typename T >
OCC_GPU_ENABLED OCC_GPU_INLINE constexpr T	spherical_harmonic_factor (int l)

template<typename T , int LA, int LB, typename BoysParams = BoysParamsDefault>
OCC_GPU_ENABLED void	esp_primitive (T a, T b, const T A, const T B, const T C, const T boys_table, T *integrals)
	ESP integral for a single primitive pair at a single point.

template<typename T , int LA, int LB, typename BoysParams = BoysParamsDefault>
OCC_GPU_ENABLED void	esp_contracted (int na_prim, int nb_prim, const T exponents_a, const T exponents_b, const T coeffs_a, const T coeffs_b, const T A, const T B, const T C, const T boys_table, T *integrals)
	ESP integral for contracted shell pair at a single point.

template<typename T , int LA, int LB, typename BoysParams = BoysParamsDefault>
void	esp_contracted_batch (int na_prim, int nb_prim, const T exponents_a, const T exponents_b, const T coeffs_a, const T coeffs_b, const T A, const T B, int npts, const T C, const T boys_table, T *integrals)
	ESP integrals for a shell pair at multiple points (vectorized over points) SHARK-style: E-coefficients computed once per primitive pair, reused for all points.

template<typename T , int LA, int LB>
void	build_e_matrix (const ECoeffs3D< T, LA, LB > &E, T *E_matrix)
	Build E-matrix for a primitive pair.

template<typename T , int LA, int LB>
ShellPairData< T >	precompute_shell_pair (int na_prim, int nb_prim, const T exponents_a, const T exponents_b, const T coeffs_a, const T coeffs_b, const T A, const T B)
	Precompute ShellPairData for a shell pair.

template<int LA, int LB>
constexpr size_t	esp_workspace_size (int npts)
	Calculate workspace size for esp_evaluate_with_precomputed.

template<typename T , int LA, int LB, typename BoysParams = BoysParamsDefault>
void	esp_evaluate_with_precomputed (const ShellPairData< T > &shell_pair, int npts, const T C, const T boys_table, T integrals, T workspace)
	ESP evaluation using precomputed ShellPairData This is the hot path - E-matrices are already computed!

template<typename T >
void	build_aux_e_1d (int lc, T gamma, T *E_1d)
	Build 1D E-coefficients for single-center auxiliary with exponent gamma Uses recurrence: E^{l+1}_t = (1/2γ) E^l_{t-1} + (t+1) E^l_{t+1}.

template<typename T >
void	build_aux_e_matrix_with_gamma (const T E_1d, int lc, T E_matrix)
	Build E-matrix for single-center auxiliary shell with ket signs.

template<typename T , int L>
AuxShellData< T >	precompute_aux_shell (int nprim, const T exponents, const T coeffs, const T *C)
	Precompute auxiliary shell data with gamma-dependent E-coefficients.

template<typename T >
ShellPairData< T >	precompute_shell_pair_dispatch (int la, int lb, int na_prim, int nb_prim, const T exponents_a, const T exponents_b, const T coeffs_a, const T coeffs_b, const T A, const T B)
	Dispatch shell pair precomputation based on runtime angular momenta Supports angular momenta up to L=4 (g functions)

template<typename T >
AuxShellData< T >	precompute_aux_shell_dispatch (int lc, int nprim, const T exponents, const T coeffs, const T *C)
	Dispatch auxiliary shell precomputation based on runtime angular momentum.

template<typename T , int LA, int LB, int LC, typename BoysParams = BoysParamsDefault>
void	eri3c_evaluate_with_precomputed (const ShellPairData< T > &ao_pair, const AuxShellData< T > &aux_shell, const T boys_table, T integrals)
	3-center ERI (μν\|P) using precomputed data

template<typename T , int LP, int LQ, typename BoysParams = BoysParamsDefault>
void	eri2c_evaluate_with_precomputed (const AuxShellData< T > &shell_P, const AuxShellData< T > &shell_Q, const T boys_table, T integrals)
	2-center Coulomb (P\|Q) using precomputed data

template<typename T , typename BoysParams = BoysParamsDefault>
void	esp_primitive_dynamic (int la, int lb, T a, T b, const T A, const T B, const T C, const T boys_table, T *integrals)
	ESP integral with runtime angular momentum.

template<typename T , typename BoysParams = BoysParamsDefault>
void	esp_contracted_dynamic (int la, int lb, int na_prim, int nb_prim, const T exponents_a, const T exponents_b, const T coeffs_a, const T coeffs_b, const T A, const T B, const T C, const T boys_table, T *integrals)
	Contracted ESP with runtime angular momentum.

template<typename T , typename BoysParams = BoysParamsDefault>
void	eri3c_dynamic (int la, int lb, int lc, int na_prim, int nb_prim, int nc_prim, const T exponents_a, const T exponents_b, const T exponents_c, const T coeffs_a, const T coeffs_b, const T coeffs_c, const T A, const T B, const T C, const T boys_table, T *integrals)
	Dynamic 3-center ERI (μν\|P) for runtime angular momentum.

template<typename T , typename BoysParams = BoysParamsDefault>
void	eri2c_dynamic (int lp, int lq, int np_prim, int nq_prim, const T exponents_p, const T exponents_q, const T coeffs_p, const T coeffs_q, const T P, const T Q, const T boys_table, T integrals)
	Dynamic 2-center Coulomb (P\|Q) for runtime angular momentum.

template<typename T >
void	build_E_ab_matrix_dynamic (const ECoeffs1DDynamic< T > &Ex, const ECoeffs1DDynamic< T > &Ey, const ECoeffs1DDynamic< T > &Ez, int la, int lb, T *E_ab)
	Build E_ab matrix [nab × nherm_ab] from 3D E-coefficients Row order: standard Cartesian order (descending in first index)

template<typename T >
void	build_E_c_matrix_dynamic (const T E_c_1d, int lc, T E_c_matrix)
	Build E_c matrix [nc × nherm_c] from single-center E-coefficients with ket signs The sign (-1)^(tx+ty+tz) is baked into the matrix.

template<typename T >
void	build_R_tensor_dynamic (const RIntsDynamic< T > &R, int L_ab, int lc, T *R_tensor)
	Build R_tensor [nherm_ab × nherm_c] from R-integrals R_tensor[h_ab, h_c] = R[combined_hermite_index(h_ab, h_c)].

template<typename T , typename BoysParams = BoysParamsDefault>
void	eri3c_dynamic_matmul (int la, int lb, int lc, int na_prim, int nb_prim, int nc_prim, const T exponents_a, const T exponents_b, const T exponents_c, const T coeffs_a, const T coeffs_b, const T coeffs_c, const T A, const T B, const T C, const T boys_table, T *integrals)
	Dynamic 3-center ERI using matrix multiplication for contraction This version pre-allocates workspace and uses Eigen matmul.

template<typename T , typename BoysParams = BoysParamsDefault>
void	eri3c_dynamic_matmul_workspace (int la, int lb, int lc, int na_prim, int nb_prim, int nc_prim, const T exponents_a, const T exponents_b, const T exponents_c, const T coeffs_a, const T coeffs_b, const T coeffs_c, const T A, const T B, const T C, const T boys_table, T integrals, T E_ab_workspace, T E_c_workspace, T R_workspace, T *temp_workspace)
	Dynamic 3-center ERI using matrix multiplication with external workspace This version eliminates internal allocations by using caller-provided buffers.

std::tuple< size_t, size_t, size_t, size_t >	eri3c_workspace_sizes (int la, int lb, int lc)
	Required workspace sizes for eri3c_dynamic_matmul_workspace Returns sizes as tuple: (E_ab_size, E_c_size, R_tensor_size, temp_size)

std::tuple< size_t, size_t, size_t, size_t >	eri3c_workspace_sizes_max (int max_l_ao, int max_l_aux)
	Maximum workspace sizes given max angular momenta Useful for pre-allocating workspace for all shell combinations.

constexpr int	nherm (int L)

constexpr int	nhermsum (int L)

OCC_GPU_ENABLED OCC_GPU_INLINE constexpr int	hermite_index (int t, int u, int v)

template<typename T , int L, typename BoysParams >
OCC_GPU_ENABLED void	compute_r_ints (const T *boys_table, T p, T PCx, T PCy, T PCz, RInts< T, L > &R)

template<typename T , int L>
OCC_GPU_ENABLED void	compute_r_ints (const T boys_table, T p, T PCx, T PCy, T PCz, T R_out)

template<typename T , typename BoysParams >
OCC_GPU_ENABLED void	compute_r_ints_dynamic (const T *boys_table, int L, T p, T PCx, T PCy, T PCz, RIntsDynamic< T > &R)

template<typename T , typename BoysParams = BoysParamsDefault>
OCC_GPU_ENABLED OCC_GPU_INLINE void	compute_r_ints_L0_batch (const T boys_table, T p, int npts, const T PCx, const T PCy, const T PCz, T *R_out)

template<typename T , typename BoysParams = BoysParamsDefault>
OCC_GPU_ENABLED OCC_GPU_INLINE void	compute_r_ints_L1_batch (const T boys_table, T p, int npts, const T PCx, const T PCy, const T PCz, T *R_out)

template<typename T , typename BoysParams = BoysParamsDefault>
OCC_GPU_ENABLED OCC_GPU_INLINE void	compute_r_ints_L2_batch (const T boys_table, T p, int npts, const T PCx, const T PCy, const T PCz, T *R_out)

template<typename T , typename BoysParams = BoysParamsDefault>
OCC_GPU_ENABLED OCC_GPU_INLINE void	compute_r_ints_L3_batch (const T boys_table, T p, int npts, const T PCx, const T PCy, const T PCz, T *R_out)

template<typename T , typename BoysParams = BoysParamsDefault>
OCC_GPU_ENABLED OCC_GPU_INLINE void	compute_r_ints_L4_batch (const T boys_table, T p, int npts, const T PCx, const T PCy, const T PCz, T *R_out)

template<typename T , typename BoysParams = BoysParamsDefault>
OCC_GPU_ENABLED OCC_GPU_INLINE void	compute_r_ints_L5_batch (const T boys_table, T p, int npts, const T PCx, const T PCy, const T PCz, T *R_out)

template<typename T , typename BoysParams = BoysParamsDefault>
OCC_GPU_ENABLED OCC_GPU_INLINE void	compute_r_ints_L6_batch (const T boys_table, T p, int npts, const T PCx, const T PCy, const T PCz, T *R_out)

template<typename T , int L, typename BoysParams = BoysParamsDefault>
OCC_GPU_ENABLED OCC_GPU_INLINE void	compute_r_ints_batch (const T boys_table, T p, int npts, const T PCx, const T PCy, const T PCz, T *R_out)

template<typename T , typename BoysParams = BoysParamsDefault>
void	compute_r_ints_L0_eigen (const T *boys_table, T p, int npts, const Eigen::Array< T, Eigen::Dynamic, 1 > &PCx, const Eigen::Array< T, Eigen::Dynamic, 1 > &PCy, const Eigen::Array< T, Eigen::Dynamic, 1 > &PCz, Eigen::Ref< Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor > > R_out)

template<typename T , typename BoysParams = BoysParamsDefault>
void	compute_r_ints_L1_eigen (const T *boys_table, T p, int npts, const Eigen::Array< T, Eigen::Dynamic, 1 > &PCx, const Eigen::Array< T, Eigen::Dynamic, 1 > &PCy, const Eigen::Array< T, Eigen::Dynamic, 1 > &PCz, Eigen::Ref< Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor > > R_out)

template<typename T , typename BoysParams = BoysParamsDefault>
void	compute_r_ints_L2_eigen (const T *boys_table, T p, int npts, const Eigen::Array< T, Eigen::Dynamic, 1 > &PCx, const Eigen::Array< T, Eigen::Dynamic, 1 > &PCy, const Eigen::Array< T, Eigen::Dynamic, 1 > &PCz, Eigen::Ref< Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor > > R_out)

template<typename T , typename BoysParams = BoysParamsDefault>
void	compute_r_ints_L3_eigen (const T *boys_table, T p, int npts, const Eigen::Array< T, Eigen::Dynamic, 1 > &PCx, const Eigen::Array< T, Eigen::Dynamic, 1 > &PCy, const Eigen::Array< T, Eigen::Dynamic, 1 > &PCz, Eigen::Ref< Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor > > R_out)

template<typename T , typename BoysParams = BoysParamsDefault>
void	compute_r_ints_L4_eigen (const T *boys_table, T p, int npts, const Eigen::Array< T, Eigen::Dynamic, 1 > &PCx, const Eigen::Array< T, Eigen::Dynamic, 1 > &PCy, const Eigen::Array< T, Eigen::Dynamic, 1 > &PCz, Eigen::Ref< Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor > > R_out)

template<typename T , typename BoysParams = BoysParamsDefault>
void	compute_r_ints_L6_eigen (const T *boys_table, T p, int npts, const Eigen::Array< T, Eigen::Dynamic, 1 > &PCx, const Eigen::Array< T, Eigen::Dynamic, 1 > &PCy, const Eigen::Array< T, Eigen::Dynamic, 1 > &PCz, Eigen::Ref< Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor > > R_out)

template<typename T , int L, typename BoysParams = BoysParamsDefault>
void	compute_r_ints_batch_direct (const T *boys_table, T p, int npts, T Px, T Py, T Pz, const Eigen::Ref< const Eigen::Matrix< T, 3, Eigen::Dynamic > > &C, Eigen::Ref< Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor > > R_out)

template<typename T , typename BoysParams = BoysParamsDefault>
OCC_GPU_ENABLED OCC_GPU_INLINE void	compute_r_ints_3c_L0 (const T boys_table, T p, T PCx, T PCy, T PCz, T R)

template<typename T , typename BoysParams = BoysParamsDefault>
OCC_GPU_ENABLED OCC_GPU_INLINE void	compute_r_ints_3c_L1 (const T boys_table, T p, T PCx, T PCy, T PCz, T R)

template<typename T , typename BoysParams = BoysParamsDefault>
OCC_GPU_ENABLED OCC_GPU_INLINE void	compute_r_ints_3c_L2 (const T boys_table, T p, T PCx, T PCy, T PCz, T R)

template<typename T , typename BoysParams = BoysParamsDefault>
OCC_GPU_ENABLED OCC_GPU_INLINE void	compute_r_ints_3c_L3 (const T boys_table, T p, T PCx, T PCy, T PCz, T R)

template<typename T , typename BoysParams = BoysParamsDefault>
OCC_GPU_ENABLED OCC_GPU_INLINE void	compute_r_ints_3c_L4 (const T boys_table, T p, T PCx, T PCy, T PCz, T R)

template<typename T , typename BoysParams = BoysParamsDefault>
OCC_GPU_ENABLED OCC_GPU_INLINE void	compute_r_ints_3c_L5 (const T boys_table, T p, T PCx, T PCy, T PCz, T R)

template<typename T , typename BoysParams = BoysParamsDefault>
OCC_GPU_ENABLED OCC_GPU_INLINE void	compute_r_ints_3c_L6 (const T boys_table, T p, T PCx, T PCy, T PCz, T R)

template<typename T , typename BoysParams = BoysParamsDefault>
OCC_GPU_ENABLED OCC_GPU_INLINE void	fused_forward_0_0 (const T boys_table, T alpha, T PCx, T PCy, T PCz, T prefactor, const T X, T *Y)

template<typename T , typename BoysParams = BoysParamsDefault>
OCC_GPU_ENABLED OCC_GPU_INLINE void	fused_backward_0_0 (const T boys_table, T alpha, T PCx, T PCy, T PCz, T prefactor, const T T_vec, T *U)

template<typename T , typename BoysParams = BoysParamsDefault>
OCC_GPU_ENABLED OCC_GPU_INLINE void	fused_forward_0_1 (const T boys_table, T alpha, T PCx, T PCy, T PCz, T prefactor, const T X, T *Y)

template<typename T , typename BoysParams = BoysParamsDefault>
OCC_GPU_ENABLED OCC_GPU_INLINE void	fused_backward_0_1 (const T boys_table, T alpha, T PCx, T PCy, T PCz, T prefactor, const T T_vec, T *U)

template<typename T , typename BoysParams = BoysParamsDefault>
OCC_GPU_ENABLED OCC_GPU_INLINE void	fused_forward_1_0 (const T boys_table, T alpha, T PCx, T PCy, T PCz, T prefactor, const T X, T *Y)

template<typename T , typename BoysParams = BoysParamsDefault>
OCC_GPU_ENABLED OCC_GPU_INLINE void	fused_backward_1_0 (const T boys_table, T alpha, T PCx, T PCy, T PCz, T prefactor, const T T_vec, T *U)

template<typename T , typename BoysParams = BoysParamsDefault>
OCC_GPU_ENABLED OCC_GPU_INLINE void	fused_forward_0_2 (const T boys_table, T alpha, T PCx, T PCy, T PCz, T prefactor, const T X, T *Y)

template<typename T , typename BoysParams = BoysParamsDefault>
OCC_GPU_ENABLED OCC_GPU_INLINE void	fused_backward_0_2 (const T boys_table, T alpha, T PCx, T PCy, T PCz, T prefactor, const T T_vec, T *U)

template<typename T , typename BoysParams = BoysParamsDefault>
OCC_GPU_ENABLED OCC_GPU_INLINE void	fused_forward_2_0 (const T boys_table, T alpha, T PCx, T PCy, T PCz, T prefactor, const T X, T *Y)

template<typename T , typename BoysParams = BoysParamsDefault>
OCC_GPU_ENABLED OCC_GPU_INLINE void	fused_backward_2_0 (const T boys_table, T alpha, T PCx, T PCy, T PCz, T prefactor, const T T_vec, T *U)

template<typename T , typename BoysParams = BoysParamsDefault>
OCC_GPU_ENABLED OCC_GPU_INLINE void	fused_forward_1_1 (const T boys_table, T alpha, T PCx, T PCy, T PCz, T prefactor, const T X, T *Y)

template<typename T , typename BoysParams = BoysParamsDefault>
OCC_GPU_ENABLED OCC_GPU_INLINE void	fused_backward_1_1 (const T boys_table, T alpha, T PCx, T PCy, T PCz, T prefactor, const T T_vec, T *U)

template<typename T , typename BoysParams = BoysParamsDefault>
OCC_GPU_ENABLED OCC_GPU_INLINE void	fused_forward_0_3 (const T boys_table, T alpha, T PCx, T PCy, T PCz, T prefactor, const T X, T *Y)

template<typename T , typename BoysParams = BoysParamsDefault>
OCC_GPU_ENABLED OCC_GPU_INLINE void	fused_backward_0_3 (const T boys_table, T alpha, T PCx, T PCy, T PCz, T prefactor, const T T_vec, T *U)

template<typename T , typename BoysParams = BoysParamsDefault>
OCC_GPU_ENABLED OCC_GPU_INLINE void	fused_forward_3_0 (const T boys_table, T alpha, T PCx, T PCy, T PCz, T prefactor, const T X, T *Y)

template<typename T , typename BoysParams = BoysParamsDefault>
OCC_GPU_ENABLED OCC_GPU_INLINE void	fused_backward_3_0 (const T boys_table, T alpha, T PCx, T PCy, T PCz, T prefactor, const T T_vec, T *U)

template<typename T , typename BoysParams = BoysParamsDefault>
OCC_GPU_ENABLED OCC_GPU_INLINE void	fused_forward_1_2 (const T boys_table, T alpha, T PCx, T PCy, T PCz, T prefactor, const T X, T *Y)

template<typename T , typename BoysParams = BoysParamsDefault>
OCC_GPU_ENABLED OCC_GPU_INLINE void	fused_backward_1_2 (const T boys_table, T alpha, T PCx, T PCy, T PCz, T prefactor, const T T_vec, T *U)

template<typename T , typename BoysParams = BoysParamsDefault>
OCC_GPU_ENABLED OCC_GPU_INLINE void	fused_forward_2_1 (const T boys_table, T alpha, T PCx, T PCy, T PCz, T prefactor, const T X, T *Y)

template<typename T , typename BoysParams = BoysParamsDefault>
OCC_GPU_ENABLED OCC_GPU_INLINE void	fused_backward_2_1 (const T boys_table, T alpha, T PCx, T PCy, T PCz, T prefactor, const T T_vec, T *U)

template<typename T , typename BoysParams = BoysParamsDefault>
OCC_GPU_ENABLED OCC_GPU_INLINE bool	fused_forward_dispatch (const T boys_table, int L_ab, int lc, T alpha, T PCx, T PCy, T PCz, T prefactor, const T X, T *Y)

template<typename T , typename BoysParams = BoysParamsDefault>
OCC_GPU_ENABLED OCC_GPU_INLINE bool	fused_backward_dispatch (const T boys_table, int L_ab, int lc, T alpha, T PCx, T PCy, T PCz, T prefactor, const T T_vec, T *U)

template<typename T , typename BoysParams = BoysParamsDefault>
OCC_GPU_ENABLED OCC_GPU_INLINE void	compute_r_ints_3c_dispatch (const T boys_table, int L, T p, T PCx, T PCy, T PCz, T R)
	Dispatch to specialized kernel based on runtime L value Falls back to generic compute_r_ints_dynamic for L > 6.

template<typename T , typename BoysParams = BoysParamsDefault>
OCC_GPU_ENABLED OCC_GPU_INLINE void	compute_r_ints_3c_dispatch (const T *boys_table, int L, T p, T PCx, T PCy, T PCz, RIntsDynamic< T > &R)
	Version that writes directly to RIntsDynamic.

Variables
constexpr int	LMAX = 6

constexpr int	E1D_MAX_SIZE = (LMAX + 1) * (LMAX + 1) * (2 * LMAX + 1)

constexpr int	RINTS_LMAX = 15

constexpr int	RINTS_MAX_SIZE = nhermsum(RINTS_LMAX)

Typedef Documentation

◆ BoysDefault

using occ::ints::BoysDefault = typedef Boys<BoysParamsDefault>

◆ BoysExtended

using occ::ints::BoysExtended = typedef Boys<BoysParamsExtended>

◆ BoysParamsDefault

using occ::ints::BoysParamsDefault = typedef BoysTableParams<7, 16, 36, 252>

◆ BoysParamsExtended

using occ::ints::BoysParamsExtended = typedef BoysTableParams<7, 32, 117, 819>

◆ BoysParamsHighRes

using occ::ints::BoysParamsHighRes = typedef BoysTableParams<7, 16, 36, 504>

Function Documentation

◆ apply_hermite_signs()

template<typename T >

void occ::ints::apply_hermite_signs	(	const T *	in,
		int	L_max,
		T *	out
	)

Apply Hermite signs to a vector out[h] = sign(h) * in[h] where sign(h) = (-1)^(t+u+v)

◆ aux_to_hermite()

template<typename Scalar >

void occ::ints::aux_to_hermite	(	const Scalar *	E_c,
		const Scalar *	d_r,
		int	nc,
		int	nherm_c,
		Scalar *	T_out
	)

Eq.

20: Transform from aux orbital to Hermite basis T_p = sum_r E^r_p * d_r

Parameters

E_c	Aux E-matrix [nc * nherm_c] row-major
d_r	Fitted coefficients [nc]
nc	Number of aux Cartesian functions
nherm_c	Number of aux Hermite functions
T_out	Output [nherm_c]

◆ boys()

const BoysDefault & occ::ints::boys ( )

inline

◆ boys_asymptotic() [1/2]

template<typename T >

OCC_GPU_ENABLED OCC_GPU_INLINE T occ::ints::boys_asymptotic	(	T	x,
		int	m
	)

◆ boys_asymptotic() [2/2]

template<typename T , int N>

OCC_GPU_ENABLED OCC_GPU_INLINE void occ::ints::boys_asymptotic	(	T	x,
		int	m0,
		T *	F
	)

Asymptotic expansion for Boys function: F_m(T) ~ sqrt(pi/(4T)) * prod(i-0.5)/T Valid for T > 30.

◆ boys_evaluate() [1/2]

template<typename T , typename Params >

OCC_GPU_ENABLED OCC_GPU_INLINE T occ::ints::boys_evaluate	(	const T *	table,
		T	x,
		int	m
	)

◆ boys_evaluate() [2/2]

template<typename T , int N, typename Params >

OCC_GPU_ENABLED OCC_GPU_INLINE void occ::ints::boys_evaluate	(	const T *	table,
		T	x,
		int	m0,
		T *	F
	)

◆ boys_extended()

const BoysExtended & occ::ints::boys_extended ( )

inline

◆ boys_interpolate() [1/2]

template<typename T , typename Params >

OCC_GPU_ENABLED OCC_GPU_INLINE T occ::ints::boys_interpolate	(	const T *	table,
		T	x,
		int	m
	)

Interpolate F_m(x) from Chebyshev table.

◆ boys_interpolate() [2/2]

template<typename T , int N, typename Params >

OCC_GPU_ENABLED OCC_GPU_INLINE void occ::ints::boys_interpolate	(	const T *	table,
		T	x,
		int	m0,
		T *	F
	)

◆ build_aux_e_1d()

template<typename T >

void occ::ints::build_aux_e_1d	(	int	lc,
		T	gamma,
		T *	E_1d
	)

Build 1D E-coefficients for single-center auxiliary with exponent gamma Uses recurrence: E^{l+1}_t = (1/2γ) E^l_{t-1} + (t+1) E^l_{t+1}.

Parameters

lc	Angular momentum
gamma	Exponent
E_1d	Output: [(lc+1) × (lc+1)] 1D E-coefficients

◆ build_aux_e_matrix_with_gamma()

template<typename T >

void occ::ints::build_aux_e_matrix_with_gamma	(	const T *	E_1d,
		int	lc,
		T *	E_matrix
	)

Build E-matrix for single-center auxiliary shell with ket signs.

Parameters

E_1d	1D E-coefficients from build_aux_e_1d
lc	Angular momentum
E_matrix	Output: [nc × nherm] E-matrix with ket signs baked in

◆ build_E_ab_matrix_dynamic()

template<typename T >

void occ::ints::build_E_ab_matrix_dynamic	(	const ECoeffs1DDynamic< T > &	Ex,
		const ECoeffs1DDynamic< T > &	Ey,
		const ECoeffs1DDynamic< T > &	Ez,
		int	la,
		int	lb,
		T *	E_ab
	)

Build E_ab matrix [nab × nherm_ab] from 3D E-coefficients Row order: standard Cartesian order (descending in first index)

◆ build_E_c_matrix_dynamic()

template<typename T >

void occ::ints::build_E_c_matrix_dynamic	(	const T *	E_c_1d,
		int	lc,
		T *	E_c_matrix
	)

Build E_c matrix [nc × nherm_c] from single-center E-coefficients with ket signs The sign (-1)^(tx+ty+tz) is baked into the matrix.

◆ build_e_matrix()

template<typename T , int LA, int LB>

void occ::ints::build_e_matrix	(	const ECoeffs3D< T, LA, LB > &	E,
		T *	E_matrix
	)

Build E-matrix for a primitive pair.

◆ build_R_tensor_dynamic()

template<typename T >

void occ::ints::build_R_tensor_dynamic	(	const RIntsDynamic< T > &	R,
		int	L_ab,
		int	lc,
		T *	R_tensor
	)

Build R_tensor [nherm_ab × nherm_c] from R-integrals R_tensor[h_ab, h_c] = R[combined_hermite_index(h_ab, h_c)].

◆ compute_accumulated_E_ab()

template<typename T >

void occ::ints::compute_accumulated_E_ab	(	const ShellPairData< T > &	shell_pair,
		T *	E_ab_out
	)

Compute E_ab matrix accumulated over all primitives in a shell pair This is needed for the forward and backward transformations.

NOTE: For TRUE Split-RI-J, we do NOT include prefactors here. The E-matrix is just a pure basis transformation weighted by contraction coefficients. All integral prefactors (2π/p, spherical factors, etc.) go into R_pq.

Parameters

shell_pair	Precomputed shell pair data
E_ab_out	Output [nab * nherm_ab] row-major

◆ compute_accumulated_E_c()

template<typename T >

void occ::ints::compute_accumulated_E_c	(	const AuxShellData< T > &	aux_shell,
		T *	E_c_out
	)

Compute E_c matrix accumulated over all primitives in an aux shell.

Parameters

aux_shell	Precomputed aux shell data
E_c_out	Output [nc * nherm_c] row-major

◆ compute_e_coeffs_1d()

template<typename T , int A, int B>

OCC_GPU_ENABLED OCC_GPU_INLINE void occ::ints::compute_e_coeffs_1d	(	T	a,
		T	b,
		T	XAB,
		ECoeffs1D< T, A, B > &	E
	)

◆ compute_e_coeffs_1d_dynamic()

template<typename T >

OCC_GPU_ENABLED void occ::ints::compute_e_coeffs_1d_dynamic	(	int	la,
		int	lb,
		T	a,
		T	b,
		T	XAB,
		ECoeffs1DDynamic< T > &	E
	)

◆ compute_e_coeffs_3d() [1/2]

template<typename T , int LA, int LB>

OCC_GPU_ENABLED OCC_GPU_INLINE void occ::ints::compute_e_coeffs_3d	(	T	a,
		T	b,
		const T *	A,
		const T *	B,
		ECoeffs3D< T, LA, LB > &	E
	)

◆ compute_e_coeffs_3d() [2/2]

template<typename T , int LA, int LB>

OCC_GPU_ENABLED OCC_GPU_INLINE void occ::ints::compute_e_coeffs_3d	(	T	a,
		T	b,
		T	Ax,
		T	Ay,
		T	Az,
		T	Bx,
		T	By,
		T	Bz,
		ECoeffs3D< T, LA, LB > &	E
	)

◆ compute_r_ints() [1/2]

template<typename T , int L, typename BoysParams >

OCC_GPU_ENABLED void occ::ints::compute_r_ints	(	const T *	boys_table,
		T	p,
		T	PCx,
		T	PCy,
		T	PCz,
		RInts< T, L > &	R
	)

◆ compute_r_ints() [2/2]

template<typename T , int L>

OCC_GPU_ENABLED void occ::ints::compute_r_ints	(	const T *	boys_table,
		T	p,
		T	PCx,
		T	PCy,
		T	PCz,
		T *	R_out
	)

◆ compute_r_ints_3c_dispatch() [1/2]

template<typename T , typename BoysParams = BoysParamsDefault>

OCC_GPU_ENABLED OCC_GPU_INLINE void occ::ints::compute_r_ints_3c_dispatch	(	const T *	boys_table,
		int	L,
		T	p,
		T	PCx,
		T	PCy,
		T	PCz,
		RIntsDynamic< T > &	R
	)

Version that writes directly to RIntsDynamic.

◆ compute_r_ints_3c_dispatch() [2/2]

template<typename T , typename BoysParams = BoysParamsDefault>

OCC_GPU_ENABLED OCC_GPU_INLINE void occ::ints::compute_r_ints_3c_dispatch	(	const T *	boys_table,
		int	L,
		T	p,
		T	PCx,
		T	PCy,
		T	PCz,
		T *	R
	)

Dispatch to specialized kernel based on runtime L value Falls back to generic compute_r_ints_dynamic for L > 6.

◆ compute_r_ints_3c_L0()

template<typename T , typename BoysParams = BoysParamsDefault>

OCC_GPU_ENABLED OCC_GPU_INLINE void occ::ints::compute_r_ints_3c_L0	(	const T *	boys_table,
		T	p,
		T	PCx,
		T	PCy,
		T	PCz,
		T *	R
	)

◆ compute_r_ints_3c_L1()

template<typename T , typename BoysParams = BoysParamsDefault>

OCC_GPU_ENABLED OCC_GPU_INLINE void occ::ints::compute_r_ints_3c_L1	(	const T *	boys_table,
		T	p,
		T	PCx,
		T	PCy,
		T	PCz,
		T *	R
	)

◆ compute_r_ints_3c_L2()

template<typename T , typename BoysParams = BoysParamsDefault>

OCC_GPU_ENABLED OCC_GPU_INLINE void occ::ints::compute_r_ints_3c_L2	(	const T *	boys_table,
		T	p,
		T	PCx,
		T	PCy,
		T	PCz,
		T *	R
	)

◆ compute_r_ints_3c_L3()

template<typename T , typename BoysParams = BoysParamsDefault>

OCC_GPU_ENABLED OCC_GPU_INLINE void occ::ints::compute_r_ints_3c_L3	(	const T *	boys_table,
		T	p,
		T	PCx,
		T	PCy,
		T	PCz,
		T *	R
	)

◆ compute_r_ints_3c_L4()

template<typename T , typename BoysParams = BoysParamsDefault>

OCC_GPU_ENABLED OCC_GPU_INLINE void occ::ints::compute_r_ints_3c_L4	(	const T *	boys_table,
		T	p,
		T	PCx,
		T	PCy,
		T	PCz,
		T *	R
	)

◆ compute_r_ints_3c_L5()

template<typename T , typename BoysParams = BoysParamsDefault>

OCC_GPU_ENABLED OCC_GPU_INLINE void occ::ints::compute_r_ints_3c_L5	(	const T *	boys_table,
		T	p,
		T	PCx,
		T	PCy,
		T	PCz,
		T *	R
	)

◆ compute_r_ints_3c_L6()

template<typename T , typename BoysParams = BoysParamsDefault>

OCC_GPU_ENABLED OCC_GPU_INLINE void occ::ints::compute_r_ints_3c_L6	(	const T *	boys_table,
		T	p,
		T	PCx,
		T	PCy,
		T	PCz,
		T *	R
	)

◆ compute_r_ints_batch()

template<typename T , int L, typename BoysParams = BoysParamsDefault>

OCC_GPU_ENABLED OCC_GPU_INLINE void occ::ints::compute_r_ints_batch	(	const T *	boys_table,
		T	p,
		int	npts,
		const T *	PCx,
		const T *	PCy,
		const T *	PCz,
		T *	R_out
	)

◆ compute_r_ints_batch_direct()

template<typename T , int L, typename BoysParams = BoysParamsDefault>

void occ::ints::compute_r_ints_batch_direct	(	const T *	boys_table,
		T	p,
		int	npts,
		T	Px,
		T	Py,
		T	Pz,
		const Eigen::Ref< const Eigen::Matrix< T, 3, Eigen::Dynamic > > &	C,
		Eigen::Ref< Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor > >	R_out
	)

◆ compute_r_ints_dynamic()

template<typename T , typename BoysParams >

OCC_GPU_ENABLED void occ::ints::compute_r_ints_dynamic	(	const T *	boys_table,
		int	L,
		T	p,
		T	PCx,
		T	PCy,
		T	PCz,
		RIntsDynamic< T > &	R
	)

◆ compute_r_ints_L0_batch()

template<typename T , typename BoysParams = BoysParamsDefault>

OCC_GPU_ENABLED OCC_GPU_INLINE void occ::ints::compute_r_ints_L0_batch	(	const T *	boys_table,
		T	p,
		int	npts,
		const T *	PCx,
		const T *	PCy,
		const T *	PCz,
		T *	R_out
	)

◆ compute_r_ints_L0_eigen()

template<typename T , typename BoysParams = BoysParamsDefault>

void occ::ints::compute_r_ints_L0_eigen	(	const T *	boys_table,
		T	p,
		int	npts,
		const Eigen::Array< T, Eigen::Dynamic, 1 > &	PCx,
		const Eigen::Array< T, Eigen::Dynamic, 1 > &	PCy,
		const Eigen::Array< T, Eigen::Dynamic, 1 > &	PCz,
		Eigen::Ref< Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor > >	R_out
	)

◆ compute_r_ints_L1_batch()

template<typename T , typename BoysParams = BoysParamsDefault>

OCC_GPU_ENABLED OCC_GPU_INLINE void occ::ints::compute_r_ints_L1_batch	(	const T *	boys_table,
		T	p,
		int	npts,
		const T *	PCx,
		const T *	PCy,
		const T *	PCz,
		T *	R_out
	)

◆ compute_r_ints_L1_eigen()

template<typename T , typename BoysParams = BoysParamsDefault>

void occ::ints::compute_r_ints_L1_eigen	(	const T *	boys_table,
		T	p,
		int	npts,
		const Eigen::Array< T, Eigen::Dynamic, 1 > &	PCx,
		const Eigen::Array< T, Eigen::Dynamic, 1 > &	PCy,
		const Eigen::Array< T, Eigen::Dynamic, 1 > &	PCz,
		Eigen::Ref< Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor > >	R_out
	)

◆ compute_r_ints_L2_batch()

template<typename T , typename BoysParams = BoysParamsDefault>

OCC_GPU_ENABLED OCC_GPU_INLINE void occ::ints::compute_r_ints_L2_batch	(	const T *	boys_table,
		T	p,
		int	npts,
		const T *	PCx,
		const T *	PCy,
		const T *	PCz,
		T *	R_out
	)

◆ compute_r_ints_L2_eigen()

template<typename T , typename BoysParams = BoysParamsDefault>

void occ::ints::compute_r_ints_L2_eigen	(	const T *	boys_table,
		T	p,
		int	npts,
		const Eigen::Array< T, Eigen::Dynamic, 1 > &	PCx,
		const Eigen::Array< T, Eigen::Dynamic, 1 > &	PCy,
		const Eigen::Array< T, Eigen::Dynamic, 1 > &	PCz,
		Eigen::Ref< Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor > >	R_out
	)

◆ compute_r_ints_L3_batch()

template<typename T , typename BoysParams = BoysParamsDefault>

OCC_GPU_ENABLED OCC_GPU_INLINE void occ::ints::compute_r_ints_L3_batch	(	const T *	boys_table,
		T	p,
		int	npts,
		const T *	PCx,
		const T *	PCy,
		const T *	PCz,
		T *	R_out
	)

◆ compute_r_ints_L3_eigen()

template<typename T , typename BoysParams = BoysParamsDefault>

void occ::ints::compute_r_ints_L3_eigen	(	const T *	boys_table,
		T	p,
		int	npts,
		const Eigen::Array< T, Eigen::Dynamic, 1 > &	PCx,
		const Eigen::Array< T, Eigen::Dynamic, 1 > &	PCy,
		const Eigen::Array< T, Eigen::Dynamic, 1 > &	PCz,
		Eigen::Ref< Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor > >	R_out
	)

◆ compute_r_ints_L4_batch()

template<typename T , typename BoysParams = BoysParamsDefault>

OCC_GPU_ENABLED OCC_GPU_INLINE void occ::ints::compute_r_ints_L4_batch	(	const T *	boys_table,
		T	p,
		int	npts,
		const T *	PCx,
		const T *	PCy,
		const T *	PCz,
		T *	R_out
	)

◆ compute_r_ints_L4_eigen()

template<typename T , typename BoysParams = BoysParamsDefault>

void occ::ints::compute_r_ints_L4_eigen	(	const T *	boys_table,
		T	p,
		int	npts,
		const Eigen::Array< T, Eigen::Dynamic, 1 > &	PCx,
		const Eigen::Array< T, Eigen::Dynamic, 1 > &	PCy,
		const Eigen::Array< T, Eigen::Dynamic, 1 > &	PCz,
		Eigen::Ref< Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor > >	R_out
	)

◆ compute_r_ints_L5_batch()

template<typename T , typename BoysParams = BoysParamsDefault>

OCC_GPU_ENABLED OCC_GPU_INLINE void occ::ints::compute_r_ints_L5_batch	(	const T *	boys_table,
		T	p,
		int	npts,
		const T *	PCx,
		const T *	PCy,
		const T *	PCz,
		T *	R_out
	)

◆ compute_r_ints_L6_batch()

template<typename T , typename BoysParams = BoysParamsDefault>

OCC_GPU_ENABLED OCC_GPU_INLINE void occ::ints::compute_r_ints_L6_batch	(	const T *	boys_table,
		T	p,
		int	npts,
		const T *	PCx,
		const T *	PCy,
		const T *	PCz,
		T *	R_out
	)

◆ compute_r_ints_L6_eigen()

template<typename T , typename BoysParams = BoysParamsDefault>

void occ::ints::compute_r_ints_L6_eigen	(	const T *	boys_table,
		T	p,
		int	npts,
		const Eigen::Array< T, Eigen::Dynamic, 1 > &	PCx,
		const Eigen::Array< T, Eigen::Dynamic, 1 > &	PCy,
		const Eigen::Array< T, Eigen::Dynamic, 1 > &	PCz,
		Eigen::Ref< Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor > >	R_out
	)

◆ compute_R_pq_tensor()

template<typename T , typename BoysParams = BoysParamsDefault>

void occ::ints::compute_R_pq_tensor	(	const ShellPairData< T > &	ao_pair,
		const AuxShellData< T > &	aux_shell,
		const T *	boys_table,
		T *	R_pq_out
	)

Compute the accumulated R_pq tensor for a shell pair + aux shell.

R_pq connects Hermite indices from AO pair (index q, size nherm_ab) to Hermite indices from aux shell (index p, size nherm_c).

The tensor is: R_pq[q, p] = sum_prims prefactor * R(t_q + t_p, u_q + u_p, v_q + v_p)

where (t_q, u_q, v_q) are Hermite indices for the AO pair and (t_p, u_p, v_p) are Hermite indices for the aux shell.

Parameters

ao_pair	Precomputed AO shell pair data
aux_shell	Precomputed aux shell data
boys_table	Boys function interpolation table
R_pq_out	Output tensor [nherm_ab * nherm_c]

◆ contract_hermite_eri_backward()

template<typename Scalar >

void occ::ints::contract_hermite_eri_backward	(	const Scalar *	R_pq,
		const Scalar *	T_p,
		int	nherm_ab,
		int	nherm_c,
		Scalar *	U_q
	)

Eq.

21: Contract Hermite ERI tensor (backward) U_q = sum_p R_pq * T_p

NOTE: Uses the SAME R_pq as forward pass - this is the key insight!

Parameters

R_pq	Hermite ERI tensor [nherm_ab * nherm_c] row-major
T_p	Hermite aux coefficients [nherm_c]
nherm_ab	Rows of R_pq
nherm_c	Cols of R_pq
U_q	Output [nherm_ab]

◆ contract_hermite_eri_forward()

template<typename T >

void occ::ints::contract_hermite_eri_forward	(	const T *	R_pq,
		const T *	X_q,
		int	nherm_ab,
		int	nherm_c,
		T *	Y_p
	)

Eq.

18: Contract Hermite ERI tensor with Hermite density (forward) Y_p = sum_q R_pq * X_q

Parameters

R_pq	Hermite ERI tensor [nherm_ab * nherm_c] row-major
X_q	Hermite density [nherm_ab]
nherm_ab	Rows of R_pq (AO pair Hermite count)
nherm_c	Cols of R_pq (aux Hermite count)
Y_p	Output [nherm_c]

◆ density_to_hermite()

template<typename T >

void occ::ints::density_to_hermite	(	const T *	D_block,
		const T *	E_ab,
		int	na,
		int	nb,
		int	nherm_ab,
		T *	X_out,
		bool	apply_sign = `true`
	)

Eq.

17: Transform density block to Hermite basis X_q = sum_{ab} D[ab] * E[ab, q] * (-1)^q

This is the first step of Split-RI-J: contract density with E-matrix. The sign (-1)^q is applied here.

Parameters

D_block	Density matrix block [na * nb] (flattened)
E_ab	E-matrix [nab, nherm_ab] row-major (from primitives, accumulated)
na,nb	Shell sizes
nherm_ab	Number of Hermite functions
X_out	Output Hermite density [nherm_ab]
apply_sign	If true, apply (-1)^q signs (default true)

◆ eri2c_dynamic()

template<typename T , typename BoysParams = BoysParamsDefault>

void occ::ints::eri2c_dynamic	(	int	lp,
		int	lq,
		int	np_prim,
		int	nq_prim,
		const T *	exponents_p,
		const T *	exponents_q,
		const T *	coeffs_p,
		const T *	coeffs_q,
		const T *	P,
		const T *	Q,
		const T *	boys_table,
		T *	integrals
	)

Dynamic 2-center Coulomb (P|Q) for runtime angular momentum.

◆ eri2c_evaluate_with_precomputed()

template<typename T , int LP, int LQ, typename BoysParams = BoysParamsDefault>

void occ::ints::eri2c_evaluate_with_precomputed	(	const AuxShellData< T > &	shell_P,
		const AuxShellData< T > &	shell_Q,
		const T *	boys_table,
		T *	integrals
	)

2-center Coulomb (P|Q) using precomputed data

Computes: (P|Q) = Σ_prims (2π)/(p+q) × cp × cq × Σ_{tuv} E^{PQ}_{tuv} × R_{tuv}(p+q, P-Q)

Parameters

shell_P	Precomputed auxiliary shell P data
shell_Q	Precomputed auxiliary shell Q data
boys_table	Boys function interpolation table
integrals	Output: [nc_P, nc_Q] integrals

◆ eri3c_contracted()

template<typename T , int LA, int LB, int LC, typename BoysParams = BoysParamsDefault>

void occ::ints::eri3c_contracted	(	int	na_prim,
		int	nb_prim,
		int	nc_prim,
		const T *	exponents_a,
		const T *	exponents_b,
		const T *	exponents_c,
		const T *	coeffs_a,
		const T *	coeffs_b,
		const T *	coeffs_c,
		const T *	A,
		const T *	B,
		const T *	C,
		const T *	boys_table,
		T *	integrals
	)

3-center ERI contracted integral (μν|P) for shell triple

◆ eri3c_dispatch()

template<typename T , typename BoysParams = BoysParamsDefault>

void occ::ints::eri3c_dispatch	(	int	la,
		int	lb,
		int	lc,
		int	na_prim,
		int	nb_prim,
		int	nc_prim,
		const T *	exponents_a,
		const T *	exponents_b,
		const T *	exponents_c,
		const T *	coeffs_a,
		const T *	coeffs_b,
		const T *	coeffs_c,
		const T *	A,
		const T *	B,
		const T *	C,
		const T *	boys_table,
		T *	integrals
	)

Dispatch to templated 3c ERI kernel based on runtime angular momenta.

◆ eri3c_dynamic()

template<typename T , typename BoysParams = BoysParamsDefault>

void occ::ints::eri3c_dynamic	(	int	la,
		int	lb,
		int	lc,
		int	na_prim,
		int	nb_prim,
		int	nc_prim,
		const T *	exponents_a,
		const T *	exponents_b,
		const T *	exponents_c,
		const T *	coeffs_a,
		const T *	coeffs_b,
		const T *	coeffs_c,
		const T *	A,
		const T *	B,
		const T *	C,
		const T *	boys_table,
		T *	integrals
	)

Dynamic 3-center ERI (μν|P) for runtime angular momentum.

◆ eri3c_dynamic_matmul()

template<typename T , typename BoysParams = BoysParamsDefault>

void occ::ints::eri3c_dynamic_matmul	(	int	la,
		int	lb,
		int	lc,
		int	na_prim,
		int	nb_prim,
		int	nc_prim,
		const T *	exponents_a,
		const T *	exponents_b,
		const T *	exponents_c,
		const T *	coeffs_a,
		const T *	coeffs_b,
		const T *	coeffs_c,
		const T *	A,
		const T *	B,
		const T *	C,
		const T *	boys_table,
		T *	integrals
	)

Dynamic 3-center ERI using matrix multiplication for contraction This version pre-allocates workspace and uses Eigen matmul.

◆ eri3c_dynamic_matmul_workspace()

template<typename T , typename BoysParams = BoysParamsDefault>

void occ::ints::eri3c_dynamic_matmul_workspace	(	int	la,
		int	lb,
		int	lc,
		int	na_prim,
		int	nb_prim,
		int	nc_prim,
		const T *	exponents_a,
		const T *	exponents_b,
		const T *	exponents_c,
		const T *	coeffs_a,
		const T *	coeffs_b,
		const T *	coeffs_c,
		const T *	A,
		const T *	B,
		const T *	C,
		const T *	boys_table,
		T *	integrals,
		T *	E_ab_workspace,
		T *	E_c_workspace,
		T *	R_workspace,
		T *	temp_workspace
	)

Dynamic 3-center ERI using matrix multiplication with external workspace This version eliminates internal allocations by using caller-provided buffers.

Parameters

la,lb,lc	Angular momenta
na_prim,nb_prim,nc_prim	Number of primitives
exponents_a/b/c	Primitive exponents
coeffs_a/b/c	Contraction coefficients
A,B,C	Shell centers
boys_table	Boys function interpolation table
integrals	Output buffer [nab × nc]
E_ab_workspace	Workspace for E_ab matrix [nab × nherm_ab]
E_c_workspace	Workspace for E_c matrix [nc × nherm_c]
R_workspace	Workspace for R tensor [nherm_ab × nherm_c]
temp_workspace	Workspace for temp matrix [nab × nherm_c]

◆ eri3c_evaluate_with_precomputed()

template<typename T , int LA, int LB, int LC, typename BoysParams = BoysParamsDefault>

void occ::ints::eri3c_evaluate_with_precomputed	(	const ShellPairData< T > &	ao_pair,
		const AuxShellData< T > &	aux_shell,
		const T *	boys_table,
		T *	integrals
	)

3-center ERI (μν|P) using precomputed data

Computes: (μν|P) = Σ_prims (2π^{5/2})/(p*q*√(p+q)) × ca×cb×cc × Σ_{tuv,xyz} E^{ab}_{tuv} × E^c_{xyz} × R_{t+x,u+y,v+z}(α, PC_scaled) where p = α_a + α_b, q = γ_c, α = pq/(p+q)

Parameters

ao_pair	Precomputed AO shell pair data
aux_shell	Precomputed auxiliary shell data
boys_table	Boys function interpolation table
integrals	Output: [nab, nc] integrals

◆ eri3c_primitive()

template<typename T , int LA, int LB, int LC, typename BoysParams = BoysParamsDefault>

OCC_GPU_ENABLED void occ::ints::eri3c_primitive	(	T	a,
		T	b,
		T	gamma,
		const T *	A,
		const T *	B,
		const T *	C,
		const T *	boys_table,
		T *	integrals
	)

3-center ERI primitive integral (μν|P) Uses templated RInts for efficiency (no dynamic allocation)

◆ eri3c_workspace_sizes()

std::tuple< size_t, size_t, size_t, size_t > occ::ints::eri3c_workspace_sizes	(	int	la,
		int	lb,
		int	lc
	)

inline

Required workspace sizes for eri3c_dynamic_matmul_workspace Returns sizes as tuple: (E_ab_size, E_c_size, R_tensor_size, temp_size)

◆ eri3c_workspace_sizes_max()

std::tuple< size_t, size_t, size_t, size_t > occ::ints::eri3c_workspace_sizes_max	(	int	max_l_ao,
		int	max_l_aux
	)

inline

Maximum workspace sizes given max angular momenta Useful for pre-allocating workspace for all shell combinations.

◆ esp_contracted()

template<typename T , int LA, int LB, typename BoysParams = BoysParamsDefault>

OCC_GPU_ENABLED void occ::ints::esp_contracted	(	int	na_prim,
		int	nb_prim,
		const T *	exponents_a,
		const T *	exponents_b,
		const T *	coeffs_a,
		const T *	coeffs_b,
		const T *	A,
		const T *	B,
		const T *	C,
		const T *	boys_table,
		T *	integrals
	)

ESP integral for contracted shell pair at a single point.

◆ esp_contracted_batch()

template<typename T , int LA, int LB, typename BoysParams = BoysParamsDefault>

void occ::ints::esp_contracted_batch	(	int	na_prim,
		int	nb_prim,
		const T *	exponents_a,
		const T *	exponents_b,
		const T *	coeffs_a,
		const T *	coeffs_b,
		const T *	A,
		const T *	B,
		int	npts,
		const T *	C,
		const T *	boys_table,
		T *	integrals
	)

ESP integrals for a shell pair at multiple points (vectorized over points) SHARK-style: E-coefficients computed once per primitive pair, reused for all points.

◆ esp_contracted_dynamic()

template<typename T , typename BoysParams = BoysParamsDefault>

void occ::ints::esp_contracted_dynamic	(	int	la,
		int	lb,
		int	na_prim,
		int	nb_prim,
		const T *	exponents_a,
		const T *	exponents_b,
		const T *	coeffs_a,
		const T *	coeffs_b,
		const T *	A,
		const T *	B,
		const T *	C,
		const T *	boys_table,
		T *	integrals
	)

Contracted ESP with runtime angular momentum.

◆ esp_evaluate_with_precomputed()

template<typename T , int LA, int LB, typename BoysParams = BoysParamsDefault>

void occ::ints::esp_evaluate_with_precomputed	(	const ShellPairData< T > &	shell_pair,
		int	npts,
		const T *	C,
		const T *	boys_table,
		T *	integrals,
		T *	workspace
	)

ESP evaluation using precomputed ShellPairData This is the hot path - E-matrices are already computed!

Parameters

shell_pair	Precomputed shell pair data
npts	Number of grid points
C	Grid point coordinates [3 * npts]
boys_table	Boys function interpolation table
integrals	Output buffer [npts * nab]
workspace	Pre-allocated workspace (size >= esp_workspace_size<LA,LB>(npts))

◆ esp_primitive()

template<typename T , int LA, int LB, typename BoysParams = BoysParamsDefault>

OCC_GPU_ENABLED void occ::ints::esp_primitive	(	T	a,
		T	b,
		const T *	A,
		const T *	B,
		const T *	C,
		const T *	boys_table,
		T *	integrals
	)

ESP integral for a single primitive pair at a single point.

Parameters

a	Exponent of first primitive
b	Exponent of second primitive
A	Center of first primitive [3]
B	Center of second primitive [3]
C	Point at which to evaluate potential [3]
boys_table	Boys function interpolation table
integrals	Output: (la+1)(la+2)/2 × (lb+1)(lb+2)/2 integrals

The output layout is [Cartesian_a][Cartesian_b] in standard order

◆ esp_primitive_dynamic()

template<typename T , typename BoysParams = BoysParamsDefault>

void occ::ints::esp_primitive_dynamic	(	int	la,
		int	lb,
		T	a,
		T	b,
		const T *	A,
		const T *	B,
		const T *	C,
		const T *	boys_table,
		T *	integrals
	)

ESP integral with runtime angular momentum.

◆ esp_workspace_size()

template<int LA, int LB>

constexpr size_t occ::ints::esp_workspace_size ( int npts )

constexpr

Calculate workspace size for esp_evaluate_with_precomputed.

◆ fused_backward_0_0()

template<typename T , typename BoysParams = BoysParamsDefault>

OCC_GPU_ENABLED OCC_GPU_INLINE void occ::ints::fused_backward_0_0	(	const T *	boys_table,
		T	alpha,
		T	PCx,
		T	PCy,
		T	PCz,
		T	prefactor,
		const T *	T_vec,
		T *	U
	)

◆ fused_backward_0_1()

template<typename T , typename BoysParams = BoysParamsDefault>

OCC_GPU_ENABLED OCC_GPU_INLINE void occ::ints::fused_backward_0_1	(	const T *	boys_table,
		T	alpha,
		T	PCx,
		T	PCy,
		T	PCz,
		T	prefactor,
		const T *	T_vec,
		T *	U
	)

◆ fused_backward_0_2()

template<typename T , typename BoysParams = BoysParamsDefault>

OCC_GPU_ENABLED OCC_GPU_INLINE void occ::ints::fused_backward_0_2	(	const T *	boys_table,
		T	alpha,
		T	PCx,
		T	PCy,
		T	PCz,
		T	prefactor,
		const T *	T_vec,
		T *	U
	)

◆ fused_backward_0_3()

template<typename T , typename BoysParams = BoysParamsDefault>

OCC_GPU_ENABLED OCC_GPU_INLINE void occ::ints::fused_backward_0_3	(	const T *	boys_table,
		T	alpha,
		T	PCx,
		T	PCy,
		T	PCz,
		T	prefactor,
		const T *	T_vec,
		T *	U
	)

◆ fused_backward_1_0()

template<typename T , typename BoysParams = BoysParamsDefault>

OCC_GPU_ENABLED OCC_GPU_INLINE void occ::ints::fused_backward_1_0	(	const T *	boys_table,
		T	alpha,
		T	PCx,
		T	PCy,
		T	PCz,
		T	prefactor,
		const T *	T_vec,
		T *	U
	)

◆ fused_backward_1_1()

template<typename T , typename BoysParams = BoysParamsDefault>

OCC_GPU_ENABLED OCC_GPU_INLINE void occ::ints::fused_backward_1_1	(	const T *	boys_table,
		T	alpha,
		T	PCx,
		T	PCy,
		T	PCz,
		T	prefactor,
		const T *	T_vec,
		T *	U
	)

◆ fused_backward_1_2()

template<typename T , typename BoysParams = BoysParamsDefault>

OCC_GPU_ENABLED OCC_GPU_INLINE void occ::ints::fused_backward_1_2	(	const T *	boys_table,
		T	alpha,
		T	PCx,
		T	PCy,
		T	PCz,
		T	prefactor,
		const T *	T_vec,
		T *	U
	)

◆ fused_backward_2_0()

template<typename T , typename BoysParams = BoysParamsDefault>

OCC_GPU_ENABLED OCC_GPU_INLINE void occ::ints::fused_backward_2_0	(	const T *	boys_table,
		T	alpha,
		T	PCx,
		T	PCy,
		T	PCz,
		T	prefactor,
		const T *	T_vec,
		T *	U
	)

◆ fused_backward_2_1()

template<typename T , typename BoysParams = BoysParamsDefault>

OCC_GPU_ENABLED OCC_GPU_INLINE void occ::ints::fused_backward_2_1	(	const T *	boys_table,
		T	alpha,
		T	PCx,
		T	PCy,
		T	PCz,
		T	prefactor,
		const T *	T_vec,
		T *	U
	)

◆ fused_backward_3_0()

template<typename T , typename BoysParams = BoysParamsDefault>

OCC_GPU_ENABLED OCC_GPU_INLINE void occ::ints::fused_backward_3_0	(	const T *	boys_table,
		T	alpha,
		T	PCx,
		T	PCy,
		T	PCz,
		T	prefactor,
		const T *	T_vec,
		T *	U
	)

◆ fused_backward_dispatch()

template<typename T , typename BoysParams = BoysParamsDefault>

OCC_GPU_ENABLED OCC_GPU_INLINE bool occ::ints::fused_backward_dispatch	(	const T *	boys_table,
		int	L_ab,
		int	lc,
		T	alpha,
		T	PCx,
		T	PCy,
		T	PCz,
		T	prefactor,
		const T *	T_vec,
		T *	U
	)

◆ fused_forward_0_0()

template<typename T , typename BoysParams = BoysParamsDefault>

OCC_GPU_ENABLED OCC_GPU_INLINE void occ::ints::fused_forward_0_0	(	const T *	boys_table,
		T	alpha,
		T	PCx,
		T	PCy,
		T	PCz,
		T	prefactor,
		const T *	X,
		T *	Y
	)

◆ fused_forward_0_1()

template<typename T , typename BoysParams = BoysParamsDefault>

OCC_GPU_ENABLED OCC_GPU_INLINE void occ::ints::fused_forward_0_1	(	const T *	boys_table,
		T	alpha,
		T	PCx,
		T	PCy,
		T	PCz,
		T	prefactor,
		const T *	X,
		T *	Y
	)

◆ fused_forward_0_2()

template<typename T , typename BoysParams = BoysParamsDefault>

OCC_GPU_ENABLED OCC_GPU_INLINE void occ::ints::fused_forward_0_2	(	const T *	boys_table,
		T	alpha,
		T	PCx,
		T	PCy,
		T	PCz,
		T	prefactor,
		const T *	X,
		T *	Y
	)

◆ fused_forward_0_3()

template<typename T , typename BoysParams = BoysParamsDefault>

OCC_GPU_ENABLED OCC_GPU_INLINE void occ::ints::fused_forward_0_3	(	const T *	boys_table,
		T	alpha,
		T	PCx,
		T	PCy,
		T	PCz,
		T	prefactor,
		const T *	X,
		T *	Y
	)

◆ fused_forward_1_0()

template<typename T , typename BoysParams = BoysParamsDefault>

OCC_GPU_ENABLED OCC_GPU_INLINE void occ::ints::fused_forward_1_0	(	const T *	boys_table,
		T	alpha,
		T	PCx,
		T	PCy,
		T	PCz,
		T	prefactor,
		const T *	X,
		T *	Y
	)

◆ fused_forward_1_1()

template<typename T , typename BoysParams = BoysParamsDefault>

OCC_GPU_ENABLED OCC_GPU_INLINE void occ::ints::fused_forward_1_1	(	const T *	boys_table,
		T	alpha,
		T	PCx,
		T	PCy,
		T	PCz,
		T	prefactor,
		const T *	X,
		T *	Y
	)

◆ fused_forward_1_2()

template<typename T , typename BoysParams = BoysParamsDefault>

OCC_GPU_ENABLED OCC_GPU_INLINE void occ::ints::fused_forward_1_2	(	const T *	boys_table,
		T	alpha,
		T	PCx,
		T	PCy,
		T	PCz,
		T	prefactor,
		const T *	X,
		T *	Y
	)

◆ fused_forward_2_0()

template<typename T , typename BoysParams = BoysParamsDefault>

OCC_GPU_ENABLED OCC_GPU_INLINE void occ::ints::fused_forward_2_0	(	const T *	boys_table,
		T	alpha,
		T	PCx,
		T	PCy,
		T	PCz,
		T	prefactor,
		const T *	X,
		T *	Y
	)

◆ fused_forward_2_1()

template<typename T , typename BoysParams = BoysParamsDefault>

OCC_GPU_ENABLED OCC_GPU_INLINE void occ::ints::fused_forward_2_1	(	const T *	boys_table,
		T	alpha,
		T	PCx,
		T	PCy,
		T	PCz,
		T	prefactor,
		const T *	X,
		T *	Y
	)

◆ fused_forward_3_0()

template<typename T , typename BoysParams = BoysParamsDefault>

OCC_GPU_ENABLED OCC_GPU_INLINE void occ::ints::fused_forward_3_0	(	const T *	boys_table,
		T	alpha,
		T	PCx,
		T	PCy,
		T	PCz,
		T	prefactor,
		const T *	X,
		T *	Y
	)

◆ fused_forward_dispatch()

template<typename T , typename BoysParams = BoysParamsDefault>

OCC_GPU_ENABLED OCC_GPU_INLINE bool occ::ints::fused_forward_dispatch	(	const T *	boys_table,
		int	L_ab,
		int	lc,
		T	alpha,
		T	PCx,
		T	PCy,
		T	PCz,
		T	prefactor,
		const T *	X,
		T *	Y
	)

◆ hermite_index()

OCC_GPU_ENABLED OCC_GPU_INLINE constexpr int occ::ints::hermite_index	(	int	t,
		int	u,
		int	v
	)

constexpr

◆ hermite_sign()

template<typename T >

OCC_GPU_ENABLED OCC_GPU_INLINE constexpr T occ::ints::hermite_sign	(	int	t,
		int	u,
		int	v
	)

constexpr

Compute Hermite sign factor (-1)^(t+u+v) for a given Hermite index.

◆ hermite_to_aux()

template<typename T >

void occ::ints::hermite_to_aux	(	const T *	E_c,
		const T *	Y_p,
		int	nc,
		int	nherm_c,
		T *	g_out
	)

Eq.

19: Transform from Hermite to aux orbital basis g_r = sum_p E^r_p * Y_p

Parameters

E_c	Aux E-matrix [nc * nherm_c] row-major
Y_p	Hermite intermediate [nherm_c]
nc	Number of aux Cartesian functions
nherm_c	Number of aux Hermite functions
g_out	Output [nc] (accumulated)

◆ hermite_to_orbital()

template<typename T >

void occ::ints::hermite_to_orbital	(	const T *	E_ab,
		const T *	U_q,
		int	na,
		int	nb,
		int	nherm_ab,
		T *	J_block,
		bool	apply_sign = `true`
	)

Eq.

22: Transform from Hermite to orbital basis (build J block) J_{mu,nu} = sum_q (-1)^q * E^{mu nu}_q * U_q

Parameters

E_ab	E-matrix [nab * nherm_ab] row-major
U_q	Hermite coefficients [nherm_ab] (signs already applied)
na,nb	Shell sizes
nherm_ab	Number of Hermite functions
J_block	Output [na * nb] (accumulated)
apply_sign	If true, apply (-1)^q to U before contraction

◆ ncart()

constexpr int occ::ints::ncart ( int L )

constexpr

◆ ncartsum()

constexpr int occ::ints::ncartsum ( int L )

constexpr

◆ nherm()

constexpr int occ::ints::nherm ( int L )

constexpr

◆ nhermsum()

constexpr int occ::ints::nhermsum ( int L )

constexpr

◆ precompute_aux_shell()

template<typename T , int L>

AuxShellData< T > occ::ints::precompute_aux_shell	(	int	nprim,
		const T *	exponents,
		const T *	coeffs,
		const T *	C
	)

Precompute auxiliary shell data with gamma-dependent E-coefficients.

Parameters

nprim	Number of primitives
exponents	Primitive exponents [nprim]
coeffs	Contraction coefficients [nprim]
C	Shell center [3]

◆ precompute_aux_shell_dispatch()

template<typename T >

AuxShellData< T > occ::ints::precompute_aux_shell_dispatch	(	int	lc,
		int	nprim,
		const T *	exponents,
		const T *	coeffs,
		const T *	C
	)

Dispatch auxiliary shell precomputation based on runtime angular momentum.

◆ precompute_shell_pair()

template<typename T , int LA, int LB>

ShellPairData< T > occ::ints::precompute_shell_pair	(	int	na_prim,
		int	nb_prim,
		const T *	exponents_a,
		const T *	exponents_b,
		const T *	coeffs_a,
		const T *	coeffs_b,
		const T *	A,
		const T *	B
	)

Precompute ShellPairData for a shell pair.

◆ precompute_shell_pair_dispatch()

template<typename T >

ShellPairData< T > occ::ints::precompute_shell_pair_dispatch	(	int	la,
		int	lb,
		int	na_prim,
		int	nb_prim,
		const T *	exponents_a,
		const T *	exponents_b,
		const T *	coeffs_a,
		const T *	coeffs_b,
		const T *	A,
		const T *	B
	)

Dispatch shell pair precomputation based on runtime angular momenta Supports angular momenta up to L=4 (g functions)

◆ spherical_harmonic_factor()

template<typename T >

OCC_GPU_ENABLED OCC_GPU_INLINE constexpr T occ::ints::spherical_harmonic_factor ( int l )

constexpr

◆ split_rij_workspace_sizes()

std::tuple< size_t, size_t, size_t, size_t > occ::ints::split_rij_workspace_sizes	(	int	max_l_ao,
		int	max_l_aux
	)

inline

Compute maximum workspace sizes for Split-RI-J.

Parameters

max_l_ao	Maximum AO angular momentum
max_l_aux	Maximum aux angular momentum

Returns: Tuple of (max_nherm_ab, max_nherm_c, max_nab, max_nc)

Variable Documentation

◆ E1D_MAX_SIZE

constexpr int occ::ints::E1D_MAX_SIZE = (LMAX + 1) * (LMAX + 1) * (2 * LMAX + 1)

constexpr

◆ LMAX

constexpr int occ::ints::LMAX = 6

constexpr

◆ RINTS_LMAX

constexpr int occ::ints::RINTS_LMAX = 15

constexpr

◆ RINTS_MAX_SIZE

constexpr int occ::ints::RINTS_MAX_SIZE = nhermsum(RINTS_LMAX)

constexpr

Namespaces

Classes

Typedefs

Functions

Variables

Typedef Documentation

◆ BoysDefault

◆ BoysExtended

◆ BoysParamsDefault

◆ BoysParamsExtended

◆ BoysParamsHighRes

Function Documentation

◆ apply_hermite_signs()

◆ aux_to_hermite()

◆ boys()

◆ boys_asymptotic() [1/2]

◆ boys_asymptotic() [2/2]

◆ boys_evaluate() [1/2]

◆ boys_evaluate() [2/2]

◆ boys_extended()

◆ boys_interpolate() [1/2]

◆ boys_interpolate() [2/2]

◆ build_aux_e_1d()

◆ build_aux_e_matrix_with_gamma()

◆ build_E_ab_matrix_dynamic()

◆ build_E_c_matrix_dynamic()

◆ build_e_matrix()

◆ build_R_tensor_dynamic()

◆ compute_accumulated_E_ab()

◆ compute_accumulated_E_c()

◆ compute_e_coeffs_1d()

◆ compute_e_coeffs_1d_dynamic()

◆ compute_e_coeffs_3d() [1/2]

◆ compute_e_coeffs_3d() [2/2]

◆ compute_r_ints() [1/2]

◆ compute_r_ints() [2/2]

◆ compute_r_ints_3c_dispatch() [1/2]

◆ compute_r_ints_3c_dispatch() [2/2]

◆ compute_r_ints_3c_L0()

◆ compute_r_ints_3c_L1()

◆ compute_r_ints_3c_L2()

◆ compute_r_ints_3c_L3()

◆ compute_r_ints_3c_L4()

◆ compute_r_ints_3c_L5()

◆ compute_r_ints_3c_L6()

◆ compute_r_ints_batch()

◆ compute_r_ints_batch_direct()

◆ compute_r_ints_dynamic()

◆ compute_r_ints_L0_batch()

◆ compute_r_ints_L0_eigen()

◆ compute_r_ints_L1_batch()

◆ compute_r_ints_L1_eigen()

◆ compute_r_ints_L2_batch()

◆ compute_r_ints_L2_eigen()

◆ compute_r_ints_L3_batch()

◆ compute_r_ints_L3_eigen()

◆ compute_r_ints_L4_batch()

◆ compute_r_ints_L4_eigen()

◆ compute_r_ints_L5_batch()

◆ compute_r_ints_L6_batch()

◆ compute_r_ints_L6_eigen()

◆ compute_R_pq_tensor()

◆ contract_hermite_eri_backward()

◆ contract_hermite_eri_forward()

◆ density_to_hermite()

◆ eri2c_dynamic()

◆ eri2c_evaluate_with_precomputed()

◆ eri3c_contracted()

◆ eri3c_dispatch()

◆ eri3c_dynamic()

◆ eri3c_dynamic_matmul()

◆ eri3c_dynamic_matmul_workspace()

◆ eri3c_evaluate_with_precomputed()

◆ eri3c_primitive()

◆ eri3c_workspace_sizes()

◆ eri3c_workspace_sizes_max()

◆ esp_contracted()

◆ esp_contracted_batch()

◆ esp_contracted_dynamic()

◆ esp_evaluate_with_precomputed()