"""
Molecular integrals over Gaussian basis functions generated by sympleints.
See https://github.com/eljost/sympleints for more information.
sympleints version: 0.1.dev103+g56f68c5.d20240122
sympy version: 1.12
sympleints was executed with the following arguments:
/home/johannes/.pyenv/versions/sympleints/bin/sympleints --norm cgto --keys ~2c2e ~3c2e_sph ~coul --opt-basic --prefix opt_new
lmax = 4
lauxmax = 6
out_dir = .
prefix = opt_new
keys = ['~2c2e', '~3c2e_sph', '~coul']
sph = False
opt_basic = True
boys_func = sympleints.testing.boys
normalize = cgto
"""
import numba
from numba import i8, f8
import numpy
func_type = numba.types.FunctionType(
numba.types.void(f8, f8, f8[:], f8, f8, f8[:], f8[:], f8[::1])
)
[docs]
@numba.jit(
func_type.signature,
nopython=True,
nogil=True,
fastmath=True,
cache=True,
)
def ovlp3d_00(ax, da, A, bx, db, B, R, result):
"""Cartesian 3D (ss) overlap integral.
Generated code; DO NOT modify by hand!"""
x0 = (ax + bx) ** (-1.0)
x1 = ax * bx * x0
# 1 item(s)
result[0] += (
5.56832799683170785
* da
* db
* x0**1.5
* numpy.exp(-x1 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2))
)
[docs]
@numba.jit(
func_type.signature,
nopython=True,
nogil=True,
fastmath=True,
cache=True,
)
def ovlp3d_10(ax, da, A, bx, db, B, R, result):
"""Cartesian 3D (ps) overlap integral.
Generated code; DO NOT modify by hand!"""
x0 = (ax + bx) ** (-1.0)
x1 = ax * bx * x0
x2 = (
5.56832799683170785
* da
* db
* x0**1.5
* numpy.exp(-x1 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2))
)
# 3 item(s)
result[0] += x2 * (x0 * (ax * A[0] + bx * B[0]) - A[0])
result[1] += x2 * (x0 * (ax * A[1] + bx * B[1]) - A[1])
result[2] += x2 * (x0 * (ax * A[2] + bx * B[2]) - A[2])
[docs]
@numba.jit(
func_type.signature,
nopython=True,
nogil=True,
fastmath=True,
cache=True,
)
def ovlp3d_01(ax, da, A, bx, db, B, R, result):
"""See docstring of ovlp3d_10."""
# Call equivalent function and write to result
tmp = numpy.zeros_like(result)
ovlp3d_10(bx, db, B, ax, da, A, R, tmp)
result[:] += numpy.transpose(tmp.reshape(3, 1), axes=(1, 0)).flatten()
[docs]
@numba.jit(
func_type.signature,
nopython=True,
nogil=True,
fastmath=True,
cache=True,
)
def ovlp3d_20(ax, da, A, bx, db, B, R, result):
"""Cartesian 3D (ds) overlap integral.
Generated code; DO NOT modify by hand!"""
x0 = (ax + bx) ** (-1.0)
x1 = -x0 * (ax * A[0] + bx * B[0]) + A[0]
x2 = 0.5 * x0
x3 = ax * bx * x0
x4 = (
5.56832799683170785
* da
* db
* x0**1.5
* numpy.exp(-x3 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2))
)
x5 = 0.577350269189625764 * x4
x6 = -x0 * (ax * A[1] + bx * B[1]) + A[1]
x7 = x1 * x4
x8 = -x0 * (ax * A[2] + bx * B[2]) + A[2]
# 6 item(s)
result[0] += x5 * (x1**2 + x2)
result[1] += x6 * x7
result[2] += x7 * x8
result[3] += x5 * (x2 + x6**2)
result[4] += x4 * x6 * x8
result[5] += x5 * (x2 + x8**2)
[docs]
@numba.jit(
func_type.signature,
nopython=True,
nogil=True,
fastmath=True,
cache=True,
)
def ovlp3d_02(ax, da, A, bx, db, B, R, result):
"""See docstring of ovlp3d_20."""
# Call equivalent function and write to result
tmp = numpy.zeros_like(result)
ovlp3d_20(bx, db, B, ax, da, A, R, tmp)
result[:] += numpy.transpose(tmp.reshape(6, 1), axes=(1, 0)).flatten()
[docs]
@numba.jit(
func_type.signature,
nopython=True,
nogil=True,
fastmath=True,
cache=True,
)
def ovlp3d_30(ax, da, A, bx, db, B, R, result):
"""Cartesian 3D (fs) overlap integral.
Generated code; DO NOT modify by hand!"""
x0 = (ax + bx) ** (-1.0)
x1 = -x0 * (ax * A[0] + bx * B[0]) + A[0]
x2 = x1**2
x3 = 1.5 * x0
x4 = 5.56832799683170785
x5 = numpy.sqrt(x0)
x6 = ax * bx * x0
x7 = numpy.exp(-x6 * (A[0] - B[0]) ** 2)
x8 = numpy.exp(-x6 * (A[1] - B[1]) ** 2)
x9 = numpy.exp(-x6 * (A[2] - B[2]) ** 2)
x10 = da * db * x0 * x1 * x4 * x5 * x7 * x8 * x9
x11 = 0.258198889747161126
x12 = -x0 * (ax * A[1] + bx * B[1]) + A[1]
x13 = da * db * x0 * x4 * x5 * x7 * x8 * x9
x14 = x12 * x13
x15 = 0.5 * x0
x16 = 0.577350269189625764
x17 = x16 * (x15 + x2)
x18 = -x0 * (ax * A[2] + bx * B[2]) + A[2]
x19 = x13 * x18
x20 = x12**2
x21 = x15 + x20
x22 = x10 * x16
x23 = x18**2
x24 = x15 + x23
# 10 item(s)
result[0] += -x10 * x11 * (x2 + x3)
result[1] += -x14 * x17
result[2] += -x17 * x19
result[3] += -x21 * x22
result[4] += -x10 * x12 * x18
result[5] += -x22 * x24
result[6] += -x11 * x14 * (x20 + x3)
result[7] += -x16 * x19 * x21
result[8] += -x14 * x16 * x24
result[9] += -x11 * x19 * (x23 + x3)
[docs]
@numba.jit(
func_type.signature,
nopython=True,
nogil=True,
fastmath=True,
cache=True,
)
def ovlp3d_03(ax, da, A, bx, db, B, R, result):
"""See docstring of ovlp3d_30."""
# Call equivalent function and write to result
tmp = numpy.zeros_like(result)
ovlp3d_30(bx, db, B, ax, da, A, R, tmp)
result[:] += numpy.transpose(tmp.reshape(10, 1), axes=(1, 0)).flatten()
[docs]
@numba.jit(
func_type.signature,
nopython=True,
nogil=True,
fastmath=True,
cache=True,
)
def ovlp3d_40(ax, da, A, bx, db, B, R, result):
"""Cartesian 3D (gs) overlap integral.
Generated code; DO NOT modify by hand!"""
x0 = 0.5 / (ax + bx)
x1 = (ax + bx) ** (-1.0)
x2 = x1 * (ax * A[0] + bx * B[0]) - A[0]
x3 = ax * bx * x1
x4 = numpy.exp(-x3 * (A[0] - B[0]) ** 2)
x5 = 1.77245385090551603 * numpy.sqrt(x1)
x6 = x4 * x5
x7 = x2**2 * x6
x8 = x0 * x6
x9 = x7 + x8
x10 = x2 * (2.0 * x8 + x9)
x11 = numpy.exp(-x3 * (A[1] - B[1]) ** 2)
x12 = da * db
x13 = numpy.exp(-x3 * (A[2] - B[2]) ** 2)
x14 = 3.14159265358979324 * x1 * x13
x15 = x12 * x14
x16 = x11 * x15
x17 = 0.0975900072948533179
x18 = x1 * (ax * A[1] + bx * B[1]) - A[1]
x19 = 0.258198889747161126
x20 = x18 * x19
x21 = x10 * x16
x22 = x1 * (ax * A[2] + bx * B[2]) - A[2]
x23 = x19 * x22
x24 = x11 * x5
x25 = x18**2 * x24
x26 = x0 * x24
x27 = x25 + x26
x28 = x13 * x5
x29 = 0.333333333333333333 * x12
x30 = x29 * x9
x31 = 1.73205080756887729
x32 = x18 * x31
x33 = x14 * x22
x34 = x22**2 * x28
x35 = x0 * x28
x36 = x34 + x35
x37 = x2 * x4
x38 = x19 * x37
x39 = x18 * (2.0 * x26 + x27)
x40 = x15 * x39
x41 = x27 * x29
x42 = 3.14159265358979324 * x1 * x11
x43 = x22 * (2.0 * x35 + x36)
x44 = x12 * x42
x45 = x43 * x44
x46 = x17 * x4
# 15 item(s)
result[0] += x16 * x17 * (3.0 * x0 * (x7 + x8) + x10 * x2)
result[1] += x20 * x21
result[2] += x21 * x23
result[3] += x27 * x28 * x30
result[4] += x11 * x30 * x32 * x33
result[5] += x24 * x30 * x36
result[6] += x38 * x40
result[7] += x31 * x33 * x37 * x41
result[8] += x29 * x32 * x36 * x37 * x42
result[9] += x38 * x45
result[10] += x15 * x46 * (3.0 * x0 * (x25 + x26) + x18 * x39)
result[11] += x23 * x4 * x40
result[12] += x36 * x41 * x6
result[13] += x20 * x4 * x45
result[14] += x44 * x46 * (3.0 * x0 * (x34 + x35) + x22 * x43)
[docs]
@numba.jit(
func_type.signature,
nopython=True,
nogil=True,
fastmath=True,
cache=True,
)
def ovlp3d_04(ax, da, A, bx, db, B, R, result):
"""See docstring of ovlp3d_40."""
# Call equivalent function and write to result
tmp = numpy.zeros_like(result)
ovlp3d_40(bx, db, B, ax, da, A, R, tmp)
result[:] += numpy.transpose(tmp.reshape(15, 1), axes=(1, 0)).flatten()
[docs]
@numba.jit(
func_type.signature,
nopython=True,
nogil=True,
fastmath=True,
cache=True,
)
def ovlp3d_11(ax, da, A, bx, db, B, R, result):
"""Cartesian 3D (pp) overlap integral.
Generated code; DO NOT modify by hand!"""
x0 = (ax + bx) ** (-1.0)
x1 = 0.5 * x0
x2 = -x0 * (ax * A[0] + bx * B[0])
x3 = x2 + A[0]
x4 = x2 + B[0]
x5 = ax * bx * x0
x6 = (
5.56832799683170785
* da
* db
* x0**1.5
* numpy.exp(-x5 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2))
)
x7 = -x0 * (ax * A[1] + bx * B[1])
x8 = x7 + B[1]
x9 = x3 * x6
x10 = -x0 * (ax * A[2] + bx * B[2])
x11 = x10 + B[2]
x12 = x7 + A[1]
x13 = x12 * x6
x14 = x10 + A[2]
x15 = x14 * x6
# 9 item(s)
result[0] += x6 * (x1 + x3 * x4)
result[1] += x8 * x9
result[2] += x11 * x9
result[3] += x13 * x4
result[4] += x6 * (x1 + x12 * x8)
result[5] += x11 * x13
result[6] += x15 * x4
result[7] += x15 * x8
result[8] += x6 * (x1 + x11 * x14)
[docs]
@numba.jit(
func_type.signature,
nopython=True,
nogil=True,
fastmath=True,
cache=True,
)
def ovlp3d_21(ax, da, A, bx, db, B, R, result):
"""Cartesian 3D (dp) overlap integral.
Generated code; DO NOT modify by hand!"""
x0 = (ax + bx) ** (-1.0)
x1 = x0 * (ax * A[0] + bx * B[0])
x2 = -x1
x3 = x2 + A[0]
x4 = x2 + B[0]
x5 = x3 * x4
x6 = ax * bx * x0
x7 = (
5.56832799683170785
* da
* db
* x0**1.5
* numpy.exp(-x6 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2))
)
x8 = 1.73205080756887729 * x7
x9 = 0.166666666666666667 * x8
x10 = x0 * (ax * A[1] + bx * B[1])
x11 = -x10
x12 = x11 + B[1]
x13 = 0.5 * x0
x14 = 0.333333333333333333 * x8
x15 = x14 * (x13 + x3**2)
x16 = x0 * (ax * A[2] + bx * B[2])
x17 = -x16
x18 = x17 + B[2]
x19 = x11 + A[1]
x20 = x7 * (x13 + x5)
x21 = x12 * x19
x22 = x13 + x21
x23 = x3 * x7
x24 = x17 + A[2]
x25 = x18 * x24
x26 = x13 + x25
x27 = x14 * (x13 + x19**2)
x28 = x24 * x7
x29 = x14 * (x13 + x24**2)
# 18 item(s)
result[0] += -x9 * (x0 * (-2.0 * x1 + A[0] + B[0]) + x3 * (x0 + 2.0 * x5))
result[1] += -x12 * x15
result[2] += -x15 * x18
result[3] += -x19 * x20
result[4] += -x22 * x23
result[5] += -x18 * x19 * x23
result[6] += -x20 * x24
result[7] += -x12 * x23 * x24
result[8] += -x23 * x26
result[9] += -x27 * x4
result[10] += -x9 * (x0 * (-2.0 * x10 + A[1] + B[1]) + x19 * (x0 + 2.0 * x21))
result[11] += -x18 * x27
result[12] += -x19 * x28 * x4
result[13] += -x22 * x28
result[14] += -x19 * x26 * x7
result[15] += -x29 * x4
result[16] += -x12 * x29
result[17] += -x9 * (x0 * (-2.0 * x16 + A[2] + B[2]) + x24 * (x0 + 2.0 * x25))
[docs]
@numba.jit(
func_type.signature,
nopython=True,
nogil=True,
fastmath=True,
cache=True,
)
def ovlp3d_12(ax, da, A, bx, db, B, R, result):
"""See docstring of ovlp3d_21."""
# Call equivalent function and write to result
tmp = numpy.zeros_like(result)
ovlp3d_21(bx, db, B, ax, da, A, R, tmp)
result[:] += numpy.transpose(tmp.reshape(6, 3), axes=(1, 0)).flatten()
[docs]
@numba.jit(
func_type.signature,
nopython=True,
nogil=True,
fastmath=True,
cache=True,
)
def ovlp3d_31(ax, da, A, bx, db, B, R, result):
"""Cartesian 3D (fp) overlap integral.
Generated code; DO NOT modify by hand!"""
x0 = (ax + bx) ** (-1.0)
x1 = x0 * (ax * A[0] + bx * B[0])
x2 = -x1
x3 = x2 + A[0]
x4 = x3**2
x5 = 3.0 * x0
x6 = x2 + B[0]
x7 = x3 * x6
x8 = x0 * (-2.0 * x1 + A[0] + B[0]) + x3 * (x0 + 2.0 * x7)
x9 = ax * bx * x0
x10 = (
5.56832799683170785
* da
* db
* numpy.exp(-x9 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2))
)
x11 = x0**1.5 * x10
x12 = 3.87298334620741689 * x11
x13 = 0.0166666666666666667 * x12
x14 = x0 * (ax * A[1] + bx * B[1])
x15 = -x14
x16 = x15 + B[1]
x17 = 0.0666666666666666667 * x12
x18 = x16 * x17
x19 = 1.5 * x0
x20 = x3 * (x19 + x4)
x21 = x0 * (ax * A[2] + bx * B[2])
x22 = -x21
x23 = x22 + B[2]
x24 = x17 * x23
x25 = x15 + A[1]
x26 = x11 * x25
x27 = 1.73205080756887729
x28 = 0.166666666666666667 * x27
x29 = x28 * x8
x30 = 0.5 * x0
x31 = x16 * x25
x32 = x30 + x31
x33 = 0.333333333333333333 * x27
x34 = x33 * (x30 + x4)
x35 = x0**1.5 * x10
x36 = x34 * x35
x37 = x22 + A[2]
x38 = x11 * x37
x39 = x23 * x37
x40 = x30 + x39
x41 = x25**2
x42 = x30 + x41
x43 = x30 + x7
x44 = x33 * x35
x45 = x43 * x44
x46 = x0 * (-2.0 * x14 + A[1] + B[1]) + x25 * (x0 + 2.0 * x31)
x47 = x28 * x46
x48 = x11 * x3
x49 = x33 * x48
x50 = x37**2
x51 = x30 + x50
x52 = x0 * (-2.0 * x21 + A[2] + B[2]) + x37 * (x0 + 2.0 * x39)
x53 = x28 * x52
x54 = x25 * (x19 + x41)
x55 = x17 * x6
x56 = x33 * x6
x57 = x37 * (x19 + x50)
# 30 item(s)
result[0] += x13 * (x0 * (2.0 * x4 + x5 + 4.0 * x7) + 2.0 * x3 * x8)
result[1] += x18 * x20
result[2] += x20 * x24
result[3] += x26 * x29
result[4] += x32 * x36
result[5] += x23 * x26 * x34
result[6] += x29 * x38
result[7] += x16 * x34 * x38
result[8] += x36 * x40
result[9] += x42 * x45
result[10] += x47 * x48
result[11] += x23 * x42 * x49
result[12] += x25 * x38 * x43
result[13] += x3 * x32 * x38
result[14] += x26 * x3 * x40
result[15] += x45 * x51
result[16] += x16 * x49 * x51
result[17] += x48 * x53
result[18] += x54 * x55
result[19] += x13 * (x0 * (4.0 * x31 + 2.0 * x41 + x5) + 2.0 * x25 * x46)
result[20] += x24 * x54
result[21] += x38 * x42 * x56
result[22] += x38 * x47
result[23] += x40 * x42 * x44
result[24] += x26 * x51 * x56
result[25] += x32 * x44 * x51
result[26] += x26 * x53
result[27] += x55 * x57
result[28] += x18 * x57
result[29] += x13 * (x0 * (4.0 * x39 + x5 + 2.0 * x50) + 2.0 * x37 * x52)
[docs]
@numba.jit(
func_type.signature,
nopython=True,
nogil=True,
fastmath=True,
cache=True,
)
def ovlp3d_13(ax, da, A, bx, db, B, R, result):
"""See docstring of ovlp3d_31."""
# Call equivalent function and write to result
tmp = numpy.zeros_like(result)
ovlp3d_31(bx, db, B, ax, da, A, R, tmp)
result[:] += numpy.transpose(tmp.reshape(10, 3), axes=(1, 0)).flatten()
[docs]
@numba.jit(
func_type.signature,
nopython=True,
nogil=True,
fastmath=True,
cache=True,
)
def ovlp3d_41(ax, da, A, bx, db, B, R, result):
"""Cartesian 3D (gp) overlap integral.
Generated code; DO NOT modify by hand!"""
x0 = 0.5 / (ax + bx)
x1 = (ax + bx) ** (-1.0)
x2 = -x1 * (ax * A[0] + bx * B[0])
x3 = -x2 - A[0]
x4 = ax * bx * x1
x5 = numpy.exp(-x4 * (A[0] - B[0]) ** 2)
x6 = 1.77245385090551603 * numpy.sqrt(x1)
x7 = x5 * x6
x8 = x3 * x7
x9 = -x2 - B[0]
x10 = x7 * x9
x11 = x0 * (x10 + x8)
x12 = x0 * x7
x13 = x8 * x9
x14 = x12 + x13
x15 = x14 * x3
x16 = x3**2 * x7
x17 = x12 + x16
x18 = x3 * (2.0 * x12 + x17)
x19 = 3.0 * x12
x20 = x11 + x15
x21 = x0 * (2.0 * x13 + x16 + x19) + x20 * x3
x22 = numpy.exp(-x4 * (A[1] - B[1]) ** 2)
x23 = da * db
x24 = numpy.exp(-x4 * (A[2] - B[2]) ** 2)
x25 = 3.14159265358979324 * x1 * x24
x26 = x23 * x25
x27 = x22 * x26
x28 = 0.0975900072948533179
x29 = x27 * x28
x30 = -x1 * (ax * A[1] + bx * B[1])
x31 = -x30 - B[1]
x32 = x29 * (x0 * (3.0 * x16 + x19) + x18 * x3)
x33 = -x1 * (ax * A[2] + bx * B[2])
x34 = -x33 - B[2]
x35 = -x30 - A[1]
x36 = 0.258198889747161126
x37 = x27 * x36
x38 = x21 * x37
x39 = x0 * x6
x40 = x22 * x39
x41 = x22 * x6
x42 = x35 * x41
x43 = x31 * x42
x44 = x40 + x43
x45 = x24 * x6
x46 = x23 * x36
x47 = x18 * x46
x48 = x18 * x37
x49 = -x33 - A[2]
x50 = x24 * x39
x51 = x45 * x49
x52 = x34 * x51
x53 = x50 + x52
x54 = x35**2 * x41
x55 = x40 + x54
x56 = 0.333333333333333333 * x23
x57 = x45 * x56
x58 = x31 * x41
x59 = x0 * (x42 + x58)
x60 = x35 * x44
x61 = x59 + x60
x62 = x34 * x45
x63 = x17 * x56
x64 = 1.73205080756887729
x65 = x56 * x64
x66 = x35 * x65
x67 = x25 * x49
x68 = x63 * x64
x69 = x45 * x49**2
x70 = x50 + x69
x71 = x41 * x56
x72 = x0 * (x51 + x62)
x73 = x49 * x53
x74 = x72 + x73
x75 = x35 * (2.0 * x40 + x55)
x76 = x14 * x46
x77 = x3 * x5
x78 = 3.0 * x40
x79 = x0 * (2.0 * x43 + x54 + x78) + x35 * x61
x80 = x26 * x36
x81 = x79 * x80
x82 = x75 * x80
x83 = x55 * x56
x84 = x64 * x83
x85 = x65 * x70
x86 = 3.14159265358979324 * x1 * x22
x87 = x77 * x86
x88 = x49 * (2.0 * x50 + x70)
x89 = x46 * x88
x90 = 3.0 * x50
x91 = x0 * (2.0 * x52 + x69 + x90) + x49 * x74
x92 = x46 * x91
x93 = x28 * x5
x94 = x26 * x93
x95 = x94 * (x0 * (3.0 * x54 + x78) + x35 * x75)
x96 = x49 * x5
x97 = x46 * x7
x98 = x56 * x7
x99 = x35 * x5 * x86
x100 = x23 * x86 * x93
x101 = x100 * (x0 * (3.0 * x69 + x90) + x49 * x88)
# 45 item(s)
result[0] += x29 * (x0 * (3.0 * x11 + 3.0 * x15 + x18) + x21 * x3)
result[1] += x31 * x32
result[2] += x32 * x34
result[3] += x35 * x38
result[4] += x44 * x45 * x47
result[5] += x34 * x35 * x48
result[6] += x38 * x49
result[7] += x31 * x48 * x49
result[8] += x41 * x47 * x53
result[9] += x20 * x55 * x57
result[10] += x17 * x57 * x61
result[11] += x55 * x62 * x63
result[12] += x20 * x22 * x66 * x67
result[13] += x44 * x51 * x68
result[14] += x42 * x53 * x68
result[15] += x20 * x70 * x71
result[16] += x58 * x63 * x70
result[17] += x17 * x71 * x74
result[18] += x45 * x75 * x76
result[19] += x77 * x81
result[20] += x34 * x77 * x82
result[21] += x14 * x51 * x84
result[22] += x61 * x65 * x67 * x77
result[23] += x53 * x8 * x84
result[24] += x14 * x42 * x85
result[25] += x44 * x8 * x85
result[26] += x66 * x74 * x87
result[27] += x41 * x76 * x88
result[28] += x31 * x87 * x89
result[29] += x87 * x92
result[30] += x9 * x95
result[31] += x94 * (x0 * (3.0 * x59 + 3.0 * x60 + x75) + x35 * x79)
result[32] += x34 * x95
result[33] += x82 * x9 * x96
result[34] += x81 * x96
result[35] += x53 * x75 * x97
result[36] += x10 * x70 * x83
result[37] += x61 * x70 * x98
result[38] += x55 * x74 * x98
result[39] += x89 * x9 * x99
result[40] += x44 * x88 * x97
result[41] += x92 * x99
result[42] += x101 * x9
result[43] += x101 * x31
result[44] += x100 * (x0 * (3.0 * x72 + 3.0 * x73 + x88) + x49 * x91)
[docs]
@numba.jit(
func_type.signature,
nopython=True,
nogil=True,
fastmath=True,
cache=True,
)
def ovlp3d_14(ax, da, A, bx, db, B, R, result):
"""See docstring of ovlp3d_41."""
# Call equivalent function and write to result
tmp = numpy.zeros_like(result)
ovlp3d_41(bx, db, B, ax, da, A, R, tmp)
result[:] += numpy.transpose(tmp.reshape(15, 3), axes=(1, 0)).flatten()
[docs]
@numba.jit(
func_type.signature,
nopython=True,
nogil=True,
fastmath=True,
cache=True,
)
def ovlp3d_22(ax, da, A, bx, db, B, R, result):
"""Cartesian 3D (dd) overlap integral.
Generated code; DO NOT modify by hand!"""
x0 = (ax + bx) ** (-1.0)
x1 = x0 * (ax * A[0] + bx * B[0])
x2 = -x1
x3 = x2 + B[0]
x4 = x3**2
x5 = 3.0 * x0
x6 = x2 + A[0]
x7 = x3 * x6
x8 = x0 * (-2.0 * x1 + A[0] + B[0])
x9 = x0 + 2.0 * x7
x10 = x3 * x9 + x8
x11 = ax * bx * x0
x12 = (
5.56832799683170785
* da
* db
* numpy.exp(-x11 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2))
)
x13 = x0**1.5 * x12
x14 = 0.0833333333333333333 * x13
x15 = x0 * (ax * A[1] + bx * B[1])
x16 = -x15
x17 = x16 + B[1]
x18 = x13 * x17
x19 = 1.73205080756887729
x20 = 0.166666666666666667 * x19
x21 = x20 * (x6 * x9 + x8)
x22 = x0 * (ax * A[2] + bx * B[2])
x23 = -x22
x24 = x23 + B[2]
x25 = x13 * x24
x26 = x17**2
x27 = 0.5 * x0
x28 = x26 + x27
x29 = x27 + x6**2
x30 = x0**1.5 * x12
x31 = 0.333333333333333333 * x30
x32 = x29 * x31
x33 = 0.333333333333333333 * x19
x34 = x25 * x33
x35 = x24**2
x36 = x27 + x35
x37 = x16 + A[1]
x38 = x13 * x20
x39 = x10 * x38
x40 = x17 * x37
x41 = x27 + x40
x42 = x27 + x7
x43 = x30 * x42
x44 = x0 * (-2.0 * x15 + A[1] + B[1])
x45 = x0 + 2.0 * x40
x46 = x17 * x45 + x44
x47 = x38 * x6
x48 = x13 * x33 * x6
x49 = x23 + A[2]
x50 = x24 * x49
x51 = x27 + x50
x52 = x0 * (-2.0 * x22 + A[2] + B[2])
x53 = x0 + 2.0 * x50
x54 = x24 * x53 + x52
x55 = x27 + x4
x56 = x27 + x37**2
x57 = x31 * x56
x58 = x13 * x3
x59 = x20 * (x37 * x45 + x44)
x60 = x27 + x49**2
x61 = x31 * x60
x62 = x20 * (x49 * x53 + x52)
# 36 item(s)
result[0] += x14 * (x0 * (2.0 * x4 + x5 + 4.0 * x7) + 2.0 * x10 * x6)
result[1] += x18 * x21
result[2] += x21 * x25
result[3] += x28 * x32
result[4] += x17 * x29 * x34
result[5] += x32 * x36
result[6] += x37 * x39
result[7] += x41 * x43
result[8] += x25 * x37 * x42
result[9] += x46 * x47
result[10] += x25 * x41 * x6
result[11] += x36 * x37 * x48
result[12] += x39 * x49
result[13] += x18 * x42 * x49
result[14] += x43 * x51
result[15] += x28 * x48 * x49
result[16] += x18 * x51 * x6
result[17] += x47 * x54
result[18] += x55 * x57
result[19] += x58 * x59
result[20] += x3 * x34 * x56
result[21] += x14 * (x0 * (2.0 * x26 + 4.0 * x40 + x5) + 2.0 * x37 * x46)
result[22] += x25 * x59
result[23] += x36 * x57
result[24] += x13 * x33 * x37 * x49 * x55
result[25] += x41 * x49 * x58
result[26] += x37 * x51 * x58
result[27] += x38 * x46 * x49
result[28] += x30 * x41 * x51
result[29] += x37 * x38 * x54
result[30] += x55 * x61
result[31] += x18 * x3 * x33 * x60
result[32] += x58 * x62
result[33] += x28 * x61
result[34] += x18 * x62
result[35] += x14 * (x0 * (2.0 * x35 + x5 + 4.0 * x50) + 2.0 * x49 * x54)
[docs]
@numba.jit(
func_type.signature,
nopython=True,
nogil=True,
fastmath=True,
cache=True,
)
def ovlp3d_32(ax, da, A, bx, db, B, R, result):
"""Cartesian 3D (fd) overlap integral.
Generated code; DO NOT modify by hand!"""
x0 = (ax + bx) ** (-1.0)
x1 = x0 * (ax * A[0] + bx * B[0])
x2 = -x1
x3 = x2 + B[0]
x4 = x3**2
x5 = 3.0 * x0
x6 = x2 + A[0]
x7 = x3 * x6
x8 = x5 + 4.0 * x7
x9 = x0 * (-2.0 * x1 + A[0] + B[0])
x10 = x0 + 2.0 * x7
x11 = x10 * x3
x12 = x11 + x9
x13 = 2.0 * x6
x14 = x0 * (2.0 * x4 + x8) + x12 * x13
x15 = x10 * x6
x16 = 2.0 * x0
x17 = 2.2360679774997897
x18 = ax * bx * x0
x19 = (
5.56832799683170785
* da
* db
* numpy.exp(-x18 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2))
)
x20 = x0**1.5 * x19
x21 = 0.0166666666666666667 * x20
x22 = x17 * x21
x23 = x0 * (ax * A[1] + bx * B[1])
x24 = -x23
x25 = x24 + B[1]
x26 = x6**2
x27 = x15 + x9
x28 = 3.87298334620741689
x29 = x21 * x28
x30 = x29 * (x0 * (2.0 * x26 + x8) + x13 * x27)
x31 = x0 * (ax * A[2] + bx * B[2])
x32 = -x31
x33 = x32 + B[2]
x34 = x25**2
x35 = 0.5 * x0
x36 = x34 + x35
x37 = 0.0666666666666666667 * x17
x38 = x36 * x37
x39 = 1.5 * x0
x40 = x26 + x39
x41 = x0**1.5 * x19
x42 = x41 * x6
x43 = x40 * x42
x44 = x20 * x33
x45 = 0.0666666666666666667 * x28
x46 = x33**2
x47 = x35 + x46
x48 = x37 * x47
x49 = x24 + A[1]
x50 = 0.0833333333333333333 * x20
x51 = x14 * x50
x52 = x25 * x49
x53 = x35 + x52
x54 = 1.73205080756887729
x55 = 0.166666666666666667 * x41
x56 = x54 * x55
x57 = x27 * x56
x58 = x44 * x49
x59 = 0.166666666666666667 * x54
x60 = x27 * x59
x61 = x0 * (-2.0 * x23 + A[1] + B[1])
x62 = x0 + 2.0 * x52
x63 = x25 * x62
x64 = x61 + x63
x65 = x26 + x35
x66 = x55 * x65
x67 = 0.333333333333333333 * x54
x68 = x33 * x67
x69 = x41 * x65
x70 = 0.333333333333333333 * x47
x71 = x41 * x49
x72 = x32 + A[2]
x73 = x20 * x72
x74 = x25 * x73
x75 = x33 * x72
x76 = x35 + x75
x77 = 0.333333333333333333 * x36
x78 = x41 * x72
x79 = x25 * x67
x80 = x0 * (-2.0 * x31 + A[2] + B[2])
x81 = x0 + 2.0 * x75
x82 = x33 * x81
x83 = x80 + x82
x84 = x49**2
x85 = x35 + x84
x86 = x12 * x55
x87 = x49 * x62
x88 = x61 + x87
x89 = x35 + x7
x90 = x56 * x89
x91 = x41 * x89
x92 = x5 + 4.0 * x52
x93 = 2.0 * x49
x94 = x0 * (2.0 * x34 + x92) + x64 * x93
x95 = x50 * x6
x96 = x59 * x6
x97 = x59 * x73
x98 = x20 * x96
x99 = x72**2
x100 = x35 + x99
x101 = x72 * x81
x102 = x101 + x80
x103 = x5 + 4.0 * x75
x104 = 2.0 * x72
x105 = x0 * (x103 + 2.0 * x46) + x104 * x83
x106 = x39 + x84
x107 = x106 * x71
x108 = x35 + x4
x109 = x108 * x37
x110 = x29 * (x0 * (2.0 * x84 + x92) + x88 * x93)
x111 = x3 * x45
x112 = 0.333333333333333333 * x108
x113 = x3 * x41 * x67
x114 = x39 + x99
x115 = x114 * x78
x116 = x29 * (x0 * (x103 + 2.0 * x99) + x102 * x104)
# 60 item(s)
result[0] += -x22 * (x14 * x6 + x16 * (x11 + x15 + 2.0 * x9))
result[1] += -x25 * x30
result[2] += -x30 * x33
result[3] += -x38 * x43
result[4] += -x25 * x40 * x44 * x45 * x6
result[5] += -x43 * x48
result[6] += -x49 * x51
result[7] += -x53 * x57
result[8] += -x58 * x60
result[9] += -x64 * x66
result[10] += -x53 * x68 * x69
result[11] += -x65 * x70 * x71
result[12] += -x51 * x72
result[13] += -x60 * x74
result[14] += -x57 * x76
result[15] += -x65 * x77 * x78
result[16] += -x69 * x76 * x79
result[17] += -x66 * x83
result[18] += -x85 * x86
result[19] += -x88 * x90
result[20] += -x68 * x85 * x91
result[21] += -x94 * x95
result[22] += -x44 * x88 * x96
result[23] += -x42 * x70 * x85
result[24] += -x12 * x49 * x97
result[25] += -x53 * x72 * x91
result[26] += -x49 * x76 * x91
result[27] += -x64 * x73 * x96
result[28] += -x42 * x53 * x76
result[29] += -x49 * x83 * x98
result[30] += -x100 * x86
result[31] += -x100 * x79 * x91
result[32] += -x102 * x90
result[33] += -x100 * x42 * x77
result[34] += -x102 * x25 * x98
result[35] += -x105 * x95
result[36] += -x107 * x109
result[37] += -x110 * x3
result[38] += -x106 * x111 * x58
result[39] += -x22 * (x16 * (2.0 * x61 + x63 + x87) + x49 * x94)
result[40] += -x110 * x33
result[41] += -x107 * x48
result[42] += -x112 * x78 * x85
result[43] += -x3 * x88 * x97
result[44] += -x113 * x76 * x85
result[45] += -x50 * x72 * x94
result[46] += -x56 * x76 * x88
result[47] += -x55 * x83 * x85
result[48] += -x100 * x112 * x71
result[49] += -x100 * x113 * x53
result[50] += -x102 * x20 * x3 * x49 * x59
result[51] += -x100 * x55 * x64
result[52] += -x102 * x53 * x56
result[53] += -x105 * x49 * x50
result[54] += -x109 * x115
result[55] += -x111 * x114 * x74
result[56] += -x116 * x3
result[57] += -x115 * x38
result[58] += -x116 * x25
result[59] += -x22 * (x105 * x72 + x16 * (x101 + 2.0 * x80 + x82))
[docs]
@numba.jit(
func_type.signature,
nopython=True,
nogil=True,
fastmath=True,
cache=True,
)
def ovlp3d_23(ax, da, A, bx, db, B, R, result):
"""See docstring of ovlp3d_32."""
# Call equivalent function and write to result
tmp = numpy.zeros_like(result)
ovlp3d_32(bx, db, B, ax, da, A, R, tmp)
result[:] += numpy.transpose(tmp.reshape(10, 6), axes=(1, 0)).flatten()
[docs]
@numba.jit(
func_type.signature,
nopython=True,
nogil=True,
fastmath=True,
cache=True,
)
def ovlp3d_42(ax, da, A, bx, db, B, R, result):
"""Cartesian 3D (gd) overlap integral.
Generated code; DO NOT modify by hand!"""
x0 = 0.5 / (ax + bx)
x1 = (ax + bx) ** (-1.0)
x2 = -x1 * (ax * A[0] + bx * B[0])
x3 = -x2 - A[0]
x4 = ax * bx * x1
x5 = numpy.exp(-x4 * (A[0] - B[0]) ** 2)
x6 = 1.77245385090551603 * numpy.sqrt(x1)
x7 = x5 * x6
x8 = x3**2 * x7
x9 = x0 * x7
x10 = 3.0 * x9
x11 = -x2 - B[0]
x12 = x3 * x7
x13 = x11 * x12
x14 = x10 + 2.0 * x13
x15 = x0 * (x14 + x8)
x16 = x11 * x7
x17 = x0 * (x12 + x16)
x18 = x13 + x9
x19 = x18 * x3
x20 = x17 + x19
x21 = x20 * x3
x22 = x11**2 * x7
x23 = x0 * (x14 + x22)
x24 = x11 * x18
x25 = x17 + x24
x26 = x25 * x3
x27 = x23 + x26
x28 = 2.0 * x0 * (2.0 * x17 + x19 + x24) + x27 * x3
x29 = da * db
x30 = 0.0563436169819011052
x31 = x29 * x30
x32 = numpy.exp(-x4 * (A[1] - B[1]) ** 2)
x33 = numpy.exp(-x4 * (A[2] - B[2]) ** 2)
x34 = 3.14159265358979324 * x1 * x33
x35 = x32 * x34
x36 = -x1 * (ax * A[1] + bx * B[1])
x37 = -x36 - B[1]
x38 = 0.0975900072948533179
x39 = x37 * x38
x40 = x8 + x9
x41 = 2.0 * x0 * x12 + x3 * x40
x42 = x15 + x21
x43 = x29 * x35
x44 = x43 * (x0 * (3.0 * x17 + 3.0 * x19 + x41) + x3 * x42)
x45 = -x1 * (ax * A[2] + bx * B[2])
x46 = -x45 - B[2]
x47 = x38 * x46
x48 = x32 * x6
x49 = x37**2 * x48
x50 = x0 * x48
x51 = x49 + x50
x52 = x0 * (x10 + 3.0 * x8) + x3 * x41
x53 = x33 * x6
x54 = x29 * x53
x55 = x30 * x54
x56 = x46**2 * x53
x57 = x0 * x53
x58 = x56 + x57
x59 = x31 * x58
x60 = -x36 - A[1]
x61 = 2.2360679774997897
x62 = 0.0666666666666666667 * x29
x63 = x61 * x62
x64 = x60 * x63
x65 = x28 * x35
x66 = x48 * x60
x67 = x37 * x66
x68 = x50 + x67
x69 = 0.0666666666666666667 * x54
x70 = 3.87298334620741689
x71 = x42 * x70
x72 = x35 * x62 * x71
x73 = x37 * x48
x74 = x0 * (x66 + x73)
x75 = x37 * x68
x76 = x74 + x75
x77 = x41 * x61
x78 = x46 * x53
x79 = x62 * x78
x80 = x41 * x70
x81 = x62 * x77
x82 = -x45 - A[2]
x83 = x63 * x82
x84 = x53 * x82
x85 = x46 * x84
x86 = x57 + x85
x87 = x48 * x62
x88 = x62 * x73
x89 = x0 * (x78 + x84)
x90 = x46 * x86
x91 = x89 + x90
x92 = x48 * x60**2
x93 = x50 + x92
x94 = 1.73205080756887729 * x29
x95 = 0.111111111111111111 * x93 * x94
x96 = x60 * x68
x97 = x74 + x96
x98 = 0.333333333333333333 * x20
x99 = x29 * x78
x100 = 3.0 * x50
x101 = x100 + 2.0 * x67
x102 = x0 * (x101 + x49)
x103 = x60 * x76
x104 = x102 + x103
x105 = x40 * x94
x106 = 0.111111111111111111 * x105
x107 = 0.333333333333333333 * x97
x108 = 0.333333333333333333 * x82
x109 = x68 * x94
x110 = 0.333333333333333333 * x86
x111 = x110 * x94
x112 = 0.333333333333333333 * x40
x113 = x29 * x76
x114 = x29 * x91
x115 = x53 * x82**2
x116 = x115 + x57
x117 = 0.111111111111111111 * x116 * x94
x118 = 0.333333333333333333 * x116
x119 = x118 * x29
x120 = x82 * x86
x121 = x120 + x89
x122 = x121 * x29
x123 = 3.0 * x57
x124 = x123 + 2.0 * x85
x125 = x0 * (x124 + x56)
x126 = x82 * x91
x127 = x125 + x126
x128 = x60 * (2.0 * x50 + x93)
x129 = x25 * x61
x130 = x0 * (x101 + x92)
x131 = x60 * x97
x132 = x130 + x131
x133 = x18 * x70
x134 = 2.0 * x0 * (2.0 * x74 + x75 + x96) + x104 * x60
x135 = x3 * x5
x136 = x135 * x34
x137 = x62 * x70
x138 = x132 * x137
x139 = x12 * x63
x140 = 0.333333333333333333 * x93
x141 = x18 * x94
x142 = 0.333333333333333333 * x121
x143 = 3.14159265358979324 * x1 * x32
x144 = x135 * x143
x145 = x82 * (x116 + 2.0 * x57)
x146 = x0 * (x115 + x124)
x147 = x121 * x82
x148 = x146 + x147
x149 = x137 * x148
x150 = 2.0 * x0 * (x120 + 2.0 * x89 + x90) + x127 * x82
x151 = x22 + x9
x152 = x0 * (x100 + 3.0 * x92) + x128 * x60
x153 = x34 * x5
x154 = x11 * x153
x155 = x29 * (x0 * (x128 + 3.0 * x74 + 3.0 * x96) + x132 * x60)
x156 = x31 * x5
x157 = x151 * x63
x158 = x137 * x16
x159 = x62 * x7
x160 = x159 * x70
x161 = x159 * x61
x162 = x143 * x5
x163 = x11 * x162
x164 = x0 * (3.0 * x115 + x123) + x145 * x82
x165 = x164 * x31
x166 = x29 * (x0 * (3.0 * x120 + x145 + 3.0 * x89) + x148 * x82)
# 90 item(s)
result[0] += (
x31 * x35 * (x0 * (2.0 * x15 + 2.0 * x21 + 3.0 * x23 + 3.0 * x26) + x28 * x3)
)
result[1] += x39 * x44
result[2] += x44 * x47
result[3] += x51 * x52 * x55
result[4] += x39 * x43 * x46 * x52
result[5] += x48 * x52 * x59
result[6] += x64 * x65
result[7] += x68 * x69 * x71
result[8] += x46 * x60 * x72
result[9] += x69 * x76 * x77
result[10] += x68 * x79 * x80
result[11] += x58 * x66 * x81
result[12] += x65 * x83
result[13] += x37 * x72 * x82
result[14] += x71 * x86 * x87
result[15] += x51 * x81 * x84
result[16] += x80 * x86 * x88
result[17] += x77 * x87 * x91
result[18] += x27 * x53 * x95
result[19] += x54 * x97 * x98
result[20] += x93 * x98 * x99
result[21] += x104 * x106 * x53
result[22] += x107 * x40 * x99
result[23] += x106 * x58 * x93
result[24] += x108 * x27 * x43 * x60
result[25] += x109 * x84 * x98
result[26] += x111 * x20 * x66
result[27] += x112 * x113 * x84
result[28] += x105 * x110 * x68
result[29] += x112 * x114 * x66
result[30] += x117 * x27 * x48
result[31] += x119 * x20 * x73
result[32] += x122 * x48 * x98
result[33] += x106 * x116 * x51
result[34] += x112 * x122 * x73
result[35] += x106 * x127 * x48
result[36] += x128 * x129 * x69
result[37] += x132 * x133 * x69
result[38] += x128 * x133 * x79
result[39] += x134 * x136 * x63
result[40] += x136 * x138 * x46
result[41] += x128 * x139 * x58
result[42] += x140 * x25 * x29 * x84
result[43] += x107 * x141 * x84
result[44] += x110 * x141 * x93
result[45] += x104 * x108 * x136 * x29
result[46] += x111 * x12 * x97
result[47] += x114 * x12 * x140
result[48] += x119 * x25 * x66
result[49] += x118 * x141 * x68
result[50] += x141 * x142 * x66
result[51] += x113 * x118 * x12
result[52] += x109 * x12 * x142
result[53] += 0.333333333333333333 * x127 * x144 * x29 * x60
result[54] += x129 * x145 * x87
result[55] += x133 * x145 * x88
result[56] += x133 * x148 * x87
result[57] += x139 * x145 * x51
result[58] += x144 * x149 * x37
result[59] += x144 * x150 * x63
result[60] += x151 * x152 * x55
result[61] += x154 * x155 * x38
result[62] += x152 * x154 * x29 * x47
result[63] += (
x156
* x34
* (x0 * (3.0 * x102 + 3.0 * x103 + 2.0 * x130 + 2.0 * x131) + x134 * x60)
)
result[64] += x153 * x155 * x47
result[65] += x152 * x59 * x7
result[66] += x128 * x157 * x84
result[67] += x138 * x154 * x82
result[68] += x128 * x158 * x86
result[69] += x134 * x153 * x83
result[70] += x132 * x160 * x86
result[71] += x128 * x161 * x91
result[72] += x116 * x151 * x95
result[73] += x119 * x16 * x97
result[74] += x122 * x140 * x16
result[75] += x104 * x117 * x7
result[76] += x107 * x122 * x7
result[77] += x127 * x7 * x95
result[78] += x145 * x157 * x66
result[79] += x145 * x158 * x68
result[80] += x149 * x163 * x60
result[81] += x145 * x161 * x76
result[82] += x148 * x160 * x68
result[83] += x150 * x162 * x64
result[84] += x151 * x165 * x48
result[85] += x163 * x164 * x29 * x39
result[86] += x163 * x166 * x38
result[87] += x165 * x51 * x7
result[88] += x162 * x166 * x39
result[89] += (
x143
* x156
* (x0 * (3.0 * x125 + 3.0 * x126 + 2.0 * x146 + 2.0 * x147) + x150 * x82)
)
[docs]
@numba.jit(
func_type.signature,
nopython=True,
nogil=True,
fastmath=True,
cache=True,
)
def ovlp3d_24(ax, da, A, bx, db, B, R, result):
"""See docstring of ovlp3d_42."""
# Call equivalent function and write to result
tmp = numpy.zeros_like(result)
ovlp3d_42(bx, db, B, ax, da, A, R, tmp)
result[:] += numpy.transpose(tmp.reshape(15, 6), axes=(1, 0)).flatten()
[docs]
@numba.jit(
func_type.signature,
nopython=True,
nogil=True,
fastmath=True,
cache=True,
)
def ovlp3d_33(ax, da, A, bx, db, B, R, result):
"""Cartesian 3D (ff) overlap integral.
Generated code; DO NOT modify by hand!"""
x0 = (ax + bx) ** (-1.0)
x1 = x0 * (ax * A[0] + bx * B[0])
x2 = -x1
x3 = x2 + B[0]
x4 = x0 * (-2.0 * x1 + A[0] + B[0])
x5 = x2 + A[0]
x6 = x3 * x5
x7 = x0 + 2.0 * x6
x8 = x3 * x7
x9 = x4 + x8
x10 = x3 * x9
x11 = x3**2
x12 = 3.0 * x0
x13 = x12 + 4.0 * x6
x14 = x0 * (2.0 * x11 + x13)
x15 = x5 * x9
x16 = x14 + 2.0 * x15
x17 = x5 * x7
x18 = 2.0 * x0
x19 = x18 * (x17 + 2.0 * x4 + x8)
x20 = x16 * x3 + x19
x21 = 2.0 * x5
x22 = ax * bx * x0
x23 = (
5.56832799683170785
* da
* db
* numpy.exp(-x22 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2))
)
x24 = x0**1.5 * x23
x25 = 0.00833333333333333333 * x24
x26 = x0 * (ax * A[1] + bx * B[1])
x27 = -x26
x28 = x27 + B[1]
x29 = 2.2360679774997897
x30 = 0.0166666666666666667 * x29
x31 = x24 * x30
x32 = x31 * (x16 * x5 + x19)
x33 = x0 * (ax * A[2] + bx * B[2])
x34 = -x33
x35 = x34 + B[2]
x36 = x28**2
x37 = 0.5 * x0
x38 = x36 + x37
x39 = x0**1.5 * x23
x40 = x38 * x39
x41 = x5**2
x42 = x17 + x4
x43 = x0 * (x13 + 2.0 * x41) + x21 * x42
x44 = x30 * x43
x45 = 0.0645497224367902814
x46 = x24 * x45
x47 = x35**2
x48 = x37 + x47
x49 = x39 * x48
x50 = 1.5 * x0
x51 = 0.0666666666666666667 * x5
x52 = x51 * (x41 + x50)
x53 = x36 + x50
x54 = x28 * x39
x55 = x53 * x54
x56 = x29 * x52
x57 = x47 + x50
x58 = x35 * x39
x59 = x57 * x58
x60 = x27 + A[1]
x61 = x20 * x31
x62 = 0.0833333333333333333 * x16
x63 = x28 * x60
x64 = x39 * (x37 + x63)
x65 = x24 * x62
x66 = x35 * x60
x67 = x0 * (-2.0 * x26 + A[1] + B[1])
x68 = x0 + 2.0 * x63
x69 = x28 * x68
x70 = x67 + x69
x71 = 0.0833333333333333333 * x39
x72 = x42 * x71
x73 = 1.73205080756887729
x74 = 0.166666666666666667 * x42
x75 = x73 * x74
x76 = x49 * x60
x77 = x12 + 4.0 * x63
x78 = x0 * (2.0 * x36 + x77)
x79 = 2.0 * x70
x80 = x28 * x79 + x78
x81 = x37 + x41
x82 = x39 * x81
x83 = x30 * x82
x84 = 0.166666666666666667 * x82
x85 = 0.333333333333333333 * x81
x86 = x29 * x57
x87 = 0.0666666666666666667 * x82
x88 = x34 + A[2]
x89 = x28 * x88
x90 = x35 * x88
x91 = x37 + x90
x92 = x39 * x91
x93 = x40 * x88
x94 = x0 * (-2.0 * x33 + A[2] + B[2])
x95 = x0 + 2.0 * x90
x96 = x35 * x95
x97 = x94 + x96
x98 = x29 * x53
x99 = x12 + 4.0 * x90
x100 = x0 * (2.0 * x47 + x99)
x101 = 2.0 * x97
x102 = x100 + x101 * x35
x103 = x60**2
x104 = x103 + x37
x105 = x104 * x39
x106 = 2.0 * x10 + x14
x107 = x106 * x30
x108 = x60 * x68
x109 = x108 + x67
x110 = x71 * x9
x111 = 0.166666666666666667 * x9
x112 = x105 * x35
x113 = x60 * x79 + x78
x114 = x37 + x6
x115 = x114 * x71
x116 = x109 * x73
x117 = 0.166666666666666667 * x114
x118 = 0.333333333333333333 * x114
x119 = x18 * (x108 + 2.0 * x67 + x69)
x120 = x113 * x28 + x119
x121 = x31 * x5
x122 = x24 * x5
x123 = 0.0833333333333333333 * x113
x124 = 0.166666666666666667 * x5
x125 = x111 * x73
x126 = x70 * x73
x127 = x39 * x88
x128 = x73 * x97
x129 = x39 * x60
x130 = x122 * x45
x131 = x88**2
x132 = x131 + x37
x133 = x132 * x39
x134 = x133 * x28
x135 = x88 * x95
x136 = x135 + x94
x137 = x136 * x73
x138 = x100 + x101 * x88
x139 = 0.0833333333333333333 * x138
x140 = x18 * (x135 + 2.0 * x94 + x96)
x141 = x138 * x35 + x140
x142 = 0.0666666666666666667 * x103 + 0.0666666666666666667 * x50
x143 = x3 * (x11 + x50)
x144 = 2.0 * x60
x145 = x0 * (2.0 * x103 + x77) + x109 * x144
x146 = x145 * x30
x147 = x11 + x37
x148 = x147 * x39
x149 = x142 * x29
x150 = x31 * (x113 * x60 + x119)
x151 = x24 * x3
x152 = x151 * x45
x153 = 0.0666666666666666667 * x143 * x29
x154 = 0.166666666666666667 * x148
x155 = 0.333333333333333333 * x147
x156 = 0.166666666666666667 * x3
x157 = 0.0666666666666666667 * x131 + 0.0666666666666666667 * x50
x158 = x157 * x29
x159 = 2.0 * x88
x160 = x0 * (2.0 * x131 + x99) + x136 * x159
x161 = x160 * x30
x162 = x31 * (x138 * x88 + x140)
# 100 item(s)
result[0] += x25 * (x0 * (4.0 * x10 + 5.0 * x14 + 6.0 * x15) + x20 * x21)
result[1] += x28 * x32
result[2] += x32 * x35
result[3] += x40 * x44
result[4] += x28 * x35 * x43 * x46
result[5] += x44 * x49
result[6] += x52 * x55
result[7] += x35 * x40 * x56
result[8] += x28 * x49 * x56
result[9] += x52 * x59
result[10] += x60 * x61
result[11] += x62 * x64
result[12] += x65 * x66
result[13] += x70 * x72
result[14] += x35 * x64 * x75
result[15] += x74 * x76
result[16] += x80 * x83
result[17] += x35 * x70 * x84
result[18] += x48 * x64 * x85
result[19] += x66 * x86 * x87
result[20] += x61 * x88
result[21] += x65 * x89
result[22] += x62 * x92
result[23] += x74 * x93
result[24] += x28 * x75 * x92
result[25] += x72 * x97
result[26] += x87 * x89 * x98
result[27] += x38 * x85 * x92
result[28] += x28 * x84 * x97
result[29] += x102 * x83
result[30] += x105 * x107
result[31] += x109 * x110
result[32] += x111 * x112
result[33] += x113 * x115
result[34] += x116 * x117 * x58
result[35] += x104 * x118 * x49
result[36] += x120 * x121
result[37] += x122 * x123 * x35
result[38] += x109 * x124 * x49
result[39] += x112 * x51 * x86
result[40] += x106 * x46 * x60 * x88
result[41] += x125 * x64 * x88
result[42] += x125 * x60 * x92
result[43] += x117 * x126 * x127
result[44] += x114 * x64 * x91
result[45] += x117 * x128 * x129
result[46] += x130 * x80 * x88
result[47] += x124 * x126 * x92
result[48] += x124 * x128 * x64
result[49] += x102 * x130 * x60
result[50] += x107 * x133
result[51] += x111 * x134
result[52] += x110 * x136
result[53] += x118 * x132 * x40
result[54] += x117 * x137 * x54
result[55] += x115 * x138
result[56] += x134 * x51 * x98
result[57] += x124 * x136 * x40
result[58] += x122 * x139 * x28
result[59] += x121 * x141
result[60] += x129 * x142 * x143
result[61] += x146 * x148
result[62] += x148 * x149 * x66
result[63] += x150 * x3
result[64] += x145 * x152 * x35
result[65] += x149 * x3 * x76
result[66] += x25 * (
x0 * (4.0 * x28 * x70 + 6.0 * x60 * x70 + 5.0 * x78) + x120 * x144
)
result[67] += x150 * x35
result[68] += x146 * x49
result[69] += x142 * x59 * x60
result[70] += x105 * x153 * x88
result[71] += x109 * x154 * x88
result[72] += x104 * x155 * x92
result[73] += x123 * x151 * x88
result[74] += x116 * x156 * x92
result[75] += x105 * x156 * x97
result[76] += x120 * x31 * x88
result[77] += x113 * x71 * x91
result[78] += x109 * x71 * x97
result[79] += x102 * x105 * x30
result[80] += x133 * x153 * x60
result[81] += x132 * x155 * x64
result[82] += x136 * x154 * x60
result[83] += x133 * x156 * x70
result[84] += x137 * x156 * x64
result[85] += x139 * x151 * x60
result[86] += x133 * x30 * x80
result[87] += x136 * x70 * x71
result[88] += x139 * x64
result[89] += x141 * x31 * x60
result[90] += x127 * x143 * x157
result[91] += x148 * x158 * x89
result[92] += x148 * x161
result[93] += x158 * x3 * x93
result[94] += x152 * x160 * x28
result[95] += x162 * x3
result[96] += x157 * x55 * x88
result[97] += x161 * x40
result[98] += x162 * x28
result[99] += x25 * (
x0 * (5.0 * x100 + 4.0 * x35 * x97 + 6.0 * x88 * x97) + x141 * x159
)
[docs]
@numba.jit(
func_type.signature,
nopython=True,
nogil=True,
fastmath=True,
cache=True,
)
def ovlp3d_43(ax, da, A, bx, db, B, R, result):
"""Cartesian 3D (gf) overlap integral.
Generated code; DO NOT modify by hand!"""
x0 = 0.5 / (ax + bx)
x1 = (ax + bx) ** (-1.0)
x2 = -x1 * (ax * A[0] + bx * B[0])
x3 = -x2 - A[0]
x4 = -x2 - B[0]
x5 = ax * bx * x1
x6 = numpy.exp(-x5 * (A[0] - B[0]) ** 2)
x7 = 1.77245385090551603 * numpy.sqrt(x1)
x8 = x6 * x7
x9 = x4**2 * x8
x10 = x0 * x8
x11 = 3.0 * x10
x12 = x3 * x8
x13 = x12 * x4
x14 = x11 + 2.0 * x13
x15 = x0 * (x14 + x9)
x16 = x4 * x8
x17 = x0 * (x12 + x16)
x18 = x10 + x13
x19 = x18 * x4
x20 = x17 + x19
x21 = x20 * x3
x22 = x15 + x21
x23 = x22 * x3
x24 = x22 * x4
x25 = x18 * x3
x26 = 2.0 * x0 * (2.0 * x17 + x19 + x25)
x27 = x20 * x4
x28 = 3.0 * x21
x29 = x24 + x26
x30 = x0 * (5.0 * x15 + 2.0 * x27 + x28) + x29 * x3
x31 = da * db
x32 = 0.00952380952380952381 * x31
x33 = 2.64575131106459059 * x32
x34 = numpy.exp(-x5 * (A[1] - B[1]) ** 2)
x35 = numpy.exp(-x5 * (A[2] - B[2]) ** 2)
x36 = 3.14159265358979324 * x1 * x35
x37 = x34 * x36
x38 = -x1 * (ax * A[1] + bx * B[1])
x39 = -x38 - B[1]
x40 = x37 * x39
x41 = x3**2 * x8
x42 = x0 * (x14 + x41)
x43 = x17 + x25
x44 = x3 * x43
x45 = x23 + x26
x46 = 5.91607978309961604
x47 = x32 * x46
x48 = x47 * (x0 * (3.0 * x15 + x28 + 2.0 * x42 + 2.0 * x44) + x3 * x45)
x49 = -x1 * (ax * A[2] + bx * B[2])
x50 = -x49 - B[2]
x51 = x37 * x50
x52 = x34 * x7
x53 = x39**2 * x52
x54 = x0 * x52
x55 = x53 + x54
x56 = x31 * x55
x57 = x35 * x7
x58 = x46 * x57
x59 = x10 + x41
x60 = 2.0 * x0
x61 = x12 * x60 + x3 * x59
x62 = x42 + x44
x63 = x0 * (3.0 * x17 + 3.0 * x25 + x61) + x3 * x62
x64 = 0.00952380952380952381 * x63
x65 = 10.2469507659595984 * x32
x66 = x50 * x65
x67 = x50**2 * x57
x68 = x0 * x57
x69 = x67 + x68
x70 = x31 * x69
x71 = x46 * x70
x72 = 2.0 * x54
x73 = x39 * (x55 + x72)
x74 = x0 * (x11 + 3.0 * x41) + x3 * x61
x75 = x33 * x74
x76 = 0.00952380952380952381 * x74
x77 = x50 * x57
x78 = x46 * x77
x79 = x39 * x52
x80 = 2.0 * x68
x81 = x50 * (x69 + x80)
x82 = -x38 - A[1]
x83 = 0.0666666666666666667 * x31
x84 = x82 * x83
x85 = x30 * x37
x86 = x52 * x82
x87 = x39 * x86
x88 = x54 + x87
x89 = 0.14907119849998598
x90 = x31 * x89
x91 = x57 * x90
x92 = x45 * x90
x93 = x0 * (x79 + x86)
x94 = x39 * x88
x95 = x93 + x94
x96 = 3.87298334620741689
x97 = x83 * x96
x98 = x62 * x97
x99 = x62 * x89
x100 = 0.0666666666666666667 * x57
x101 = 3.0 * x54
x102 = x101 + 2.0 * x87
x103 = x0 * (x102 + x53)
x104 = x39 * x95
x105 = x103 + x104
x106 = x105 * x31
x107 = x61 * x89
x108 = x107 * x31
x109 = x61 * x83
x110 = -x49 - A[2]
x111 = x110 * x83
x112 = x110 * x57
x113 = x112 * x50
x114 = x113 + x68
x115 = x52 * x90
x116 = x0 * (x112 + x77)
x117 = x114 * x50
x118 = x116 + x117
x119 = 0.0666666666666666667 * x52
x120 = 3.0 * x68
x121 = 2.0 * x113 + x120
x122 = x0 * (x121 + x67)
x123 = x118 * x50
x124 = x122 + x123
x125 = x124 * x31
x126 = x52 * x82**2
x127 = x126 + x54
x128 = x127 * x31
x129 = 0.0222222222222222222 * x96
x130 = x128 * x129
x131 = x82 * x88
x132 = x131 + x93
x133 = x31 * x57
x134 = 1.73205080756887729
x135 = 0.111111111111111111 * x134
x136 = x135 * x22
x137 = x82 * x95
x138 = x103 + x137
x139 = x134 * x43
x140 = 0.111111111111111111 * x139
x141 = 0.333333333333333333 * x31
x142 = x141 * x43
x143 = 0.111111111111111111 * x70
x144 = 2.0 * x0 * (x131 + 2.0 * x93 + x94)
x145 = x138 * x39
x146 = x144 + x145
x147 = x129 * x59
x148 = x138 * x31
x149 = x134 * x59
x150 = 0.111111111111111111 * x149
x151 = x110 * x90
x152 = x141 * x88
x153 = x114 * x141
x154 = x59 * x89
x155 = x141 * x59
x156 = x110**2 * x57
x157 = x156 + x68
x158 = x157 * x31
x159 = x129 * x158
x160 = x110 * x114
x161 = x116 + x160
x162 = x31 * x52
x163 = 0.111111111111111111 * x56
x164 = x110 * x118
x165 = x122 + x164
x166 = x165 * x31
x167 = 2.0 * x0 * (2.0 * x116 + x117 + x160)
x168 = x165 * x50
x169 = x167 + x168
x170 = x15 + x27
x171 = x82 * (x127 + x72)
x172 = x171 * x31
x173 = x0 * (x102 + x126)
x174 = x132 * x82
x175 = x173 + x174
x176 = x20 * x89
x177 = x138 * x82
x178 = x144 + x177
x179 = x18 * x89
x180 = x18 * x97
x181 = x3 * x83
x182 = 3.0 * x137
x183 = x0 * (5.0 * x103 + 2.0 * x104 + x182) + x146 * x82
x184 = x36 * x6
x185 = x183 * x184
x186 = x184 * x3
x187 = x12 * x89
x188 = 0.0666666666666666667 * x12
x189 = x170 * x89
x190 = x112 * x141
x191 = x127 * x141
x192 = x134 * x18
x193 = x12 * x141
x194 = x141 * x157
x195 = x141 * x86
x196 = 3.14159265358979324 * x1 * x34 * x6
x197 = x196 * x3 * x90
x198 = x110 * (x157 + x80)
x199 = x198 * x31
x200 = x0 * (x121 + x156)
x201 = x110 * x161
x202 = x200 + x201
x203 = x110 * x165
x204 = x167 + x203
x205 = 3.0 * x164
x206 = x0 * (5.0 * x122 + 2.0 * x123 + x205) + x110 * x169
x207 = x196 * x206
x208 = x10 + x9
x209 = x16 * x60 + x208 * x4
x210 = x0 * (x101 + 3.0 * x126) + x171 * x82
x211 = x210 * x33
x212 = x0 * (3.0 * x131 + x171 + 3.0 * x93) + x175 * x82
x213 = x208 * x32
x214 = x4 * x47
x215 = x184 * (x0 * (3.0 * x103 + 2.0 * x173 + 2.0 * x174 + x182) + x178 * x82)
x216 = x184 * x4
x217 = 0.00952380952380952381 * x16
x218 = 0.00952380952380952381 * x8
x219 = 0.0666666666666666667 * x209
x220 = x208 * x89
x221 = x220 * x31
x222 = x16 * x97
x223 = x16 * x89
x224 = x8 * x90
x225 = 0.0666666666666666667 * x8
x226 = x135 * x208
x227 = x135 * x16
x228 = x135 * x8
x229 = x196 * x4
x230 = x0 * (x120 + 3.0 * x156) + x110 * x198
x231 = x230 * x33
x232 = x230 * x46
x233 = x0 * (3.0 * x116 + 3.0 * x160 + x198) + x110 * x202
x234 = x233 * x46
x235 = x196 * (x0 * (3.0 * x122 + 2.0 * x200 + 2.0 * x201 + x205) + x110 * x204)
# 150 item(s)
result[0] += x33 * x37 * (3.0 * x0 * (x23 + x24 + 2.0 * x26) + x3 * x30)
result[1] += x40 * x48
result[2] += x48 * x51
result[3] += x56 * x58 * x64
result[4] += x40 * x63 * x66
result[5] += x52 * x64 * x71
result[6] += x57 * x73 * x75
result[7] += x56 * x76 * x78
result[8] += x71 * x76 * x79
result[9] += x52 * x75 * x81
result[10] += x84 * x85
result[11] += x45 * x88 * x91
result[12] += x51 * x82 * x92
result[13] += x62 * x91 * x95
result[14] += x77 * x88 * x98
result[15] += x70 * x86 * x99
result[16] += x100 * x106 * x61
result[17] += x108 * x77 * x95
result[18] += x107 * x70 * x88
result[19] += x109 * x81 * x86
result[20] += x111 * x85
result[21] += x110 * x40 * x92
result[22] += x114 * x115 * x45
result[23] += x112 * x56 * x99
result[24] += x114 * x79 * x98
result[25] += x115 * x118 * x62
result[26] += x109 * x112 * x73
result[27] += x107 * x114 * x56
result[28] += x108 * x118 * x79
result[29] += x119 * x125 * x61
result[30] += x130 * x29 * x57
result[31] += x132 * x133 * x136
result[32] += x128 * x136 * x77
result[33] += x133 * x138 * x140
result[34] += x132 * x142 * x77
result[35] += x127 * x139 * x143
result[36] += x133 * x146 * x147
result[37] += x148 * x150 * x77
result[38] += x132 * x143 * x149
result[39] += x128 * x147 * x81
result[40] += x151 * x29 * x37 * x82
result[41] += x112 * x152 * x22
result[42] += x153 * x22 * x86
result[43] += x112 * x142 * x95
result[44] += x139 * x153 * x88
result[45] += x118 * x142 * x86
result[46] += x106 * x112 * x154
result[47] += x114 * x155 * x95
result[48] += x118 * x155 * x88
result[49] += x125 * x154 * x86
result[50] += x159 * x29 * x52
result[51] += x136 * x158 * x79
result[52] += x136 * x161 * x162
result[53] += x139 * x157 * x163
result[54] += x142 * x161 * x79
result[55] += x140 * x162 * x165
result[56] += x147 * x158 * x73
result[57] += x149 * x161 * x163
result[58] += x150 * x166 * x79
result[59] += x147 * x162 * x169
result[60] += x100 * x170 * x172
result[61] += x175 * x20 * x91
result[62] += x172 * x176 * x77
result[63] += x133 * x178 * x179
result[64] += x175 * x180 * x77
result[65] += x171 * x179 * x70
result[66] += x181 * x185
result[67] += x178 * x186 * x50 * x90
result[68] += x175 * x187 * x70
result[69] += x172 * x188 * x81
result[70] += x112 * x128 * x189
result[71] += x132 * x190 * x20
result[72] += x114 * x191 * x20
result[73] += x138 * x18 * x190
result[74] += x132 * x153 * x192
result[75] += x118 * x18 * x191
result[76] += x146 * x151 * x186
result[77] += x12 * x138 * x153
result[78] += x118 * x132 * x193
result[79] += x124 * x128 * x187
result[80] += x158 * x189 * x86
result[81] += x194 * x20 * x88
result[82] += x161 * x195 * x20
result[83] += x18 * x194 * x95
result[84] += x152 * x161 * x192
result[85] += x165 * x18 * x195
result[86] += x105 * x158 * x187
result[87] += x161 * x193 * x95
result[88] += x12 * x152 * x165
result[89] += x169 * x197 * x82
result[90] += x119 * x170 * x199
result[91] += x176 * x199 * x79
result[92] += x115 * x20 * x202
result[93] += x179 * x198 * x56
result[94] += x180 * x202 * x79
result[95] += x162 * x179 * x204
result[96] += x188 * x199 * x73
result[97] += x187 * x202 * x56
result[98] += x197 * x204 * x39
result[99] += x181 * x207
result[100] += x209 * x211 * x57
result[101] += x212 * x213 * x58
result[102] += x210 * x213 * x78
result[103] += x214 * x215
result[104] += x212 * x216 * x66
result[105] += x210 * x217 * x71
result[106] += x184 * x33 * (3.0 * x0 * (2.0 * x144 + x145 + x177) + x183 * x82)
result[107] += x215 * x47 * x50
result[108] += x212 * x218 * x71
result[109] += x211 * x8 * x81
result[110] += x112 * x172 * x219
result[111] += x112 * x175 * x221
result[112] += x114 * x172 * x220
result[113] += x151 * x178 * x216
result[114] += x114 * x175 * x222
result[115] += x118 * x172 * x223
result[116] += x111 * x185
result[117] += x114 * x178 * x224
result[118] += x118 * x175 * x224
result[119] += x124 * x172 * x225
result[120] += x130 * x157 * x209
result[121] += x132 * x158 * x226
result[122] += x128 * x161 * x226
result[123] += x138 * x158 * x227
result[124] += x132 * x141 * x16 * x161
result[125] += x128 * x165 * x227
result[126] += x146 * x159 * x8
result[127] += x148 * x161 * x228
result[128] += x132 * x166 * x228
result[129] += x130 * x169 * x8
result[130] += x199 * x219 * x86
result[131] += x199 * x220 * x88
result[132] += x202 * x221 * x86
result[133] += x199 * x223 * x95
result[134] += x202 * x222 * x88
result[135] += x204 * x229 * x82 * x90
result[136] += x105 * x199 * x225
result[137] += x202 * x224 * x95
result[138] += x204 * x224 * x88
result[139] += x207 * x84
result[140] += x209 * x231 * x52
result[141] += x213 * x232 * x79
result[142] += x213 * x234 * x52
result[143] += x217 * x232 * x56
result[144] += x229 * x233 * x39 * x65
result[145] += x214 * x235
result[146] += x231 * x73 * x8
result[147] += x218 * x234 * x56
result[148] += x235 * x39 * x47
result[149] += x196 * x33 * (3.0 * x0 * (2.0 * x167 + x168 + x203) + x110 * x206)
[docs]
@numba.jit(
func_type.signature,
nopython=True,
nogil=True,
fastmath=True,
cache=True,
)
def ovlp3d_34(ax, da, A, bx, db, B, R, result):
"""See docstring of ovlp3d_43."""
# Call equivalent function and write to result
tmp = numpy.zeros_like(result)
ovlp3d_43(bx, db, B, ax, da, A, R, tmp)
result[:] += numpy.transpose(tmp.reshape(15, 10), axes=(1, 0)).flatten()
[docs]
@numba.jit(
func_type.signature,
nopython=True,
nogil=True,
fastmath=True,
cache=True,
)
def ovlp3d_44(ax, da, A, bx, db, B, R, result):
"""Cartesian 3D (gg) overlap integral.
Generated code; DO NOT modify by hand!"""
x0 = 0.5 / (ax + bx)
x1 = (ax + bx) ** (-1.0)
x2 = -x1 * (ax * A[0] + bx * B[0])
x3 = -x2 - B[0]
x4 = -x2 - A[0]
x5 = ax * bx * x1
x6 = numpy.exp(-x5 * (A[0] - B[0]) ** 2)
x7 = 1.77245385090551603 * numpy.sqrt(x1)
x8 = x6 * x7
x9 = x0 * x8
x10 = x4 * x8
x11 = x10 * x3
x12 = x11 + x9
x13 = x12 * x4
x14 = x12 * x3
x15 = x3 * x8
x16 = x0 * (x10 + x15)
x17 = 2.0 * x0 * (x13 + x14 + 2.0 * x16)
x18 = x3**2 * x8
x19 = 3.0 * x9
x20 = 2.0 * x11 + x19
x21 = x0 * (x18 + x20)
x22 = x14 + x16
x23 = x22 * x4
x24 = x21 + x23
x25 = x24 * x3
x26 = x17 + x25
x27 = x26 * x3
x28 = x26 * x4
x29 = x22 * x3
x30 = 3.0 * x23
x31 = x0 * (5.0 * x21 + 2.0 * x29 + x30)
x32 = x24 * x4
x33 = 3.0 * x0 * (2.0 * x17 + x25 + x32)
x34 = x28 + x31
x35 = x3 * x34 + x33
x36 = numpy.exp(-x5 * (A[1] - B[1]) ** 2)
x37 = da * db
x38 = 0.00952380952380952381 * x37
x39 = numpy.exp(-x5 * (A[2] - B[2]) ** 2)
x40 = 3.14159265358979324 * x1 * x39
x41 = x38 * x40
x42 = x36 * x41
x43 = -x1 * (ax * A[1] + bx * B[1])
x44 = -x43 - B[1]
x45 = 2.64575131106459059
x46 = x42 * x45
x47 = x46 * (x33 + x34 * x4)
x48 = -x1 * (ax * A[2] + bx * B[2])
x49 = -x48 - B[2]
x50 = x4**2 * x8
x51 = x0 * (x20 + x50)
x52 = x13 + x16
x53 = x4 * x52
x54 = x17 + x32
x55 = x0 * (3.0 * x21 + x30 + 2.0 * x51 + 2.0 * x53) + x4 * x54
x56 = x39 * x7
x57 = 0.0325300024316177726
x58 = x36 * x7
x59 = x44**2 * x58
x60 = x0 * x58
x61 = x59 + x60
x62 = x37 * x61
x63 = x57 * x62
x64 = 5.91607978309961604
x65 = x42 * x64
x66 = x49**2 * x56
x67 = x0 * x56
x68 = x66 + x67
x69 = x37 * x68
x70 = x57 * x69
x71 = 2.0 * x60
x72 = x44 * (x61 + x71)
x73 = 3.0 * x16
x74 = x50 + x9
x75 = 2.0 * x9
x76 = x4 * (x74 + x75)
x77 = x51 + x53
x78 = x0 * (3.0 * x13 + x73 + x76) + x4 * x77
x79 = x38 * x45
x80 = x78 * x79
x81 = x49 * x56
x82 = 0.00952380952380952381 * x64
x83 = x78 * x82
x84 = x44 * x58
x85 = 2.0 * x67
x86 = x49 * (x68 + x85)
x87 = 3.0 * x60
x88 = x0 * (3.0 * x59 + x87) + x44 * x72
x89 = x0 * (x19 + 3.0 * x50) + x4 * x76
x90 = x38 * x89
x91 = x45 * x90
x92 = 3.0 * x67
x93 = x0 * (3.0 * x66 + x92) + x49 * x86
x94 = -x43 - A[1]
x95 = x35 * x46
x96 = x58 * x94
x97 = x44 * x96
x98 = x60 + x97
x99 = x37 * x98
x100 = 0.0666666666666666667 * x56
x101 = 0.0666666666666666667 * x37
x102 = x101 * x40
x103 = x102 * x49
x104 = x34 * x36
x105 = x0 * (x84 + x96)
x106 = x44 * x98
x107 = x105 + x106
x108 = 0.0860662965823870419
x109 = x108 * x37
x110 = x109 * x54
x111 = 0.14907119849998598
x112 = x111 * x54
x113 = x108 * x54
x114 = x87 + 2.0 * x97
x115 = x0 * (x114 + x59)
x116 = x107 * x44
x117 = x115 + x116
x118 = x37 * x77
x119 = x111 * x77
x120 = x119 * x37
x121 = 0.0666666666666666667 * x118
x122 = 3.0 * x105
x123 = x0 * (3.0 * x106 + x122 + x72) + x117 * x44
x124 = x76 * x79
x125 = 0.0666666666666666667 * x76
x126 = x125 * x37
x127 = x108 * x76
x128 = -x48 - A[2]
x129 = x102 * x128
x130 = x128 * x56
x131 = x130 * x49
x132 = x131 + x67
x133 = x132 * x37
x134 = 0.0666666666666666667 * x58
x135 = x0 * (x130 + x81)
x136 = x132 * x49
x137 = x135 + x136
x138 = 2.0 * x131 + x92
x139 = x0 * (x138 + x66)
x140 = x137 * x49
x141 = x139 + x140
x142 = 3.0 * x135
x143 = x0 * (3.0 * x136 + x142 + x86) + x141 * x49
x144 = x27 + x31
x145 = x58 * x94**2
x146 = x145 + x60
x147 = x146 * x37
x148 = x147 * x57
x149 = x94 * x98
x150 = x105 + x149
x151 = x109 * x56
x152 = x108 * x81
x153 = x107 * x94
x154 = x115 + x153
x155 = 0.111111111111111111 * x37
x156 = x155 * x24
x157 = 1.73205080756887729
x158 = x155 * x157
x159 = x158 * x24
x160 = x155 * x68
x161 = 2.0 * x0 * (2.0 * x105 + x106 + x149)
x162 = x154 * x44
x163 = x161 + x162
x164 = x157 * x52
x165 = x154 * x155
x166 = x108 * x86
x167 = 3.0 * x153
x168 = x0 * (5.0 * x115 + 2.0 * x116 + x167)
x169 = x163 * x44
x170 = x168 + x169
x171 = x37 * x74
x172 = x171 * x57
x173 = x111 * x26
x174 = x107 * x158
x175 = 0.333333333333333333 * x99
x176 = x137 * x158
x177 = x111 * x37
x178 = x177 * x52
x179 = 0.333333333333333333 * x133
x180 = x171 * x82
x181 = x111 * x74
x182 = x128**2 * x56
x183 = x182 + x67
x184 = x183 * x37
x185 = x184 * x57
x186 = x108 * x84
x187 = x128 * x132
x188 = x135 + x187
x189 = x109 * x58
x190 = x155 * x61
x191 = x128 * x137
x192 = x139 + x191
x193 = x108 * x72
x194 = 2.0 * x0 * (2.0 * x135 + x136 + x187)
x195 = x192 * x49
x196 = x194 + x195
x197 = 3.0 * x191
x198 = x0 * (5.0 * x139 + 2.0 * x140 + x197)
x199 = x196 * x49
x200 = x198 + x199
x201 = x94 * (x146 + x71)
x202 = x18 + x9
x203 = x3 * (x202 + x75)
x204 = x21 + x29
x205 = x0 * (3.0 * x14 + x203 + x73) + x204 * x3
x206 = x205 * x79
x207 = x0 * (x114 + x145)
x208 = x150 * x94
x209 = x207 + x208
x210 = x204 * x37
x211 = 0.0666666666666666667 * x201
x212 = x154 * x94
x213 = x161 + x212
x214 = x108 * x22
x215 = x214 * x37
x216 = x177 * x22
x217 = x163 * x94
x218 = x168 + x217
x219 = x12 * x37
x220 = x111 * x219
x221 = x4 * x45
x222 = 3.0 * x0 * (2.0 * x161 + x162 + x212)
x223 = x218 * x44 + x222
x224 = x41 * x6
x225 = x223 * x224
x226 = x218 * x6
x227 = x10 * x108
x228 = x10 * x101
x229 = x10 * x79
x230 = x147 * x82
x231 = x111 * x204
x232 = x231 * x37
x233 = x158 * x22
x234 = 0.333333333333333333 * x219
x235 = x4 * x64
x236 = x10 * x111
x237 = x10 * x177
x238 = x184 * x82
x239 = 3.14159265358979324 * x1 * x36 * x6
x240 = x239 * x38
x241 = x128 * (x183 + x85)
x242 = 0.0666666666666666667 * x241
x243 = x0 * (x138 + x182)
x244 = x128 * x188
x245 = x243 + x244
x246 = x128 * x192
x247 = x194 + x246
x248 = x128 * x196
x249 = x198 + x248
x250 = x101 * x239 * x249
x251 = 3.0 * x0 * (2.0 * x194 + x195 + x246)
x252 = x249 * x49 + x251
x253 = x240 * x252
x254 = x0 * (3.0 * x18 + x19) + x203 * x3
x255 = x0 * (3.0 * x145 + x87) + x201 * x94
x256 = x255 * x38
x257 = x0 * (x122 + 3.0 * x149 + x201) + x209 * x94
x258 = x257 * x79
x259 = x256 * x45
x260 = x0 * (3.0 * x115 + x167 + 2.0 * x207 + 2.0 * x208) + x213 * x94
x261 = x202 * x37 * x57
x262 = x202 * x38 * x64
x263 = x3 * x45
x264 = x224 * (x218 * x94 + x222)
x265 = x3 * x64
x266 = x15 * x82
x267 = x254 * x79
x268 = x101 * x203
x269 = x109 * x202
x270 = x111 * x202
x271 = x111 * x15
x272 = x15 * x37
x273 = x111 * x272
x274 = 0.0666666666666666667 * x8
x275 = x109 * x8
x276 = x274 * x37
x277 = x79 * x8
x278 = x108 * x203
x279 = x155 * x202
x280 = x108 * x15
x281 = x15 * x158
x282 = x0 * (3.0 * x182 + x92) + x128 * x241
x283 = x282 * x38
x284 = x283 * x45
x285 = x0 * (x142 + 3.0 * x187 + x241) + x128 * x245
x286 = x0 * (3.0 * x139 + x197 + 2.0 * x243 + 2.0 * x244) + x128 * x247
x287 = x240 * (x128 * x249 + x251)
# 225 item(s)
result[0] += x42 * (x0 * (3.0 * x27 + 4.0 * x28 + 7.0 * x31) + x35 * x4)
result[1] += x44 * x47
result[2] += x47 * x49
result[3] += x55 * x56 * x63
result[4] += x44 * x49 * x55 * x65
result[5] += x55 * x58 * x70
result[6] += x56 * x72 * x80
result[7] += x62 * x81 * x83
result[8] += x69 * x83 * x84
result[9] += x58 * x80 * x86
result[10] += x56 * x88 * x90
result[11] += x72 * x81 * x91
result[12] += x61 * x70 * x89
result[13] += x84 * x86 * x91
result[14] += x58 * x90 * x93
result[15] += x94 * x95
result[16] += x100 * x34 * x99
result[17] += x103 * x104 * x94
result[18] += x107 * x110 * x56
result[19] += x112 * x81 * x99
result[20] += x113 * x69 * x96
result[21] += x100 * x117 * x118
result[22] += x107 * x120 * x81
result[23] += x119 * x68 * x99
result[24] += x121 * x86 * x96
result[25] += x123 * x124 * x56
result[26] += x117 * x126 * x81
result[27] += x107 * x127 * x69
result[28] += x125 * x86 * x99
result[29] += x124 * x93 * x96
result[30] += x128 * x95
result[31] += x104 * x129 * x44
result[32] += x133 * x134 * x34
result[33] += x113 * x130 * x62
result[34] += x112 * x133 * x84
result[35] += x110 * x137 * x58
result[36] += x121 * x130 * x72
result[37] += x119 * x133 * x61
result[38] += x120 * x137 * x84
result[39] += x118 * x134 * x141
result[40] += x124 * x130 * x88
result[41] += x125 * x133 * x72
result[42] += x127 * x137 * x62
result[43] += x126 * x141 * x84
result[44] += x124 * x143 * x58
result[45] += x144 * x148 * x56
result[46] += x150 * x151 * x26
result[47] += x147 * x152 * x26
result[48] += x154 * x156 * x56
result[49] += x150 * x159 * x81
result[50] += x146 * x160 * x24
result[51] += x151 * x163 * x52
result[52] += x164 * x165 * x81
result[53] += x150 * x160 * x164
result[54] += x147 * x166 * x52
result[55] += x170 * x172 * x56
result[56] += x152 * x163 * x171
result[57] += x154 * x160 * x74
result[58] += x150 * x166 * x171
result[59] += x148 * x74 * x93
result[60] += x128 * x144 * x65 * x94
result[61] += x130 * x173 * x99
result[62] += x133 * x173 * x96
result[63] += x130 * x174 * x24
result[64] += x132 * x175 * x24
result[65] += x176 * x24 * x96
result[66] += x117 * x130 * x178
result[67] += x107 * x179 * x52
result[68] += x137 * x175 * x52
result[69] += x141 * x178 * x96
result[70] += x123 * x130 * x180
result[71] += x117 * x133 * x181
result[72] += x107 * x176 * x74
result[73] += x141 * x181 * x99
result[74] += x143 * x180 * x96
result[75] += x144 * x185 * x58
result[76] += x184 * x186 * x26
result[77] += x188 * x189 * x26
result[78] += x183 * x190 * x24
result[79] += x159 * x188 * x84
result[80] += x156 * x192 * x58
result[81] += x184 * x193 * x52
result[82] += x164 * x188 * x190
result[83] += x155 * x164 * x192 * x84
result[84] += x189 * x196 * x52
result[85] += x172 * x183 * x88
result[86] += x171 * x188 * x193
result[87] += x190 * x192 * x74
result[88] += x171 * x186 * x196
result[89] += x172 * x200 * x58
result[90] += x201 * x206 * x56
result[91] += x100 * x209 * x210
result[92] += x210 * x211 * x81
result[93] += x213 * x215 * x56
result[94] += x209 * x216 * x81
result[95] += x201 * x214 * x69
result[96] += x100 * x218 * x219
result[97] += x213 * x220 * x81
result[98] += x209 * x220 * x68
result[99] += x211 * x219 * x86
result[100] += x221 * x225
result[101] += x103 * x226 * x4
result[102] += x213 * x227 * x69
result[103] += x209 * x228 * x86
result[104] += x201 * x229 * x93
result[105] += x130 * x205 * x230
result[106] += x130 * x150 * x232
result[107] += x133 * x146 * x231
result[108] += x130 * x154 * x233
result[109] += x150 * x179 * x22
result[110] += x146 * x176 * x22
result[111] += x130 * x163 * x220
result[112] += x12 * x154 * x179
result[113] += x137 * x150 * x234
result[114] += x141 * x146 * x220
result[115] += x128 * x170 * x224 * x235
result[116] += x133 * x163 * x236
result[117] += x10 * x154 * x176
result[118] += x141 * x150 * x237
result[119] += x10 * x143 * x230
result[120] += x205 * x238 * x96
result[121] += x183 * x231 * x99
result[122] += x188 * x232 * x96
result[123] += x174 * x183 * x22
result[124] += x175 * x188 * x22
result[125] += x192 * x233 * x96
result[126] += x117 * x183 * x220
result[127] += x107 * x188 * x234
result[128] += x12 * x175 * x192
result[129] += x196 * x220 * x96
result[130] += x10 * x123 * x238
result[131] += x117 * x188 * x237
result[132] += x10 * x174 * x192
result[133] += x196 * x236 * x99
result[134] += x200 * x235 * x240 * x94
result[135] += x206 * x241 * x58
result[136] += x210 * x242 * x84
result[137] += x134 * x210 * x245
result[138] += x214 * x241 * x62
result[139] += x216 * x245 * x84
result[140] += x215 * x247 * x58
result[141] += x219 * x242 * x72
result[142] += x220 * x245 * x61
result[143] += x220 * x247 * x84
result[144] += x134 * x219 * x249
result[145] += x229 * x241 * x88
result[146] += x228 * x245 * x72
result[147] += x227 * x247 * x62
result[148] += x250 * x4 * x44
result[149] += x221 * x253
result[150] += x254 * x256 * x56
result[151] += x203 * x258 * x56
result[152] += x203 * x259 * x81
result[153] += x260 * x261 * x56
result[154] += x257 * x262 * x81
result[155] += x202 * x255 * x70
result[156] += x263 * x264
result[157] += x224 * x260 * x265 * x49
result[158] += x257 * x266 * x69
result[159] += x15 * x259 * x86
result[160] += x224 * (x0 * (7.0 * x168 + 3.0 * x169 + 4.0 * x217) + x223 * x94)
result[161] += x264 * x45 * x49
result[162] += x260 * x70 * x8
result[163] += x258 * x8 * x86
result[164] += x256 * x8 * x93
result[165] += x130 * x201 * x267
result[166] += x130 * x209 * x268
result[167] += x133 * x203 * x211
result[168] += x130 * x213 * x269
result[169] += x133 * x209 * x270
result[170] += x137 * x201 * x269
result[171] += x129 * x226 * x3
result[172] += x133 * x213 * x271
result[173] += x137 * x209 * x273
result[174] += x141 * x211 * x272
result[175] += x128 * x225 * x45
result[176] += x133 * x218 * x274
result[177] += x137 * x213 * x275
result[178] += x141 * x209 * x276
result[179] += x143 * x201 * x277
result[180] += x148 * x183 * x254
result[181] += x150 * x184 * x278
result[182] += x147 * x188 * x278
result[183] += x154 * x183 * x279
result[184] += x150 * x157 * x188 * x279
result[185] += x146 * x192 * x279
result[186] += x163 * x184 * x280
result[187] += x154 * x188 * x281
result[188] += x150 * x192 * x281
result[189] += x147 * x196 * x280
result[190] += x170 * x185 * x8
result[191] += x163 * x188 * x275
result[192] += x165 * x192 * x8
result[193] += x150 * x196 * x275
result[194] += x148 * x200 * x8
result[195] += x241 * x267 * x96
result[196] += x203 * x242 * x99
result[197] += x245 * x268 * x96
result[198] += x107 * x241 * x269
result[199] += x245 * x270 * x99
result[200] += x247 * x269 * x96
result[201] += x117 * x242 * x272
result[202] += x107 * x245 * x273
result[203] += x247 * x271 * x99
result[204] += x250 * x3 * x94
result[205] += x123 * x241 * x277
result[206] += x117 * x245 * x276
result[207] += x107 * x247 * x275
result[208] += x249 * x274 * x99
result[209] += x253 * x45 * x94
result[210] += x254 * x283 * x58
result[211] += x203 * x284 * x84
result[212] += x203 * x285 * x58 * x79
result[213] += x202 * x282 * x63
result[214] += x262 * x285 * x84
result[215] += x261 * x286 * x58
result[216] += x15 * x284 * x72
result[217] += x266 * x285 * x62
result[218] += x240 * x265 * x286 * x44
result[219] += x263 * x287
result[220] += x283 * x8 * x88
result[221] += x277 * x285 * x72
result[222] += x286 * x63 * x8
result[223] += x287 * x44 * x45
result[224] += x240 * (x0 * (7.0 * x198 + 3.0 * x199 + 4.0 * x248) + x128 * x252)
int_tuple_type = numba.types.UniTuple(i8, 2)
func_dict_type = numba.types.DictType(int_tuple_type, func_type)
# Sadly, this function can't be cached.
[docs]
@numba.jit(func_dict_type(), nopython=True, cache=True)
def get_func_dict():
# Can we somehow utilize the 'func_dict_type' definition above?!
#
# This definition below does not work but leads to strange errors.
# func_dict = numba.typed.Dict.empty(
# key_type=func_dict_type.key_type,
# value_type=func_dict_type.value_type,
# )
# numba plzzz
func_dict = numba.typed.Dict.empty(
key_type=int_tuple_type,
value_type=func_type,
)
func_dict[(0, 0)] = ovlp3d_00
func_dict[(1, 0)] = ovlp3d_10
func_dict[(0, 1)] = ovlp3d_01
func_dict[(2, 0)] = ovlp3d_20
func_dict[(0, 2)] = ovlp3d_02
func_dict[(3, 0)] = ovlp3d_30
func_dict[(0, 3)] = ovlp3d_03
func_dict[(4, 0)] = ovlp3d_40
func_dict[(0, 4)] = ovlp3d_04
func_dict[(1, 1)] = ovlp3d_11
func_dict[(2, 1)] = ovlp3d_21
func_dict[(1, 2)] = ovlp3d_12
func_dict[(3, 1)] = ovlp3d_31
func_dict[(1, 3)] = ovlp3d_13
func_dict[(4, 1)] = ovlp3d_41
func_dict[(1, 4)] = ovlp3d_14
func_dict[(2, 2)] = ovlp3d_22
func_dict[(3, 2)] = ovlp3d_32
func_dict[(2, 3)] = ovlp3d_23
func_dict[(4, 2)] = ovlp3d_42
func_dict[(2, 4)] = ovlp3d_24
func_dict[(3, 3)] = ovlp3d_33
func_dict[(4, 3)] = ovlp3d_43
func_dict[(3, 4)] = ovlp3d_34
func_dict[(4, 4)] = ovlp3d_44
return func_dict