"""
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 kinetic3d_00(ax, da, A, bx, db, B, R, result):
"""Cartesian 3D (ss) kinetic energy integral.
Generated code; DO NOT modify by hand!"""
x0 = (ax + bx) ** (-1.0)
x1 = ax * x0
x2 = bx * x1
# 1 item(s)
result[0] += (
-5.56832799683170785
* da
* db
* numpy.sqrt(x0)
* x1
* (
ax * (x0 + 2.0 * (-x0 * (ax * A[0] + bx * B[0]) + A[0]) ** 2)
+ ax * (x0 + 2.0 * (-x0 * (ax * A[1] + bx * B[1]) + A[1]) ** 2)
+ ax * (x0 + 2.0 * (-x0 * (ax * A[2] + bx * B[2]) + A[2]) ** 2)
- 3.0
)
* numpy.exp(-x2 * ((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 kinetic3d_10(ax, da, A, bx, db, B, R, result):
"""Cartesian 3D (ps) kinetic energy integral.
Generated code; DO NOT modify by hand!"""
x0 = (ax + bx) ** (-1.0)
x1 = -x0 * (ax * A[0] + bx * B[0]) + A[0]
x2 = -x0 * (ax * A[1] + bx * B[1]) + A[1]
x3 = ax * (x0 + 2.0 * x2**2)
x4 = -x0 * (ax * A[2] + bx * B[2]) + A[2]
x5 = bx * x0
x6 = -2.0 * x5
x7 = ax * (x0 + 2.0 * x4**2) + x6 - 3.0
x8 = ax * x5
x9 = (
5.56832799683170785
* ax
* da
* db
* x0**1.5
* numpy.exp(-x8 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2))
)
x10 = ax * (x0 + 2.0 * x1**2)
# 3 item(s)
result[0] += x1 * x9 * (ax * (x0 + 2.0 * x1**2) + x3 + x7)
result[1] += x2 * x9 * (ax * (x0 + 2.0 * x2**2) + x10 + x7)
result[2] += x4 * x9 * (ax * (x0 + 2.0 * x4**2) + x10 + x3 + x6 - 3.0)
[docs]
@numba.jit(
func_type.signature,
nopython=True,
nogil=True,
fastmath=True,
cache=True,
)
def kinetic3d_01(ax, da, A, bx, db, B, R, result):
"""See docstring of kinetic3d_10."""
# Call equivalent function and write to result
tmp = numpy.zeros_like(result)
kinetic3d_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 kinetic3d_20(ax, da, A, bx, db, B, R, result):
"""Cartesian 3D (ds) kinetic energy 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 = x0 + 2.0 * x1**2
x4 = bx * x0
x5 = 2.0 * x4 + 1.0
x6 = ax * x3
x7 = 0.5 * x6 - 0.5
x8 = ax * x0
x9 = -x0 * (ax * A[1] + bx * B[1]) + A[1]
x10 = x0 + 2.0 * x9**2
x11 = ax * x10
x12 = x11 - 1.0
x13 = ax * (x0 + 2.0 * x2)
x14 = 0.5 * x13
x15 = -x0 * (ax * A[2] + bx * B[2]) + A[2]
x16 = x0 + 2.0 * x15**2
x17 = ax * x16
x18 = x17 - 1.0
x19 = ax * x4
x20 = (
5.56832799683170785
* da
* db
* numpy.sqrt(x0)
* numpy.exp(-x19 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2))
)
x21 = 0.577350269189625764 * x0 * x20
x22 = x11 + x17 - 4.0 * x4 + x6 - 3.0
x23 = x1 * x20 * x22 * x8
x24 = x9**2
x25 = 0.5 * x8
x26 = ax * (x0 + 2.0 * x24)
x27 = x15**2
x28 = ax * (x0 + 2.0 * x27)
# 6 item(s)
result[0] += -x21 * (
ax * x2 * (ax * x3 - x5) + x12 * x14 + x14 * x18 - x4 * (x13 - 1.0) + x7 * x8
)
result[1] += -x23 * x9
result[2] += -x15 * x23
result[3] += (
-0.5
* x21
* (
2.0 * ax * x24 * (ax * x10 - x5)
+ 2.0 * x12 * x25
+ x18 * x26
+ 2.0 * x26 * x7
- 2.0 * x4 * (x26 - 1.0)
)
)
result[4] += -x15 * x20 * x22 * x8 * x9
result[5] += (
-0.5
* x21
* (
2.0 * ax * x27 * (ax * x16 - x5)
+ x12 * x28
+ 2.0 * x18 * x25
+ 2.0 * x28 * x7
- 2.0 * x4 * (x28 - 1.0)
)
)
[docs]
@numba.jit(
func_type.signature,
nopython=True,
nogil=True,
fastmath=True,
cache=True,
)
def kinetic3d_02(ax, da, A, bx, db, B, R, result):
"""See docstring of kinetic3d_20."""
# Call equivalent function and write to result
tmp = numpy.zeros_like(result)
kinetic3d_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 kinetic3d_30(ax, da, A, bx, db, B, R, result):
"""Cartesian 3D (fs) kinetic energy 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 = ax * (x0 + 2.0 * x1**2)
x4 = bx * x0
x5 = 2.0 * x4
x6 = x5 + 1.0
x7 = -x3 + x6
x8 = -ax * x7
x9 = 2.0 * x2
x10 = 3.0 * x0
x11 = ax * (x10 + x9)
x12 = x3 - 1.0
x13 = ax * x0
x14 = x12 * x13
x15 = -x0 * (ax * A[1] + bx * B[1]) + A[1]
x16 = ax * (x0 + 2.0 * x15**2)
x17 = x16 - 1.0
x18 = 0.5 * x11
x19 = -x0 * (ax * A[2] + bx * B[2]) + A[2]
x20 = ax * (x0 + 2.0 * x19**2)
x21 = x20 - 1.0
x22 = ax * (x0 + x9)
x23 = x22 - 1.0
x24 = ax * x4
x25 = (
5.56832799683170785
* da
* db
* numpy.sqrt(x0)
* numpy.exp(-x24 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2))
)
x26 = 0.258198889747161126 * x0
x27 = x25 * x26
x28 = x0 * (x14 - x23 * x5 + x8 * x9)
x29 = x19**2
x30 = 2.0 * x29
x31 = ax * (x0 + x30)
x32 = x31 - 1.0
x33 = x0 * x22
x34 = -x16 + x6
x35 = x15 * x25
x36 = 0.288675134594812882
x37 = x35 * x36
x38 = x15**2
x39 = 2.0 * x38
x40 = ax * (x0 + x39)
x41 = x40 - 1.0
x42 = -x20 + x6
x43 = x25 * x36
x44 = x19 * x43
x45 = x13 * x17
x46 = -x34
x47 = ax * x46
x48 = x0 * (x39 * x47 - x41 * x5 + x45)
x49 = x0 * x40
x50 = x1 * x43
x51 = x13 * x21
x52 = -x42
x53 = ax * x52
x54 = x0 * (x30 * x53 - x32 * x5 + x51)
x55 = x0 * x31
x56 = ax * (x10 + x39)
x57 = 0.5 * x56
x58 = ax * (x10 + x30)
x59 = 0.5 * x58
# 10 item(s)
result[0] += (
0.5
* x1
* x27
* (
2.0 * x0 * x8
+ x14
+ 2.0 * x17 * x18
+ 2.0 * x18 * x21
+ 2.0 * x2 * x8
- 2.0 * x23 * x4
- 2.0 * x4 * (x11 - 2.0)
)
)
result[1] += x37 * (x28 + x32 * x33 - x33 * x34)
result[2] += x44 * (x28 + x33 * x41 - x33 * x42)
result[3] += x50 * (x32 * x49 + x48 - x49 * x7)
result[4] += x1 * x13 * x19 * x35 * (-6.0 * bx * x0 + x16 + x20 + x3 - 3.0)
result[5] += x50 * (x41 * x55 + x54 - x55 * x7)
result[6] += (
0.5
* x26
* x35
* (
2.0 * x12 * x57
+ 2.0 * x13 * x46
+ 2.0 * x21 * x57
+ 2.0 * x38 * x47
- 2.0 * x4 * x41
- 2.0 * x4 * (x56 - 2.0)
+ x45
)
)
result[7] += x44 * (x23 * x49 - x42 * x49 + x48)
result[8] += x37 * (x23 * x55 - x34 * x55 + x54)
result[9] += (
0.5
* x19
* x27
* (
2.0 * x12 * x59
+ 2.0 * x13 * x52
+ 2.0 * x17 * x59
+ 2.0 * x29 * x53
- 2.0 * x32 * x4
- 2.0 * x4 * (x58 - 2.0)
+ x51
)
)
[docs]
@numba.jit(
func_type.signature,
nopython=True,
nogil=True,
fastmath=True,
cache=True,
)
def kinetic3d_03(ax, da, A, bx, db, B, R, result):
"""See docstring of kinetic3d_30."""
# Call equivalent function and write to result
tmp = numpy.zeros_like(result)
kinetic3d_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 kinetic3d_40(ax, da, A, bx, db, B, R, result):
"""Cartesian 3D (gs) kinetic energy integral.
Generated code; DO NOT modify by hand!"""
x0 = 2.0 * ax
x1 = (2.0 * bx + x0) ** (-1.0)
x2 = (ax + bx) ** (-1.0)
x3 = x2 * (ax * A[0] + bx * B[0]) - A[0]
x4 = -ax
x5 = x3**2
x6 = 2.0 * ax**2
x7 = -x4 - x6 * (x1 + x5)
x8 = bx * x2
x9 = ax * x8
x10 = numpy.exp(-x9 * (A[0] - B[0]) ** 2)
x11 = 1.77245385090551603 * numpy.sqrt(x2)
x12 = x10 * x11
x13 = x12 * x3
x14 = x13 * x7
x15 = x0 * x8
x16 = x13 * x15 + x14
x17 = x16 * x3
x18 = x12 * x5
x19 = x1 * x12
x20 = x18 + x19
x21 = x8 * (x0 * x20 - x12)
x22 = x19 * x7
x23 = 4.0 * x9
x24 = x17 + x21 + x22
x25 = x3 * (2.0 * x19 + x20)
x26 = x1 * (x13 * x23 + 2.0 * x14) + x24 * x3 + x8 * (x0 * x25 - 2.0 * x13)
x27 = 3.0 * x18 + 3.0 * x19
x28 = x1 * x27 + x25 * x3
x29 = numpy.exp(-x9 * (A[1] - B[1]) ** 2)
x30 = numpy.exp(-x9 * (A[2] - B[2]) ** 2)
x31 = 3.14159265358979324 * x2 * x30
x32 = x29 * x31
x33 = x2 * (ax * A[1] + bx * B[1]) - A[1]
x34 = x33**2
x35 = -x4 - x6 * (x1 + x34)
x36 = x28 * x32
x37 = x2 * (ax * A[2] + bx * B[2]) - A[2]
x38 = x37**2
x39 = -x4 - x6 * (x1 + x38)
x40 = da * db
x41 = 0.0975900072948533179 * x40
x42 = x11 * x29
x43 = x33 * x42
x44 = x35 * x43
x45 = x15 * x43 + x44
x46 = x11 * x30
x47 = x45 * x46
x48 = x26 * x32
x49 = x25 * x32
x50 = 0.258198889747161126 * x40
x51 = x37 * x46
x52 = x39 * x51
x53 = x15 * x51 + x52
x54 = x33 * x45
x55 = x34 * x42
x56 = x1 * x42
x57 = x55 + x56
x58 = x8 * (x0 * x57 - x42)
x59 = x35 * x56
x60 = x54 + x58 + x59
x61 = x20 * x46
x62 = 0.333333333333333333 * x40
x63 = 1.73205080756887729 * x62
x64 = x37 * x53
x65 = x38 * x46
x66 = x1 * x46
x67 = x65 + x66
x68 = x8 * (x0 * x67 - x46)
x69 = x39 * x66
x70 = x64 + x68 + x69
x71 = x20 * x42
x72 = x33 * (2.0 * x56 + x57)
x73 = x1 * (x23 * x43 + 2.0 * x44) + x33 * x60 + x8 * (x0 * x72 - 2.0 * x43)
x74 = x10 * x31
x75 = x73 * x74
x76 = x3 * x74
x77 = 3.14159265358979324 * x10 * x2 * x29
x78 = x3 * x77
x79 = x37 * (2.0 * x66 + x67)
x80 = x1 * (x23 * x51 + 2.0 * x52) + x37 * x70 + x8 * (x0 * x79 - 2.0 * x51)
x81 = x77 * x80
x82 = 3.0 * x55 + 3.0 * x56
x83 = x1 * x82 + x33 * x72
x84 = x74 * x83
x85 = x12 * x57
x86 = 3.0 * x65 + 3.0 * x66
x87 = x1 * x86 + x37 * x79
x88 = x77 * x87
# 15 item(s)
result[0] += x41 * (
x32 * (3.0 * x1 * (x17 + x21 + x22) + x26 * x3 + x8 * (2.0 * ax * x28 - x27))
+ x35 * x36
+ x36 * x39
)
result[1] += x50 * (x25 * x47 + x33 * x39 * x49 + x33 * x48)
result[2] += x50 * (x25 * x42 * x53 + x35 * x37 * x49 + x37 * x48)
result[3] += x62 * (x24 * x46 * x57 + x39 * x57 * x61 + x60 * x61)
result[4] += x63 * (x20 * x37 * x47 + x20 * x43 * x53 + x24 * x32 * x33 * x37)
result[5] += x62 * (x24 * x42 * x67 + x35 * x67 * x71 + x70 * x71)
result[6] += x50 * (x16 * x46 * x72 + x3 * x75 + x39 * x72 * x76)
result[7] += x63 * (x13 * x53 * x57 + x16 * x51 * x57 + x37 * x60 * x76)
result[8] += x63 * (x13 * x45 * x67 + x16 * x43 * x67 + x33 * x70 * x78)
result[9] += x50 * (x16 * x42 * x79 + x3 * x81 + x35 * x78 * x79)
result[10] += x41 * (
x39 * x84
+ x7 * x84
+ x74 * (3.0 * x1 * (x54 + x58 + x59) + x33 * x73 + x8 * (2.0 * ax * x83 - x82))
)
result[11] += x50 * (x12 * x53 * x72 + x37 * x7 * x72 * x74 + x37 * x75)
result[12] += x62 * (x12 * x60 * x67 + x67 * x7 * x85 + x70 * x85)
result[13] += x50 * (x12 * x45 * x79 + x33 * x7 * x77 * x79 + x33 * x81)
result[14] += x41 * (
x35 * x88
+ x7 * x88
+ x77 * (3.0 * x1 * (x64 + x68 + x69) + x37 * x80 + x8 * (2.0 * ax * x87 - x86))
)
[docs]
@numba.jit(
func_type.signature,
nopython=True,
nogil=True,
fastmath=True,
cache=True,
)
def kinetic3d_04(ax, da, A, bx, db, B, R, result):
"""See docstring of kinetic3d_40."""
# Call equivalent function and write to result
tmp = numpy.zeros_like(result)
kinetic3d_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 kinetic3d_11(ax, da, A, bx, db, B, R, result):
"""Cartesian 3D (pp) kinetic energy integral.
Generated code; DO NOT modify by hand!"""
x0 = (ax + bx) ** (-1.0)
x1 = -x0 * (ax * A[0] + bx * B[0])
x2 = x1 + A[0]
x3 = x0 + 2.0 * x2**2
x4 = ax * x3
x5 = x4 - 1.0
x6 = 0.5 * x0
x7 = -x0 * (ax * A[1] + bx * B[1])
x8 = x7 + A[1]
x9 = x0 + 2.0 * x8**2
x10 = ax * x9
x11 = x10 - 1.0
x12 = x1 + B[0]
x13 = x12 * x2
x14 = x0 + 2.0 * x13
x15 = 0.5 * x14
x16 = -x0 * (ax * A[2] + bx * B[2])
x17 = x16 + A[2]
x18 = x0 + 2.0 * x17**2
x19 = ax * x18
x20 = x19 - 1.0
x21 = bx * x0
x22 = 2.0 * x21 + 1.0
x23 = ax * x21
x24 = (
5.56832799683170785
* ax
* da
* db
* x0**1.5
* numpy.exp(-x23 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2))
)
x25 = x7 + B[1]
x26 = x24 * (x10 + x19 - 4.0 * x21 + x4 - 3.0)
x27 = x2 * x26
x28 = x16 + B[2]
x29 = x26 * x8
x30 = x25 * x8
x31 = x0 + 2.0 * x30
x32 = 0.5 * x31
x33 = x17 * x26
x34 = x17 * x28
x35 = x0 + 2.0 * x34
x36 = 0.5 * x35
# 9 item(s)
result[0] += -x24 * (
x11 * x15 + x13 * (ax * x3 - x22) - x14 * x21 + x15 * x20 + x5 * x6
)
result[1] += -x25 * x27
result[2] += -x27 * x28
result[3] += -x12 * x29
result[4] += -x24 * (
x11 * x6 + x20 * x32 - x21 * x31 + x30 * (ax * x9 - x22) + x32 * x5
)
result[5] += -x28 * x29
result[6] += -x12 * x33
result[7] += -x25 * x33
result[8] += -x24 * (
x11 * x36 + x20 * x6 - x21 * x35 + x34 * (ax * x18 - x22) + x36 * x5
)
[docs]
@numba.jit(
func_type.signature,
nopython=True,
nogil=True,
fastmath=True,
cache=True,
)
def kinetic3d_21(ax, da, A, bx, db, B, R, result):
"""Cartesian 3D (dp) kinetic energy integral.
Generated code; DO NOT modify by hand!"""
x0 = -B[0]
x1 = (ax + bx) ** (-1.0)
x2 = x1 * (ax * A[0] + bx * B[0])
x3 = -x2
x4 = x3 + A[0]
x5 = x3 + B[0]
x6 = 2.0 * x4
x7 = x5 * x6
x8 = x1 + x7
x9 = ax * (x1 * (-2.0 * x2 + A[0] + B[0]) + x4 * x8)
x10 = bx * x1
x11 = ax * (x1 + 2.0 * x4**2)
x12 = x11 - 1.0
x13 = 2.0 * x10
x14 = 0.5 * ax
x15 = x1 * x14
x16 = x1 * (ax * A[1] + bx * B[1])
x17 = -x16
x18 = x17 + A[1]
x19 = ax * (x1 + 2.0 * x18**2)
x20 = x19 - 1.0
x21 = 0.5 * x9
x22 = x1 * (ax * A[2] + bx * B[2])
x23 = -x22
x24 = x23 + A[2]
x25 = ax * (x1 + 2.0 * x24**2)
x26 = x25 - 1.0
x27 = x1 * x12
x28 = x13 + 1.0
x29 = -x11 + x28
x30 = -x29
x31 = -2.0 * bx * x1 * x8 + x27 + x30 * x7
x32 = x14 * x4
x33 = ax * x10
x34 = -B[1]
x35 = -B[2]
x36 = (
5.56832799683170785
* da
* db
* numpy.sqrt(x1)
* numpy.exp(-x33 * ((x0 + A[0]) ** 2 + (x34 + A[1]) ** 2 + (x35 + A[2]) ** 2))
)
x37 = 1.73205080756887729 * x36
x38 = 0.333333333333333333 * x1 * x37
x39 = 2.0 * x4**2
x40 = ax * (x1 + x39)
x41 = x40 - 1.0
x42 = x1 * (ax * x27 + ax * x30 * x39 - x13 * x41)
x43 = 2.0 * x24**2
x44 = ax * (x1 + x43)
x45 = x44 - 1.0
x46 = x1 * x40
x47 = -x19 + x28
x48 = x17 + B[1]
x49 = 0.166666666666666667 * x37
x50 = x48 * x49
x51 = 2.0 * x18**2
x52 = ax * (x1 + x51)
x53 = x52 - 1.0
x54 = -x25 + x28
x55 = x23 + B[2]
x56 = x49 * x55
x57 = x1 * x31
x58 = x1 * x8
x59 = x14 * x18
x60 = x36 * x59
x61 = x1 * x20
x62 = 2.0 * x18 * x48
x63 = x1 + x62
x64 = -x47
x65 = -x13 * x63 + x61 + x62 * x64
x66 = x1 * x65
x67 = x1 * x63
x68 = x32 * x36
x69 = 6.0 * bx * x1 - x11 - x19 - x25 + 3.0
x70 = ax * x1 * x36 * x4 * x69
x71 = x14 * x24
x72 = x36 * x71
x73 = x1 * x26
x74 = 2.0 * x24 * x55
x75 = x1 + x74
x76 = -x54
x77 = -x13 * x75 + x73 + x74 * x76
x78 = x1 * x77
x79 = x1 * x75
x80 = x1 * (ax * x51 * x64 + ax * x61 - x13 * x53)
x81 = x1 * x52
x82 = x49 * x5
x83 = ax * (x1 * (-2.0 * x16 + A[1] + B[1]) + x18 * x63)
x84 = 0.5 * x83
x85 = x1 * (ax * x43 * x76 + ax * x73 - x13 * x45)
x86 = x1 * x44
x87 = ax * (x1 * (-2.0 * x22 + A[2] + B[2]) + x24 * x75)
x88 = 0.5 * x87
# 18 item(s)
result[0] += x38 * (
-x10 * (x0 + x2 + x9)
- x15 * (x10 * x6 - x12 * x4 - x12 * x5 + x13 * x5)
+ x20 * x21
+ x21 * x26
+ x31 * x32
)
result[1] += x50 * (x42 + x45 * x46 - x46 * x47)
result[2] += x56 * (x42 + x46 * x53 - x46 * x54)
result[3] += x60 * (x45 * x58 - x47 * x58 + x57)
result[4] += x68 * (-x29 * x67 + x45 * x67 + x66)
result[5] += -x18 * x55 * x70
result[6] += x72 * (x53 * x58 - x54 * x58 + x57)
result[7] += -x24 * x48 * x70
result[8] += x68 * (-x29 * x79 + x53 * x79 + x78)
result[9] += x82 * (-x29 * x81 + x45 * x81 + x80)
result[10] += x38 * (
-x10 * (x16 + x34 + x83)
+ x12 * x84
- x15 * (x13 * x18 + x13 * x48 - x18 * x20 - x20 * x48)
+ x26 * x84
+ x59 * x65
)
result[11] += x56 * (x41 * x81 - x54 * x81 + x80)
result[12] += -ax * x1 * x18 * x24 * x36 * x5 * x69
result[13] += x72 * (x41 * x67 - x54 * x67 + x66)
result[14] += x60 * (x41 * x79 - x47 * x79 + x78)
result[15] += x82 * (-x29 * x86 + x53 * x86 + x85)
result[16] += x50 * (x41 * x86 - x47 * x86 + x85)
result[17] += x38 * (
-x10 * (x22 + x35 + x87)
+ x12 * x88
- x15 * (x13 * x24 + x13 * x55 - x24 * x26 - x26 * x55)
+ x20 * x88
+ x71 * x77
)
[docs]
@numba.jit(
func_type.signature,
nopython=True,
nogil=True,
fastmath=True,
cache=True,
)
def kinetic3d_12(ax, da, A, bx, db, B, R, result):
"""See docstring of kinetic3d_21."""
# Call equivalent function and write to result
tmp = numpy.zeros_like(result)
kinetic3d_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 kinetic3d_31(ax, da, A, bx, db, B, R, result):
"""Cartesian 3D (fp) kinetic energy 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
x5 = 2.0 * x4**2
x6 = x0 + x5
x7 = ax * x6 - 1.0
x8 = x0 * x7
x9 = ax * x8
x10 = x2 + B[0]
x11 = 2.0 * x3
x12 = x10 * x11
x13 = x0 + x12
x14 = 2.0 * x0
x15 = bx * x14
x16 = x15 + 1.0
x17 = -ax * x6 + x16
x18 = -x17
x19 = ax * x3
x20 = 4.0 * x10
x21 = 2.0 * x3**2
x22 = ax * (x0 + x21)
x23 = x22 - 1.0
x24 = ax * x18 * x21 - x15 * x23
x25 = x10 * x15 - x10 * x7 + x15 * x3 - x3 * x7
x26 = ax * x0
x27 = -2.0 * bx * x0 * x13 + x12 * x18 + x8
x28 = -x27
x29 = -B[0]
x30 = -2.0 * x1 + A[0] + B[0]
x31 = x0 * x30 + x13 * x3
x32 = ax * x31
x33 = -x15 * (x1 + x29 + x32)
x34 = x0 * (ax * A[1] + bx * B[1])
x35 = -x34
x36 = x35 + A[1]
x37 = -x36
x38 = 2.0 * x37**2
x39 = ax * (x0 + x38)
x40 = x39 - 1.0
x41 = 3.0 * x0
x42 = x21 + x41
x43 = ax * (x0 * (x20 * x3 + x42) + x11 * x31)
x44 = x0 * (ax * A[2] + bx * B[2])
x45 = -x44
x46 = x45 + A[2]
x47 = -x46
x48 = 2.0 * x47**2
x49 = ax * (x0 + x48)
x50 = x49 - 1.0
x51 = -x10 * x4
x52 = 4.0 * x51
x53 = numpy.sqrt(x0)
x54 = bx * x26
x55 = -B[1]
x56 = -B[2]
x57 = (
5.56832799683170785
* da
* db
* numpy.exp(-x54 * ((x29 + A[0]) ** 2 + (x55 + A[1]) ** 2 + (x56 + A[2]) ** 2))
)
x58 = x53 * x57
x59 = 3.87298334620741689 * x58
x60 = 0.0166666666666666667 * x0 * x59
x61 = x35 + B[1]
x62 = ax * x14
x63 = ax * x42
x64 = x24 + x9
x65 = -x0 * (x15 * (x63 - 2.0) + x17 * x62 - x64)
x66 = 2.0 * x46**2
x67 = ax * (x0 + x66)
x68 = x67 - 1.0
x69 = x0 * x63
x70 = x16 - x39
x71 = 0.0333333333333333333 * x59
x72 = x3 * x71
x73 = x45 + B[2]
x74 = 2.0 * x36**2
x75 = ax * (x0 + x74)
x76 = x75 - 1.0
x77 = x16 - x49
x78 = x0 * (x19 * x27 - x25 * x26 + x33)
x79 = x0 * x32
x80 = 1.73205080756887729 * x57
x81 = 0.166666666666666667 * x53 * x80
x82 = x36 * x81
x83 = 2.0 * x36
x84 = x61 * x83
x85 = x0 + x84
x86 = x0 * x40
x87 = -x70
x88 = -x15 * x85 + x84 * x87 + x86
x89 = 0.0833333333333333333 * x0**1.5 * x80
x90 = x0 * x22
x91 = -x77
x92 = x0 * x64 + x87 * x90 + x90 * x91
x93 = x46 * x81
x94 = 2.0 * x46
x95 = x73 * x94
x96 = x0 + x95
x97 = x0 * x50
x98 = -x15 * x96 + x91 * x95 + x97
x99 = ax * x74 * x87 - x15 * x76
x100 = ax * x86 + x99
x101 = ax * x36
x102 = x15 * x36 + x15 * x61 - x36 * x40 - x40 * x61
x103 = -2.0 * x34 + A[1] + B[1]
x104 = x0 * x103 + x36 * x85
x105 = ax * x104
x106 = -x15 * (x105 + x34 + x55)
x107 = x0 * (x101 * x88 - x102 * x26 + x106)
x108 = x0 * x105
x109 = x3 * x81
x110 = x0 * x75
x111 = x0 * x100 + x110 * x18 + x110 * x91
x112 = x0 * x13
x113 = 0.5 * x58
x114 = x113 * x46
x115 = -x88
x116 = x0 * x85
x117 = -x98
x118 = x0 * x96
x119 = ax * x66 * x91 - x15 * x68
x120 = ax * x97 + x119
x121 = x0 * x67
x122 = x0 * x120 + x121 * x18 + x121 * x87
x123 = ax * x46
x124 = x15 * x46 + x15 * x73 - x46 * x50 - x50 * x73
x125 = -2.0 * x44 + A[2] + B[2]
x126 = x0 * x125 + x46 * x96
x127 = ax * x126
x128 = -x15 * (x127 + x44 + x56)
x129 = x0 * (x123 * x98 - x124 * x26 + x128)
x130 = x0 * x127
x131 = x41 + x74
x132 = ax * x131
x133 = -x0 * (-x100 + x15 * (x132 - 2.0) + x62 * x70)
x134 = x0 * x132
x135 = x36 * x71
x136 = ax * x41
x137 = 4.0 * x61
x138 = ax * (x0 * (x131 + x137 * x36) + x104 * x83)
x139 = -x37 * x61
x140 = 4.0 * x139
x141 = x41 + x66
x142 = ax * x141
x143 = -x0 * (-x120 + x15 * (x142 - 2.0) + x62 * x77)
x144 = x0 * x142
x145 = x46 * x71
x146 = 4.0 * x73
x147 = ax * (x0 * (x141 + x146 * x46) + x126 * x94)
x148 = -x47 * x73
x149 = 4.0 * x148
# 30 item(s)
result[0] += -x60 * (
x0 * (-4.0 * ax * bx * x0 * x13 + x18 * x19 * x20 + x24 + 3.0 * x9)
- x11 * (x19 * x28 + x25 * x26 - x33)
+ x15
* (
-ax * (x0 * (x41 + x5 + x52) - 2.0 * x4 * (x0 * x30 - x4 * (x0 + 2.0 * x51)))
+ x14
+ x52
)
+ x40 * x43
+ x43 * x50
)
result[1] += x61 * x72 * (ax * x0 * x42 * x70 - x65 - x68 * x69)
result[2] += x72 * x73 * (ax * x0 * x42 * x77 - x65 - x69 * x76)
result[3] += x82 * (ax * x0 * x31 * x70 - x68 * x79 - x78)
result[4] += -x89 * (x22 * x68 * x85 + x22 * x88 + x64 * x85)
result[5] += -x73 * x82 * x92
result[6] += x93 * (ax * x0 * x31 * x77 - x76 * x79 - x78)
result[7] += -x61 * x92 * x93
result[8] += -x89 * (x22 * x76 * x96 + x22 * x98 + x64 * x96)
result[9] += -x89 * (x100 * x13 + x13 * x68 * x75 + x27 * x75)
result[10] += x109 * (ax * x0 * x104 * x17 - x107 - x108 * x68)
result[11] += -x109 * x111 * x73
result[12] += x101 * x114 * (x0 * x28 - x112 * x87 - x112 * x91)
result[13] += x114 * x19 * (x0 * x115 - x116 * x18 - x116 * x91)
result[14] += x113 * x19 * x36 * (x0 * x117 - x118 * x18 - x118 * x87)
result[15] += -x89 * (x120 * x13 + x13 * x67 * x76 + x27 * x67)
result[16] += -x109 * x122 * x61
result[17] += x109 * (ax * x0 * x126 * x17 - x129 - x130 * x76)
result[18] += x10 * x135 * (ax * x0 * x131 * x17 - x133 - x134 * x68)
result[19] += -x60 * (
x0 * (-4.0 * ax * bx * x0 * x85 + x101 * x137 * x87 + x136 * x40 + x99)
+ x138 * x50
+ x138 * x7
+ x15
* (
-ax
* (
x0 * (x140 + x38 + x41)
- 2.0 * x37 * (x0 * x103 - x37 * (x0 + 2.0 * x139))
)
+ x14
+ x140
)
- x83 * (x101 * x115 + x102 * x26 - x106)
)
result[20] += x135 * x73 * (ax * x0 * x131 * x77 - x133 - x134 * x23)
result[21] += -x10 * x111 * x93
result[22] += x93 * (ax * x0 * x104 * x77 - x107 - x108 * x23)
result[23] += -x89 * (x100 * x96 + x23 * x75 * x96 + x75 * x98)
result[24] += -x10 * x122 * x82
result[25] += -x89 * (x120 * x85 + x23 * x67 * x85 + x67 * x88)
result[26] += x82 * (ax * x0 * x126 * x70 - x129 - x130 * x23)
result[27] += x10 * x145 * (ax * x0 * x141 * x17 - x143 - x144 * x76)
result[28] += x145 * x61 * (ax * x0 * x141 * x70 - x143 - x144 * x23)
result[29] += -x60 * (
x0 * (-4.0 * ax * bx * x0 * x96 + x119 + x123 * x146 * x91 + x136 * x50)
+ x147 * x40
+ x147 * x7
+ x15
* (
-ax
* (
x0 * (x149 + x41 + x48)
- 2.0 * x47 * (x0 * x125 - x47 * (x0 + 2.0 * x148))
)
+ x14
+ x149
)
- x94 * (x117 * x123 + x124 * x26 - x128)
)
[docs]
@numba.jit(
func_type.signature,
nopython=True,
nogil=True,
fastmath=True,
cache=True,
)
def kinetic3d_13(ax, da, A, bx, db, B, R, result):
"""See docstring of kinetic3d_31."""
# Call equivalent function and write to result
tmp = numpy.zeros_like(result)
kinetic3d_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 kinetic3d_41(ax, da, A, bx, db, B, R, result):
"""Cartesian 3D (gp) kinetic energy integral.
Generated code; DO NOT modify by hand!"""
x0 = 2.0 * ax
x1 = (2.0 * bx + x0) ** (-1.0)
x2 = -ax
x3 = (ax + bx) ** (-1.0)
x4 = -x3 * (ax * A[0] + bx * B[0])
x5 = -x4 - A[0]
x6 = x5**2
x7 = 2.0 * ax**2
x8 = -x2 - x7 * (x1 + x6)
x9 = bx * x3
x10 = ax * x9
x11 = numpy.exp(-x10 * (A[0] - B[0]) ** 2)
x12 = 1.77245385090551603 * numpy.sqrt(x3)
x13 = x11 * x12
x14 = x13 * x5
x15 = x14 * x8
x16 = x0 * x9
x17 = x14 * x16 + x15
x18 = -x4 - B[0]
x19 = x13 * x18
x20 = x19 * (x16 + x8)
x21 = x1 * (x17 + x20)
x22 = x20 * x5
x23 = x1 * x13
x24 = x14 * x18
x25 = x23 + x24
x26 = x23 * x8
x27 = x16 * x25 + x22 + x26
x28 = x27 * x5
x29 = x1 * (x14 + x19)
x30 = x25 * x5
x31 = x29 + x30
x32 = x9 * (x0 * x31 - x19)
x33 = 4.0 * x10
x34 = x17 * x5
x35 = x13 * x6
x36 = x23 + x35
x37 = x9 * (x0 * x36 - x13)
x38 = x34 + x37
x39 = x26 + x38
x40 = 2.0 * x23
x41 = x5 * (x36 + x40)
x42 = x1 * (x14 * x33 + 2.0 * x15) + x39 * x5 + x9 * (x0 * x41 - 2.0 * x14)
x43 = 3.0 * x26
x44 = x21 + x28 + x32
x45 = 3.0 * x23
x46 = 2.0 * x24
x47 = x1 * (x35 + x45 + x46) + x31 * x5
x48 = (
x1 * (2.0 * x22 + x25 * x33 + x38 + x43)
+ x44 * x5
- x9 * (-2.0 * ax * x47 + x40 + x46)
)
x49 = 3.0 * x29 + 3.0 * x30
x50 = x1 * (x41 + x49) + x47 * x5
x51 = numpy.exp(-x10 * (A[1] - B[1]) ** 2)
x52 = numpy.exp(-x10 * (A[2] - B[2]) ** 2)
x53 = 3.14159265358979324 * x3 * x52
x54 = x51 * x53
x55 = -x3 * (ax * A[1] + bx * B[1])
x56 = -x55 - A[1]
x57 = x56**2
x58 = -x2 - x7 * (x1 + x57)
x59 = x50 * x54
x60 = -x3 * (ax * A[2] + bx * B[2])
x61 = -x60 - A[2]
x62 = x61**2
x63 = -x2 - x7 * (x1 + x62)
x64 = da * db
x65 = 0.0975900072948533179 * x64
x66 = -x55 - B[1]
x67 = x12 * x51
x68 = x66 * x67
x69 = x68 * (x16 + x58)
x70 = 3.0 * x35 + x45
x71 = x1 * x70 + x41 * x5
x72 = x12 * x52
x73 = x54 * (
x1 * (3.0 * x34 + 3.0 * x37 + x43) + x42 * x5 + x9 * (2.0 * ax * x71 - x70)
)
x74 = x54 * x71
x75 = -x60 - B[2]
x76 = x72 * x75
x77 = x76 * (x16 + x63)
x78 = x56 * x67
x79 = x58 * x78
x80 = x16 * x78 + x79
x81 = x48 * x54
x82 = x54 * x56
x83 = 0.258198889747161126 * x64
x84 = x56 * x69
x85 = x1 * x67
x86 = x66 * x78
x87 = x85 + x86
x88 = x58 * x85
x89 = x16 * x87 + x84 + x88
x90 = x41 * x72
x91 = x61 * x72
x92 = x63 * x91
x93 = x16 * x91 + x92
x94 = x54 * x61
x95 = x61 * x77
x96 = x1 * x72
x97 = x75 * x91
x98 = x96 + x97
x99 = x63 * x96
x100 = x16 * x98 + x95 + x99
x101 = x41 * x67
x102 = x56 * x80
x103 = x57 * x67
x104 = x103 + x85
x105 = x9 * (x0 * x104 - x67)
x106 = x102 + x105
x107 = x106 + x88
x108 = x31 * x72
x109 = 0.333333333333333333 * x64
x110 = x1 * (x68 + x78)
x111 = x56 * x87
x112 = x110 + x111
x113 = x112 * x72
x114 = x1 * (x69 + x80)
x115 = x56 * x89
x116 = x9 * (x0 * x112 - x68)
x117 = x114 + x115 + x116
x118 = 1.73205080756887729 * x109
x119 = x61 * x93
x120 = x62 * x72
x121 = x120 + x96
x122 = x9 * (x0 * x121 - x72)
x123 = x119 + x122
x124 = x123 + x99
x125 = x31 * x67
x126 = x1 * (x76 + x91)
x127 = x61 * x98
x128 = x126 + x127
x129 = x128 * x67
x130 = x1 * (x77 + x93)
x131 = x100 * x61
x132 = x9 * (x0 * x128 - x76)
x133 = x130 + x131 + x132
x134 = 2.0 * x85
x135 = x56 * (x104 + x134)
x136 = x135 * x72
x137 = x1 * (x33 * x78 + 2.0 * x79) + x107 * x56 + x9 * (x0 * x135 - 2.0 * x78)
x138 = 3.0 * x85
x139 = 2.0 * x86
x140 = x1 * (x103 + x138 + x139) + x112 * x56
x141 = 3.0 * x88
x142 = (
x1 * (x106 + x141 + x33 * x87 + 2.0 * x84)
+ x117 * x56
- x9 * (-2.0 * ax * x140 + x134 + x139)
)
x143 = x11 * x53
x144 = x142 * x143
x145 = x143 * x5
x146 = 3.14159265358979324 * x11 * x3 * x51
x147 = x146 * x5
x148 = 2.0 * x96
x149 = x61 * (x121 + x148)
x150 = x149 * x67
x151 = x1 * (x33 * x91 + 2.0 * x92) + x124 * x61 + x9 * (x0 * x149 - 2.0 * x91)
x152 = 3.0 * x96
x153 = 2.0 * x97
x154 = x1 * (x120 + x152 + x153) + x128 * x61
x155 = 3.0 * x99
x156 = (
x1 * (x123 + x155 + x33 * x98 + 2.0 * x95)
+ x133 * x61
- x9 * (-2.0 * ax * x154 + x148 + x153)
)
x157 = x146 * x156
x158 = 3.0 * x103 + x138
x159 = x1 * x158 + x135 * x56
x160 = x143 * (
x1 * (3.0 * x102 + 3.0 * x105 + x141) + x137 * x56 + x9 * (2.0 * ax * x159 - x158)
)
x161 = x143 * x159
x162 = 3.0 * x110 + 3.0 * x111
x163 = x1 * (x135 + x162) + x140 * x56
x164 = x143 * x163
x165 = x143 * x61
x166 = x13 * x135
x167 = x112 * x13
x168 = x128 * x13
x169 = x146 * x56
x170 = x13 * x149
x171 = 3.0 * x120 + x152
x172 = x1 * x171 + x149 * x61
x173 = x146 * (
x1 * (3.0 * x119 + 3.0 * x122 + x155) + x151 * x61 + x9 * (2.0 * ax * x172 - x171)
)
x174 = x146 * x172
x175 = 3.0 * x126 + 3.0 * x127
x176 = x1 * (x149 + x175) + x154 * x61
x177 = x146 * x176
# 45 item(s)
result[0] += x65 * (
x54
* (
x1 * (3.0 * x21 + 3.0 * x28 + 3.0 * x32 + x42)
+ x48 * x5
+ x9 * (2.0 * ax * x50 - x49)
)
+ x58 * x59
+ x59 * x63
)
result[1] += x65 * (x63 * x66 * x74 + x66 * x73 + x69 * x71 * x72)
result[2] += x65 * (x58 * x74 * x75 + x67 * x71 * x77 + x73 * x75)
result[3] += x83 * (x47 * x63 * x82 + x47 * x72 * x80 + x56 * x81)
result[4] += x83 * (x42 * x72 * x87 + x63 * x87 * x90 + x89 * x90)
result[5] += x83 * (x41 * x76 * x80 + x41 * x77 * x78 + x42 * x75 * x82)
result[6] += x83 * (x47 * x58 * x94 + x47 * x67 * x93 + x61 * x81)
result[7] += x83 * (x41 * x68 * x93 + x41 * x69 * x91 + x42 * x66 * x94)
result[8] += x83 * (x100 * x101 + x101 * x58 * x98 + x42 * x67 * x98)
result[9] += x109 * (x104 * x108 * x63 + x104 * x44 * x72 + x107 * x108)
result[10] += x109 * (x113 * x36 * x63 + x113 * x39 + x117 * x36 * x72)
result[11] += x109 * (x104 * x36 * x77 + x104 * x39 * x76 + x107 * x36 * x76)
result[12] += x118 * (x31 * x78 * x93 + x31 * x80 * x91 + x44 * x61 * x82)
result[13] += x118 * (x36 * x87 * x93 + x36 * x89 * x91 + x39 * x87 * x91)
result[14] += x118 * (x100 * x36 * x78 + x36 * x80 * x98 + x39 * x78 * x98)
result[15] += x109 * (x121 * x125 * x58 + x121 * x44 * x67 + x124 * x125)
result[16] += x109 * (x121 * x36 * x69 + x121 * x39 * x68 + x124 * x36 * x68)
result[17] += x109 * (x129 * x36 * x58 + x129 * x39 + x133 * x36 * x67)
result[18] += x83 * (x136 * x25 * x63 + x136 * x27 + x137 * x25 * x72)
result[19] += x83 * (x140 * x145 * x63 + x140 * x17 * x72 + x144 * x5)
result[20] += x83 * (x135 * x14 * x77 + x135 * x17 * x76 + x137 * x145 * x75)
result[21] += x118 * (x104 * x25 * x93 + x104 * x27 * x91 + x107 * x25 * x91)
result[22] += x118 * (x112 * x14 * x93 + x112 * x17 * x91 + x117 * x145 * x61)
result[23] += x118 * (x100 * x104 * x14 + x104 * x17 * x98 + x107 * x14 * x98)
result[24] += x118 * (x121 * x25 * x80 + x121 * x27 * x78 + x124 * x25 * x78)
result[25] += x118 * (x121 * x14 * x89 + x121 * x17 * x87 + x124 * x14 * x87)
result[26] += x118 * (x128 * x14 * x80 + x128 * x17 * x78 + x133 * x147 * x56)
result[27] += x83 * (x150 * x25 * x58 + x150 * x27 + x151 * x25 * x67)
result[28] += x83 * (x14 * x149 * x69 + x147 * x151 * x66 + x149 * x17 * x68)
result[29] += x83 * (x147 * x154 * x58 + x154 * x17 * x67 + x157 * x5)
result[30] += x65 * (x159 * x20 * x72 + x160 * x18 + x161 * x18 * x63)
result[31] += x65 * (
x143
* (
x1 * (3.0 * x114 + 3.0 * x115 + 3.0 * x116 + x137)
+ x142 * x56
+ x9 * (2.0 * ax * x163 - x162)
)
+ x164 * x63
+ x164 * x8
)
result[32] += x65 * (x13 * x159 * x77 + x160 * x75 + x161 * x75 * x8)
result[33] += x83 * (x135 * x19 * x93 + x135 * x20 * x91 + x137 * x165 * x18)
result[34] += x83 * (x13 * x140 * x93 + x140 * x165 * x8 + x144 * x61)
result[35] += x83 * (x100 * x166 + x13 * x137 * x98 + x166 * x8 * x98)
result[36] += x109 * (x104 * x121 * x20 + x104 * x124 * x19 + x107 * x121 * x19)
result[37] += x109 * (x117 * x121 * x13 + x121 * x167 * x8 + x124 * x167)
result[38] += x109 * (x104 * x13 * x133 + x104 * x168 * x8 + x107 * x168)
result[39] += x83 * (x149 * x19 * x80 + x149 * x20 * x78 + x151 * x169 * x18)
result[40] += x83 * (x13 * x151 * x87 + x170 * x8 * x87 + x170 * x89)
result[41] += x83 * (x13 * x154 * x80 + x154 * x169 * x8 + x157 * x56)
result[42] += x65 * (x172 * x20 * x67 + x173 * x18 + x174 * x18 * x58)
result[43] += x65 * (x13 * x172 * x69 + x173 * x66 + x174 * x66 * x8)
result[44] += x65 * (
x146
* (
x1 * (3.0 * x130 + 3.0 * x131 + 3.0 * x132 + x151)
+ x156 * x61
+ x9 * (2.0 * ax * x176 - x175)
)
+ x177 * x58
+ x177 * x8
)
[docs]
@numba.jit(
func_type.signature,
nopython=True,
nogil=True,
fastmath=True,
cache=True,
)
def kinetic3d_14(ax, da, A, bx, db, B, R, result):
"""See docstring of kinetic3d_41."""
# Call equivalent function and write to result
tmp = numpy.zeros_like(result)
kinetic3d_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 kinetic3d_22(ax, da, A, bx, db, B, R, result):
"""Cartesian 3D (dd) kinetic energy integral.
Generated code; DO NOT modify by hand!"""
x0 = (ax + bx) ** (-1.0)
x1 = x0 * (ax * A[1] + bx * B[1])
x2 = -x1
x3 = x2 + A[1]
x4 = -x3
x5 = ax * (x0 + 2.0 * x4**2)
x6 = x5 - 1.0
x7 = x0 * (ax * A[0] + bx * B[0])
x8 = -x7
x9 = x8 + B[0]
x10 = 2.0 * x9**2
x11 = 3.0 * x0
x12 = x8 + A[0]
x13 = x12 * x9
x14 = 4.0 * x13
x15 = -2.0 * x7 + A[0] + B[0]
x16 = x0 * x15
x17 = 2.0 * x13
x18 = x0 + x17
x19 = x16 + x18 * x9
x20 = 2.0 * x12
x21 = ax * (x0 * (x10 + x11 + x14) + x19 * x20)
x22 = x0 * (ax * A[2] + bx * B[2])
x23 = -x22
x24 = x23 + A[2]
x25 = -x24
x26 = ax * (x0 + 2.0 * x25**2)
x27 = x26 - 1.0
x28 = -x12
x29 = x0 + 2.0 * x28**2
x30 = ax * x29 - 1.0
x31 = 2.0 * x0
x32 = bx * x31
x33 = x32 + 1.0
x34 = -ax * x29 + x33
x35 = -x34
x36 = x0 + x10
x37 = x10 * x35 - x31 * (bx * x36 - 1.0)
x38 = ax * x0
x39 = bx * x0 * x20 - x12 * x30 - x30 * x9 + x32 * x9
x40 = x0 * x30
x41 = -2.0 * bx * x0 * x18 + x17 * x35 + x40
x42 = -x41
x43 = x31 * (-bx * x19 - x7 + A[0])
x44 = -x9
x45 = 2.0 * x44**2
x46 = x28 * x44
x47 = numpy.sqrt(x0)
x48 = -B[0]
x49 = bx * x38
x50 = -B[1]
x51 = -B[2]
x52 = (
5.56832799683170785
* da
* db
* numpy.exp(-x49 * ((x48 + A[0]) ** 2 + (x50 + A[1]) ** 2 + (x51 + A[2]) ** 2))
)
x53 = 0.0833333333333333333 * x52
x54 = x0 * x47 * x53
x55 = ax * x12
x56 = x0 * x39
x57 = x12 * x18 + x16
x58 = ax * x57
x59 = -x0 * (ax * x56 + x32 * (x48 + x58 + x7) - x41 * x55)
x60 = 2.0 * x24**2
x61 = ax * (x0 + x60)
x62 = x61 - 1.0
x63 = x0 * x58
x64 = x33 - x5
x65 = x2 + B[1]
x66 = x47 * x52
x67 = x65 * x66
x68 = 0.288675134594812882
x69 = x67 * x68
x70 = 2.0 * x3**2
x71 = ax * (x0 + x70)
x72 = x71 - 1.0
x73 = -x26 + x33
x74 = x23 + B[2]
x75 = x66 * x68
x76 = x74 * x75
x77 = 2.0 * x65**2
x78 = x0 + x77
x79 = 2.0 * x12**2
x80 = ax * (x0 + x79)
x81 = x80 - 1.0
x82 = ax * x35 * x79 + ax * x40 - x32 * x81
x83 = x0 * x6
x84 = -x64
x85 = -x31 * (bx * x78 - 1.0) + x77 * x84
x86 = x83 + x85
x87 = x0**1.5
x88 = x53 * x87
x89 = x0 * x80
x90 = -x73
x91 = 2.0 * x74**2
x92 = x0 + x91
x93 = x0 * x27
x94 = -x31 * (bx * x92 - 1.0) + x90 * x91
x95 = x93 + x94
x96 = x0 * (x41 * x9 + x43 - x56)
x97 = x0 * x19
x98 = ax * x3
x99 = x75 * x98
x100 = x3 * x65
x101 = 2.0 * x100
x102 = x0 + x101
x103 = x101 * x84 - x102 * x32 + x83
x104 = 0.25 * ax * x52 * x87
x105 = x0 * x18
x106 = -0.5 * x0 * x42 + 0.5 * x105 * x84 + 0.5 * x105 * x90
x107 = x66 * x74
x108 = x3 * x32 - x3 * x6 + x32 * x65 - x6 * x65
x109 = x0 * x108
x110 = -2.0 * x1 + A[1] + B[1]
x111 = x0 * x110
x112 = x102 * x65 + x111
x113 = x31 * (-bx * x112 - x1 + A[1])
x114 = x0 * (x103 * x65 - x109 + x113)
x115 = x0 * x112
x116 = x55 * x75
x117 = -x103
x118 = x0 * x102
x119 = -x0 * x117 + x118 * x35 + x118 * x90
x120 = 0.5 * x55
x121 = x0 * x92
x122 = ax * x24
x123 = x122 * x75
x124 = x24 * x74
x125 = 2.0 * x124
x126 = x0 + x125
x127 = x125 * x90 - x126 * x32 + x93
x128 = x0 * x78
x129 = -x127
x130 = x0 * x126
x131 = -x0 * x129 + x130 * x35 + x130 * x84
x132 = -x24 * x27 + x24 * x32 - x27 * x74 + x32 * x74
x133 = x0 * x132
x134 = -2.0 * x22 + A[2] + B[2]
x135 = x0 * x134
x136 = x126 * x74 + x135
x137 = x31 * (-bx * x136 - x22 + A[2])
x138 = x0 * (x127 * x74 - x133 + x137)
x139 = x0 * x136
x140 = ax * x70 * x84 + ax * x83 - x32 * x72
x141 = x37 + x40
x142 = x102 * x3 + x111
x143 = ax * x142
x144 = -x0 * (ax * x109 - x103 * x98 + x32 * (x1 + x143 + x50))
x145 = x0 * x143
x146 = x75 * x9
x147 = x0 * x71
x148 = 4.0 * x100
x149 = ax * (x0 * (x11 + x148 + x77) + 2.0 * x112 * x3)
x150 = -x65
x151 = 2.0 * x150**2
x152 = x150 * x4
x153 = x0 * x36
x154 = 0.5 * x66 * x9
x155 = ax * x60 * x90 + ax * x93 - x32 * x62
x156 = x0 * x61
x157 = x126 * x24 + x135
x158 = ax * x157
x159 = -x0 * (ax * x133 - x122 * x127 + x32 * (x158 + x22 + x51))
x160 = x0 * x158
x161 = 4.0 * x124
x162 = ax * (x0 * (x11 + x161 + x91) + 2.0 * x136 * x24)
x163 = -x74
x164 = 2.0 * x163**2
x165 = x163 * x25
# 36 item(s)
result[0] += -x54 * (
-ax * x20 * (x0 * x39 + x42 * x9 - x43)
+ x21 * x27
+ x21 * x6
+ x32
* (
-ax
* (
x0 * (x11 + x45 + 4.0 * x46)
- 2.0 * x28 * (x0 * x15 - x44 * (x0 + 2.0 * x46))
)
+ x0
+ x45
)
+ x38 * (-4.0 * bx * x0 * x18 + x11 * x30 + x14 * x35 + x37)
)
result[1] += x69 * (ax * x0 * x57 * x64 - x59 - x62 * x63)
result[2] += x76 * (ax * x0 * x57 * x73 - x59 - x63 * x72)
result[3] += -x88 * (x62 * x78 * x80 + x78 * x82 + x80 * x86)
result[4] += -x69 * x74 * (x0 * x82 + x84 * x89 + x89 * x90)
result[5] += -x88 * (x72 * x80 * x92 + x80 * x95 + x82 * x92)
result[6] += x99 * (x0 * x19 * x64 - x62 * x97 - x96)
result[7] += -x104 * (x102 * x18 * x62 + x102 * x41 + x103 * x18)
result[8] += -x106 * x107 * x98
result[9] += x116 * (x0 * x112 * x34 - x114 - x115 * x62)
result[10] += -x107 * x119 * x120
result[11] += -x116 * x3 * (x0 * x95 + x121 * x35 + x121 * x84)
result[12] += x123 * (x0 * x19 * x73 - x72 * x97 - x96)
result[13] += -x106 * x122 * x67
result[14] += -x104 * (x126 * x18 * x72 + x126 * x41 + x127 * x18)
result[15] += -x116 * x24 * (x0 * x86 + x128 * x35 + x128 * x90)
result[16] += -x120 * x131 * x67
result[17] += x116 * (x0 * x136 * x34 - x138 - x139 * x72)
result[18] += -x88 * (x140 * x36 + x141 * x71 + x36 * x62 * x71)
result[19] += x146 * (ax * x0 * x142 * x34 - x144 - x145 * x62)
result[20] += -x76 * x9 * (x0 * x140 + x147 * x35 + x147 * x90)
result[21] += -x54 * (
x149 * x27
+ x149 * x30
+ x32
* (
-ax
* (
x0 * (x11 + x151 + 4.0 * x152)
- 2.0 * x4 * (x0 * x110 - x150 * (x0 + 2.0 * x152))
)
+ x0
+ x151
)
+ x38 * (-4.0 * bx * x0 * x102 + x11 * x6 + x148 * x84 + x85)
- 2.0 * x98 * (x0 * x108 - x113 + x117 * x65)
)
result[22] += x76 * (ax * x0 * x142 * x73 - x144 - x145 * x81)
result[23] += -x88 * (x140 * x92 + x71 * x81 * x92 + x71 * x95)
result[24] += -x24 * x99 * (x0 * x141 + x153 * x84 + x153 * x90)
result[25] += -x119 * x122 * x154
result[26] += -x131 * x154 * x98
result[27] += x123 * (x0 * x112 * x73 - x114 - x115 * x81)
result[28] += -x104 * (x102 * x126 * x81 + x102 * x127 + x103 * x126)
result[29] += x99 * (x0 * x136 * x64 - x138 - x139 * x81)
result[30] += -x88 * (x141 * x61 + x155 * x36 + x36 * x61 * x72)
result[31] += -x69 * x9 * (x0 * x155 + x156 * x35 + x156 * x84)
result[32] += x146 * (ax * x0 * x157 * x34 - x159 - x160 * x72)
result[33] += -x88 * (x155 * x78 + x61 * x78 * x81 + x61 * x86)
result[34] += x69 * (ax * x0 * x157 * x64 - x159 - x160 * x81)
result[35] += -x54 * (
-2.0 * x122 * (x0 * x132 + x129 * x74 - x137)
+ x162 * x30
+ x162 * x6
+ x32
* (
-ax
* (
x0 * (x11 + x164 + 4.0 * x165)
- 2.0 * x25 * (x0 * x134 - x163 * (x0 + 2.0 * x165))
)
+ x0
+ x164
)
+ x38 * (-4.0 * bx * x0 * x126 + x11 * x27 + x161 * x90 + x94)
)
[docs]
@numba.jit(
func_type.signature,
nopython=True,
nogil=True,
fastmath=True,
cache=True,
)
def kinetic3d_32(ax, da, A, bx, db, B, R, result):
"""Cartesian 3D (fd) kinetic energy 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
x5 = 2.0 * x4**2
x6 = x0 + x5
x7 = ax * x6 - 1.0
x8 = x0 * x7
x9 = 3.0 * x8
x10 = x2 + B[0]
x11 = x10 * x3
x12 = 2.0 * x11
x13 = x0 + x12
x14 = 2.0 * x0
x15 = bx * x14
x16 = x15 + 1.0
x17 = -ax * x6 + x16
x18 = -x17
x19 = 4.0 * x11
x20 = x18 * x19
x21 = 2.0 * x10**2
x22 = x0 + x21
x23 = -x14 * (bx * x22 - 1.0) + x18 * x21
x24 = x10 * x15 - x10 * x7 + x15 * x3 - x3 * x7
x25 = -x0 * x24
x26 = -2.0 * bx * x0 * x13 + x12 * x18 + x8
x27 = -x26
x28 = x10 * x27
x29 = -2.0 * x1 + A[0] + B[0]
x30 = x0 * x29
x31 = x10 * x13
x32 = x30 + x31
x33 = x14 * (-bx * x32 - x1 + A[0])
x34 = x25 - x28 + x33
x35 = ax * x3
x36 = -x10
x37 = 2.0 * x36**2
x38 = 3.0 * x0
x39 = x36 * x4
x40 = 4.0 * x39
x41 = x38 + x40
x42 = -x0 * x29
x43 = x0 + 2.0 * x39
x44 = x36 * x43
x45 = 2.0 * x4
x46 = x0 * (x37 + x41) + x45 * (x42 + x44)
x47 = (
ax * x0 * (-4.0 * bx * x0 * x13 + x20 + x23 + x9)
+ x15 * (-ax * x46 + x0 + x37)
+ 2.0 * x34 * x35
)
x48 = ax * x25
x49 = -B[0]
x50 = x13 * x3
x51 = x30 + x50
x52 = ax * x51
x53 = -x15 * (x1 + x49 + x52)
x54 = -x27 * x35 + x53
x55 = x0 * (ax * A[1] + bx * B[1])
x56 = -x55
x57 = x56 + A[1]
x58 = -x57
x59 = 2.0 * x58**2
x60 = ax * (x0 + x59)
x61 = x60 - 1.0
x62 = 2.0 * x3
x63 = x0 * (x19 + x21 + x38) + x32 * x62
x64 = ax * (x14 * (2.0 * x30 + x31 + x50) + x3 * x63)
x65 = x0 * (ax * A[2] + bx * B[2])
x66 = -x65
x67 = x66 + A[2]
x68 = -x67
x69 = 2.0 * x68**2
x70 = ax * (x0 + x69)
x71 = x70 - 1.0
x72 = x4 * x43
x73 = 2.0 * x42
x74 = 2.2360679774997897
x75 = numpy.sqrt(x0)
x76 = ax * x0
x77 = bx * x76
x78 = -B[1]
x79 = -B[2]
x80 = (
5.56832799683170785
* da
* db
* numpy.exp(-x77 * ((x49 + A[0]) ** 2 + (x78 + A[1]) ** 2 + (x79 + A[2]) ** 2))
)
x81 = x75 * x80
x82 = 0.0166666666666666667 * x81
x83 = x0 * x74 * x82
x84 = 2.0 * x3**2
x85 = ax * (x0 + x84)
x86 = x85 - 1.0
x87 = ax * x18
x88 = -x15 * x86 + x84 * x87
x89 = x48 + x54
x90 = x0 * (
x0 * (-4.0 * ax * bx * x0 * x13 + ax * x20 + ax * x9 + x88)
+ x15 * (-ax * (x0 * (x41 + x5) + x45 * (x42 + x72)) + x14 + x40)
+ x62 * x89
)
x91 = 2.0 * x67**2
x92 = ax * (x0 + x91)
x93 = x92 - 1.0
x94 = x38 + x84
x95 = x76 * (x0 * (x19 + x94) + x51 * x62)
x96 = x16 - x60
x97 = x56 + B[1]
x98 = 3.87298334620741689
x99 = x82 * x98
x100 = x97 * x99
x101 = 2.0 * x57**2
x102 = ax * (x0 + x101)
x103 = x102 - 1.0
x104 = x16 - x70
x105 = x66 + B[2]
x106 = x105 * x99
x107 = 2.0 * x97**2
x108 = x0 + x107
x109 = ax * x14
x110 = ax * x94
x111 = ax * x8 + x88
x112 = x111 - x15 * (x110 - 2.0)
x113 = -x109 * x17 + x112
x114 = x0 * x61
x115 = -x96
x116 = x107 * x115 - x14 * (bx * x108 - 1.0)
x117 = x114 + x116
x118 = x0**1.5
x119 = x118 * x80
x120 = 0.0166666666666666667 * x119 * x74
x121 = x120 * x3
x122 = x0 * x110
x123 = -x104
x124 = x105 * x81
x125 = 0.0333333333333333333 * x98
x126 = 2.0 * x105**2
x127 = x0 + x126
x128 = x0 * x71
x129 = x123 * x126 - x14 * (bx * x127 - 1.0)
x130 = x128 + x129
x131 = x0 * x47
x132 = x63 * x76
x133 = 0.0833333333333333333 * x80
x134 = x133 * x75
x135 = x134 * x57
x136 = x57 * x97
x137 = 2.0 * x136
x138 = x0 + x137
x139 = x0 * x24
x140 = -ax * x139 + x26 * x35 + x53
x141 = x114 + x115 * x137 - x138 * x15
x142 = 1.73205080756887729
x143 = x118 * x133
x144 = x142 * x143
x145 = x124 * x57
x146 = x0 * x52
x147 = 0.166666666666666667 * x142
x148 = x147 * (x0 * x89 + x115 * x146 + x123 * x146)
x149 = -2.0 * x55 + A[1] + B[1]
x150 = x0 * x149
x151 = x138 * x97
x152 = x150 + x151
x153 = x15 * x57 + x15 * x97 - x57 * x61 - x61 * x97
x154 = x0 * x153
x155 = x14 * (-bx * x152 - x55 + A[1])
x156 = x141 * x97 - x154 + x155
x157 = -x111
x158 = -x141
x159 = x123 * x138
x160 = x105 * x144
x161 = -x130
x162 = x143 * x57
x163 = x134 * x67
x164 = x81 * x97
x165 = x164 * x67
x166 = x105 * x67
x167 = 2.0 * x166
x168 = x0 + x167
x169 = x123 * x167 + x128 - x15 * x168
x170 = -x117
x171 = x143 * x67
x172 = -x169
x173 = x115 * x168
x174 = x144 * x97
x175 = -2.0 * x65 + A[2] + B[2]
x176 = x0 * x175
x177 = x105 * x168
x178 = x176 + x177
x179 = x105 * x15 - x105 * x71 + x15 * x67 - x67 * x71
x180 = x0 * x179
x181 = x14 * (-bx * x178 - x65 + A[2])
x182 = x105 * x169 - x180 + x181
x183 = ax * x115
x184 = x101 * x183 - x103 * x15
x185 = ax * x114 + x184
x186 = x10 * x26 - x139 + x33
x187 = ax * x57
x188 = x138 * x57
x189 = x150 + x188
x190 = ax * x189
x191 = -x15 * (x190 + x55 + x78)
x192 = -ax * x154 + x141 * x187 + x191
x193 = -x185
x194 = x102 * x123
x195 = x38 * x61
x196 = 4.0 * x136
x197 = -x153
x198 = x0 * x197
x199 = x158 * x97
x200 = x155 + x198 - x199
x201 = -x97
x202 = 2.0 * x201**2
x203 = x201 * x58
x204 = 4.0 * x203
x205 = x204 + x38
x206 = -x149
x207 = x0 * x206
x208 = x0 + 2.0 * x203
x209 = x201 * x208
x210 = 2.0 * x58
x211 = x0 * (x202 + x205) + x210 * (x207 + x209)
x212 = (
x15 * (-ax * x211 + x0 + x202)
+ 2.0 * x187 * x200
+ x76 * (-4.0 * bx * x0 * x138 + x115 * x196 + x116 + x195)
)
x213 = x0 * x212
x214 = 2.0 * x57
x215 = x0 * (x107 + x196 + x38) + x152 * x214
x216 = x215 * x76
x217 = x134 * x3
x218 = -x158 * x187 + x191
x219 = ax * x198 + x218
x220 = x0 * x190
x221 = x0 * x219 + x123 * x220 + x18 * x220
x222 = x147 * x3
x223 = x143 * x3
x224 = x0 * x32
x225 = x147 * x81
x226 = x225 * x67
x227 = ax * x67
x228 = 0.25 * x119
x229 = x0 * x152
x230 = x168 * x18
x231 = -x179
x232 = x0 * x231
x233 = x105 * x172
x234 = x181 + x232 - x233
x235 = x0 * x178
x236 = ax * x123
x237 = -x15 * x93 + x236 * x91
x238 = ax * x128 + x237
x239 = -x238
x240 = x115 * x92
x241 = x168 * x67
x242 = x176 + x241
x243 = ax * x242
x244 = -x15 * (x243 + x65 + x79)
x245 = -ax * x180 + x169 * x227 + x244
x246 = x18 * x92
x247 = -x172 * x227 + x244
x248 = ax * x232 + x247
x249 = x0 * x243
x250 = x0 * x248 + x115 * x249 + x18 * x249
x251 = x38 * x71
x252 = 4.0 * x166
x253 = -x105
x254 = 2.0 * x253**2
x255 = x253 * x68
x256 = 4.0 * x255
x257 = x256 + x38
x258 = -x175
x259 = x0 * x258
x260 = x0 + 2.0 * x255
x261 = x253 * x260
x262 = 2.0 * x68
x263 = x0 * (x254 + x257) + x262 * (x259 + x261)
x264 = (
x15 * (-ax * x263 + x0 + x254)
+ 2.0 * x227 * x234
+ x76 * (-4.0 * bx * x0 * x168 + x123 * x252 + x129 + x251)
)
x265 = x0 * x264
x266 = 2.0 * x67
x267 = x0 * (x126 + x252 + x38) + x178 * x266
x268 = x267 * x76
x269 = x101 + x38
x270 = ax * x269
x271 = -x15 * (x270 - 2.0) + x185
x272 = -x109 * x96 + x271
x273 = x23 + x8
x274 = x120 * x57
x275 = x208 * x58
x276 = x0 * (
x0 * (-4.0 * ax * bx * x0 * x138 + ax * x195 + x183 * x196 + x184)
+ x15 * (-ax * (x0 * (x205 + x59) + x210 * (x207 + x275)) + x14 + x204)
+ x214 * x219
)
x277 = x76 * (x0 * (x196 + x269) + x189 * x214)
x278 = x10 * x99
x279 = x0 * x270
x280 = x10 * x125
x281 = ax * (x14 * (x14 * x149 + x151 + x188) + x215 * x57)
x282 = x14 * x206
x283 = -x273
x284 = x10 * x225
x285 = x10 * x144
x286 = x38 + x91
x287 = ax * x286
x288 = -x15 * (x287 - 2.0) + x238
x289 = -x104 * x109 + x288
x290 = x120 * x67
x291 = x0 * x287
x292 = x260 * x68
x293 = x0 * (
x0 * (-4.0 * ax * bx * x0 * x168 + ax * x251 + x236 * x252 + x237)
+ x15 * (-ax * (x0 * (x257 + x69) + x262 * (x259 + x292)) + x14 + x256)
+ x248 * x266
)
x294 = x76 * (x0 * (x252 + x286) + x242 * x266)
x295 = ax * (x14 * (x14 * x175 + x177 + x241) + x267 * x67)
x296 = x14 * x258
# 60 item(s)
result[0] += x83 * (
x14 * (-ax * x28 + ax * x33 + 2.0 * x48 + x54)
- x15 * (-ax * (x14 * (x44 + x72 + x73) + x4 * x46) + 2.0 * x44 + x73)
+ x3 * x47
+ x61 * x64
+ x64 * x71
)
result[1] += x100 * (x90 + x93 * x95 - x95 * x96)
result[2] += x106 * (x103 * x95 - x104 * x95 + x90)
result[3] += x121 * (x108 * x110 * x93 + x108 * x113 + x110 * x117)
result[4] += (
x124 * x125 * x3 * x97 * (x0 * (x112 + x14 * x87) + x115 * x122 + x122 * x123)
)
result[5] += x121 * (x103 * x110 * x127 + x110 * x130 + x113 * x127)
result[6] += x135 * (x131 + x132 * x93 - x132 * x96)
result[7] += x144 * (x138 * x140 + x138 * x52 * x93 + x141 * x52)
result[8] += x145 * x148
result[9] += x143 * (x111 * x152 + x152 * x85 * x93 + x156 * x85)
result[10] += x160 * (-x138 * x157 - x158 * x85 + x159 * x85)
result[11] += x162 * (x115 * x127 * x85 - x127 * x157 - x161 * x85)
result[12] += x163 * (x103 * x132 - x104 * x132 + x131)
result[13] += x148 * x165
result[14] += x144 * (x103 * x168 * x52 + x140 * x168 + x169 * x52)
result[15] += x171 * (x108 * x123 * x85 - x108 * x157 - x170 * x85)
result[16] += x174 * (-x157 * x168 - x172 * x85 + x173 * x85)
result[17] += x143 * (x103 * x178 * x85 + x111 * x178 + x182 * x85)
result[18] += x143 * (x102 * x186 + x102 * x32 * x93 + x185 * x32)
result[19] += x144 * (x13 * x190 * x93 + x13 * x192 + x190 * x26)
result[20] += x160 * (-x102 * x27 - x13 * x193 + x13 * x194)
result[21] += x217 * (-x17 * x216 + x213 + x216 * x93)
result[22] += x124 * x221 * x222
result[23] += x223 * (x102 * x127 * x18 - x102 * x161 - x127 * x193)
result[24] += x187 * x226 * (x0 * x34 + x115 * x224 + x123 * x224)
result[25] += x227 * x228 * (-x13 * x158 + x13 * x159 - x138 * x27)
result[26] += x187 * x228 * (-x13 * x172 + x13 * x173 - x168 * x27)
result[27] += x226 * x35 * (x0 * x200 + x123 * x229 + x18 * x229)
result[28] += x228 * x35 * (-x138 * x172 + x138 * x230 - x158 * x168)
result[29] += x225 * x35 * x57 * (x0 * x234 + x115 * x235 + x18 * x235)
result[30] += x143 * (x103 * x32 * x92 + x186 * x92 + x238 * x32)
result[31] += x174 * (-x13 * x239 + x13 * x240 - x27 * x92)
result[32] += x144 * (x103 * x13 * x243 + x13 * x245 + x243 * x26)
result[33] += x223 * (-x108 * x239 + x108 * x246 - x170 * x92)
result[34] += x164 * x222 * x250
result[35] += x217 * (x103 * x268 - x17 * x268 + x265)
result[36] += x274 * (x22 * x270 * x93 + x22 * x272 + x270 * x273)
result[37] += x278 * (-x17 * x277 + x276 + x277 * x93)
result[38] += x145 * x280 * (x0 * (x109 * x115 + x271) + x123 * x279 + x18 * x279)
result[39] += x83 * (
x14 * (ax * x155 - ax * x199 + x109 * x197 + x218)
- x15 * (-ax * (x14 * (x209 + x275 + x282) + x211 * x58) + 2.0 * x209 + x282)
+ x212 * x57
+ x281 * x7
+ x281 * x71
)
result[40] += x106 * (-x104 * x277 + x276 + x277 * x86)
result[41] += x274 * (x127 * x270 * x86 + x127 * x272 + x130 * x270)
result[42] += x171 * (-x102 * x283 - x193 * x22 + x194 * x22)
result[43] += x221 * x284 * x67
result[44] += x285 * (-x102 * x172 + x102 * x230 - x168 * x193)
result[45] += x163 * (-x104 * x216 + x213 + x216 * x86)
result[46] += x144 * (x168 * x190 * x86 + x168 * x192 + x169 * x190)
result[47] += x143 * (x102 * x178 * x86 + x102 * x182 + x178 * x185)
result[48] += x162 * (-x22 * x239 + x22 * x240 - x283 * x92)
result[49] += x285 * (-x138 * x239 + x138 * x246 - x158 * x92)
result[50] += x250 * x284 * x57
result[51] += x143 * (x152 * x238 + x152 * x86 * x92 + x156 * x92)
result[52] += x144 * (x138 * x243 * x86 + x138 * x245 + x141 * x243)
result[53] += x135 * (x265 + x268 * x86 - x268 * x96)
result[54] += x290 * (x103 * x22 * x287 + x22 * x289 + x273 * x287)
result[55] += x165 * x280 * (x0 * (x109 * x123 + x288) + x115 * x291 + x18 * x291)
result[56] += x278 * (x103 * x294 - x17 * x294 + x293)
result[57] += x290 * (x108 * x287 * x86 + x108 * x289 + x117 * x287)
result[58] += x100 * (x293 + x294 * x86 - x294 * x96)
result[59] += x83 * (
x14 * (ax * x181 - ax * x233 + x109 * x231 + x247)
- x15 * (-ax * (x14 * (x261 + x292 + x296) + x263 * x68) + 2.0 * x261 + x296)
+ x264 * x67
+ x295 * x61
+ x295 * x7
)
[docs]
@numba.jit(
func_type.signature,
nopython=True,
nogil=True,
fastmath=True,
cache=True,
)
def kinetic3d_23(ax, da, A, bx, db, B, R, result):
"""See docstring of kinetic3d_32."""
# Call equivalent function and write to result
tmp = numpy.zeros_like(result)
kinetic3d_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 kinetic3d_42(ax, da, A, bx, db, B, R, result):
"""Cartesian 3D (gd) kinetic energy integral.
Generated code; DO NOT modify by hand!"""
x0 = 2.0 * ax
x1 = 2.0 * bx
x2 = (x0 + x1) ** (-1.0)
x3 = (ax + bx) ** (-1.0)
x4 = -x3 * (ax * A[0] + bx * B[0])
x5 = -x4 - A[0]
x6 = -ax
x7 = x5**2
x8 = 2.0 * ax**2
x9 = -x6 - x8 * (x2 + x7)
x10 = bx * x3
x11 = ax * x10
x12 = numpy.exp(-x11 * (A[0] - B[0]) ** 2)
x13 = 1.77245385090551603 * numpy.sqrt(x3)
x14 = x12 * x13
x15 = x14 * x5
x16 = x15 * x9
x17 = x0 * x10
x18 = x15 * x17 + x16
x19 = x18 * x5
x20 = x14 * x7
x21 = x14 * x2
x22 = x20 + x21
x23 = -x14
x24 = x10 * (x0 * x22 + x23)
x25 = x19 + x24
x26 = x21 * x9
x27 = 3.0 * x26
x28 = -x4 - B[0]
x29 = x14 * x28
x30 = x29 * (x17 + x9)
x31 = x30 * x5
x32 = x15 * x28
x33 = x21 + x32
x34 = 4.0 * x11
x35 = x27 + 2.0 * x31 + x33 * x34
x36 = x2 * (x25 + x35)
x37 = x2 * (x18 + x30)
x38 = x17 * x33 + x26 + x31
x39 = x38 * x5
x40 = x2 * (x15 + x29)
x41 = x33 * x5
x42 = x40 + x41
x43 = x0 * x42 - x29
x44 = x10 * x43
x45 = x37 + x39 + x44
x46 = x45 * x5
x47 = x14 * x28**2
x48 = x21 + x47
x49 = ax * x3
x50 = x28 * x30 + x49 * (x1 * x48 + x23)
x51 = x2 * (x35 + x50)
x52 = x28 * x38
x53 = x28 * x33
x54 = x40 + x53
x55 = x1 * x54 - x15
x56 = x37 + x49 * x55 + x52
x57 = x5 * x56
x58 = 3.0 * x21
x59 = 2.0 * x32
x60 = x58 + x59
x61 = x2 * (x20 + x60)
x62 = x42 * x5
x63 = x61 + x62
x64 = 2.0 * x21
x65 = 2.0 * ax * x63 - x59 - x64
x66 = x1 * x3
x67 = x2 * (x47 + x60)
x68 = x5 * x54
x69 = x67 + x68
x70 = x10 * (2.0 * ax * x69 - x48)
x71 = x0 * x3
x72 = x51 + x57 + x70
x73 = 2.0 * x53
x74 = x2 * (4.0 * x40 + 2.0 * x41 + x73) + x5 * x69
x75 = (
-x10 * (-2.0 * ax * x74 + 2.0 * x40 + x73)
+ x2 * (4.0 * x37 + 2.0 * x39 + x43 * x66 + 2.0 * x52 + x55 * x71)
+ x5 * x72
)
x76 = 3.0 * x67 + 3.0 * x68
x77 = x2 * (2.0 * x61 + 2.0 * x62 + x76) + x5 * x74
x78 = numpy.exp(-x11 * (A[1] - B[1]) ** 2)
x79 = numpy.exp(-x11 * (A[2] - B[2]) ** 2)
x80 = 3.14159265358979324 * x3 * x79
x81 = x78 * x80
x82 = -x3 * (ax * A[1] + bx * B[1])
x83 = -x82 - A[1]
x84 = x83**2
x85 = -x6 - x8 * (x2 + x84)
x86 = x77 * x81
x87 = -x3 * (ax * A[2] + bx * B[2])
x88 = -x87 - A[2]
x89 = x88**2
x90 = -x6 - x8 * (x2 + x89)
x91 = da * db
x92 = 0.00952380952380952381 * x91
x93 = 5.91607978309961604 * x92
x94 = -x82 - B[1]
x95 = x13 * x78
x96 = x94 * x95
x97 = x96 * (x17 + x85)
x98 = x5 * (x22 + x64)
x99 = 3.0 * x40 + 3.0 * x41
x100 = x2 * (x98 + x99) + x5 * x63
x101 = x13 * x79
x102 = x25 + x26
x103 = x10 * (x0 * x98 - 2.0 * x15) + x102 * x5 + x2 * (x15 * x34 + 2.0 * x16)
x104 = x10 * x65 + x36 + x46
x105 = x81 * (
x10 * (2.0 * ax * x100 - x99)
+ x104 * x5
+ x2 * (x103 + 3.0 * x37 + 3.0 * x39 + 3.0 * x44)
)
x106 = x100 * x81
x107 = 10.2469507659595984 * x92
x108 = -x87 - B[2]
x109 = x101 * x108
x110 = x109 * (x17 + x90)
x111 = x2 * x95
x112 = x111 * x85
x113 = x94**2 * x95
x114 = x111 + x113
x115 = -x95
x116 = x49 * (x1 * x114 + x115) + x94 * x97
x117 = x112 + x116
x118 = 3.0 * x20 + x58
x119 = x118 * x2 + x5 * x98
x120 = x101 * x119
x121 = x10 * (2.0 * ax * x119 - x118) + x103 * x5 + x2 * (3.0 * x19 + 3.0 * x24 + x27)
x122 = x108 * x81
x123 = x101 * x2
x124 = x123 * x90
x125 = x101 * x108**2
x126 = x123 + x125
x127 = -x101
x128 = x108 * x110 + x49 * (x1 * x126 + x127)
x129 = x124 + x128
x130 = x119 * x95
x131 = x83 * x95
x132 = x131 * x85
x133 = x131 * x17 + x132
x134 = x75 * x81
x135 = x74 * x81
x136 = 0.0666666666666666667 * x91
x137 = 2.2360679774997897 * x136
x138 = x83 * x97
x139 = x131 * x94
x140 = x111 + x139
x141 = x112 + x138 + x140 * x17
x142 = x101 * x63
x143 = 3.87298334620741689 * x136
x144 = x2 * (x131 + x96)
x145 = x140 * x94
x146 = x144 + x145
x147 = x101 * x146
x148 = x2 * (x133 + x97)
x149 = x141 * x94
x150 = x1 * x146 - x131
x151 = x148 + x149 + x150 * x49
x152 = x101 * x88
x153 = x152 * x90
x154 = x152 * x17 + x153
x155 = x81 * x88
x156 = x110 * x88
x157 = x108 * x152
x158 = x123 + x157
x159 = x124 + x156 + x158 * x17
x160 = x63 * x95
x161 = x2 * (x109 + x152)
x162 = x108 * x158
x163 = x161 + x162
x164 = x163 * x95
x165 = x2 * (x110 + x154)
x166 = x108 * x159
x167 = x1 * x163 - x152
x168 = x165 + x166 + x167 * x49
x169 = x133 * x83
x170 = x84 * x95
x171 = x111 + x170
x172 = x10 * (x0 * x171 + x115)
x173 = x169 + x172
x174 = x112 + x173
x175 = x101 * x69
x176 = 1.73205080756887729
x177 = 0.111111111111111111 * x176 * x91
x178 = x141 * x83
x179 = x140 * x83
x180 = x144 + x179
x181 = x0 * x180 - x96
x182 = x10 * x181
x183 = x148 + x178 + x182
x184 = x101 * x42
x185 = 0.333333333333333333 * x91
x186 = 3.0 * x111
x187 = 2.0 * x139
x188 = x186 + x187
x189 = x2 * (x113 + x188)
x190 = x146 * x83
x191 = x189 + x190
x192 = x101 * x191
x193 = 3.0 * x112
x194 = 2.0 * x138 + x140 * x34 + x193
x195 = x2 * (x116 + x194)
x196 = x151 * x83
x197 = x10 * (2.0 * ax * x191 - x114)
x198 = x195 + x196 + x197
x199 = x176 * x185
x200 = x154 * x88
x201 = x101 * x89
x202 = x123 + x201
x203 = x10 * (x0 * x202 + x127)
x204 = x200 + x203
x205 = x124 + x204
x206 = x69 * x95
x207 = x159 * x88
x208 = x158 * x88
x209 = x161 + x208
x210 = x0 * x209 - x109
x211 = x10 * x210
x212 = x165 + x207 + x211
x213 = x42 * x95
x214 = 3.0 * x123
x215 = 2.0 * x157
x216 = x214 + x215
x217 = x2 * (x125 + x216)
x218 = x163 * x88
x219 = x217 + x218
x220 = x219 * x95
x221 = 3.0 * x124
x222 = 2.0 * x156 + x158 * x34 + x221
x223 = x2 * (x128 + x222)
x224 = x168 * x88
x225 = x10 * (2.0 * ax * x219 - x126)
x226 = x223 + x224 + x225
x227 = 2.0 * x111
x228 = x83 * (x171 + x227)
x229 = x10 * (x0 * x228 - 2.0 * x131) + x174 * x83 + x2 * (x131 * x34 + 2.0 * x132)
x230 = x101 * x54
x231 = x2 * (x170 + x188)
x232 = x180 * x83
x233 = x231 + x232
x234 = x101 * x233
x235 = x2 * (x173 + x194)
x236 = x183 * x83
x237 = 2.0 * ax * x233 - x187 - x227
x238 = x10 * x237 + x235 + x236
x239 = 2.0 * x145
x240 = x191 * x83 + x2 * (4.0 * x144 + 2.0 * x179 + x239)
x241 = (
-x10 * (-2.0 * ax * x240 + 2.0 * x144 + x239)
+ x198 * x83
+ x2 * (4.0 * x148 + 2.0 * x149 + x150 * x71 + 2.0 * x178 + x181 * x66)
)
x242 = x12 * x80
x243 = x241 * x242
x244 = x242 * x5
x245 = 3.14159265358979324 * x12 * x3 * x78
x246 = x245 * x5
x247 = 2.0 * x123
x248 = x88 * (x202 + x247)
x249 = x10 * (x0 * x248 - 2.0 * x152) + x2 * (x152 * x34 + 2.0 * x153) + x205 * x88
x250 = x54 * x95
x251 = x2 * (x201 + x216)
x252 = x209 * x88
x253 = x251 + x252
x254 = x253 * x95
x255 = x2 * (x204 + x222)
x256 = x212 * x88
x257 = 2.0 * ax * x253 - x215 - x247
x258 = x10 * x257 + x255 + x256
x259 = 2.0 * x162
x260 = x2 * (4.0 * x161 + 2.0 * x208 + x259) + x219 * x88
x261 = (
-x10 * (-2.0 * ax * x260 + 2.0 * x161 + x259)
+ x2 * (4.0 * x165 + 2.0 * x166 + x167 * x71 + 2.0 * x207 + x210 * x66)
+ x226 * x88
)
x262 = x245 * x261
x263 = x26 + x50
x264 = 3.0 * x170 + x186
x265 = x2 * x264 + x228 * x83
x266 = x101 * x265
x267 = (
x10 * (2.0 * ax * x265 - x264)
+ x2 * (3.0 * x169 + 3.0 * x172 + x193)
+ x229 * x83
)
x268 = 3.0 * x144 + 3.0 * x179
x269 = x2 * (x228 + x268) + x233 * x83
x270 = x242 * (
x10 * (2.0 * ax * x269 - x268)
+ x2 * (3.0 * x148 + 3.0 * x178 + 3.0 * x182 + x229)
+ x238 * x83
)
x271 = x242 * x28
x272 = 3.0 * x189 + 3.0 * x190
x273 = x2 * (2.0 * x231 + 2.0 * x232 + x272) + x240 * x83
x274 = x242 * x273
x275 = x242 * x9
x276 = x14 * x265
x277 = x14 * x233
x278 = x14 * x163
x279 = x14 * x191
x280 = x14 * x180
x281 = x14 * x219
x282 = x245 * x83
x283 = x14 * x146
x284 = x14 * x253
x285 = 3.0 * x201 + x214
x286 = x2 * x285 + x248 * x88
x287 = x286 * x95
x288 = (
x10 * (2.0 * ax * x286 - x285)
+ x2 * (3.0 * x200 + 3.0 * x203 + x221)
+ x249 * x88
)
x289 = x245 * x28
x290 = 3.0 * x161 + 3.0 * x208
x291 = x2 * (x248 + x290) + x253 * x88
x292 = x245 * (
x10 * (2.0 * ax * x291 - x290)
+ x2 * (3.0 * x165 + 3.0 * x207 + 3.0 * x211 + x249)
+ x258 * x88
)
x293 = x14 * x286
x294 = 3.0 * x217 + 3.0 * x218
x295 = x2 * (2.0 * x251 + 2.0 * x252 + x294) + x260 * x88
x296 = x245 * x295
# 90 item(s)
result[0] += x93 * (
x81
* (
x10 * (2.0 * ax * x77 - x76)
+ x2 * (2.0 * x36 + 2.0 * x46 + 3.0 * x51 + 3.0 * x57 + x65 * x66 + 3.0 * x70)
+ x5 * x75
)
+ x85 * x86
+ x86 * x90
)
result[1] += x107 * (x100 * x101 * x97 + x105 * x94 + x106 * x90 * x94)
result[2] += x107 * (x100 * x110 * x95 + x105 * x108 + x106 * x108 * x85)
result[3] += x93 * (x101 * x114 * x121 + x114 * x120 * x90 + x117 * x120)
result[4] += x107 * (x109 * x119 * x97 + x110 * x119 * x96 + x121 * x122 * x94)
result[5] += x93 * (x121 * x126 * x95 + x126 * x130 * x85 + x129 * x130)
result[6] += x137 * (x101 * x133 * x74 + x134 * x83 + x135 * x83 * x90)
result[7] += x143 * (x101 * x104 * x140 + x140 * x142 * x90 + x141 * x142)
result[8] += x143 * (x104 * x122 * x83 + x109 * x133 * x63 + x110 * x131 * x63)
result[9] += x137 * (x101 * x151 * x98 + x103 * x147 + x147 * x90 * x98)
result[10] += x143 * (x103 * x109 * x140 + x109 * x141 * x98 + x110 * x140 * x98)
result[11] += x137 * (x103 * x126 * x131 + x126 * x133 * x98 + x129 * x131 * x98)
result[12] += x137 * (x134 * x88 + x135 * x85 * x88 + x154 * x74 * x95)
result[13] += x143 * (x104 * x155 * x94 + x152 * x63 * x97 + x154 * x63 * x96)
result[14] += x143 * (x104 * x158 * x95 + x158 * x160 * x85 + x159 * x160)
result[15] += x137 * (x103 * x114 * x152 + x114 * x154 * x98 + x117 * x152 * x98)
result[16] += x143 * (x103 * x158 * x96 + x158 * x97 * x98 + x159 * x96 * x98)
result[17] += x137 * (x103 * x164 + x164 * x85 * x98 + x168 * x95 * x98)
result[18] += x177 * (x101 * x171 * x72 + x171 * x175 * x90 + x174 * x175)
result[19] += x185 * (x101 * x180 * x45 + x180 * x184 * x90 + x183 * x184)
result[20] += x185 * (x109 * x171 * x45 + x109 * x174 * x42 + x110 * x171 * x42)
result[21] += x177 * (x101 * x198 * x22 + x102 * x192 + x192 * x22 * x90)
result[22] += x185 * (x102 * x109 * x180 + x109 * x183 * x22 + x110 * x180 * x22)
result[23] += x177 * (x102 * x126 * x171 + x126 * x174 * x22 + x129 * x171 * x22)
result[24] += x185 * (x131 * x154 * x69 + x133 * x152 * x69 + x155 * x72 * x83)
result[25] += x199 * (x140 * x152 * x45 + x140 * x154 * x42 + x141 * x152 * x42)
result[26] += x199 * (x131 * x158 * x45 + x131 * x159 * x42 + x133 * x158 * x42)
result[27] += x185 * (x102 * x146 * x152 + x146 * x154 * x22 + x151 * x152 * x22)
result[28] += x199 * (x102 * x140 * x158 + x140 * x159 * x22 + x141 * x158 * x22)
result[29] += x185 * (x102 * x131 * x163 + x131 * x168 * x22 + x133 * x163 * x22)
result[30] += x177 * (x202 * x206 * x85 + x202 * x72 * x95 + x205 * x206)
result[31] += x185 * (x202 * x42 * x97 + x202 * x45 * x96 + x205 * x42 * x96)
result[32] += x185 * (x209 * x213 * x85 + x209 * x45 * x95 + x212 * x213)
result[33] += x177 * (x102 * x114 * x202 + x114 * x205 * x22 + x117 * x202 * x22)
result[34] += x185 * (x102 * x209 * x96 + x209 * x22 * x97 + x212 * x22 * x96)
result[35] += x177 * (x102 * x220 + x22 * x220 * x85 + x22 * x226 * x95)
result[36] += x137 * (x101 * x228 * x56 + x228 * x230 * x90 + x229 * x230)
result[37] += x143 * (x101 * x238 * x33 + x234 * x33 * x90 + x234 * x38)
result[38] += x143 * (x109 * x228 * x38 + x109 * x229 * x33 + x110 * x228 * x33)
result[39] += x137 * (x101 * x18 * x240 + x240 * x244 * x90 + x243 * x5)
result[40] += x143 * (x108 * x238 * x244 + x109 * x18 * x233 + x110 * x15 * x233)
result[41] += x137 * (x126 * x15 * x229 + x126 * x18 * x228 + x129 * x15 * x228)
result[42] += x185 * (x152 * x171 * x56 + x152 * x174 * x54 + x154 * x171 * x54)
result[43] += x199 * (x152 * x180 * x38 + x152 * x183 * x33 + x154 * x180 * x33)
result[44] += x199 * (x158 * x171 * x38 + x158 * x174 * x33 + x159 * x171 * x33)
result[45] += x185 * (x15 * x154 * x191 + x152 * x18 * x191 + x198 * x244 * x88)
result[46] += x199 * (x15 * x158 * x183 + x15 * x159 * x180 + x158 * x18 * x180)
result[47] += x185 * (x15 * x163 * x174 + x15 * x168 * x171 + x163 * x171 * x18)
result[48] += x185 * (x131 * x202 * x56 + x131 * x205 * x54 + x133 * x202 * x54)
result[49] += x199 * (x140 * x202 * x38 + x140 * x205 * x33 + x141 * x202 * x33)
result[50] += x199 * (x131 * x209 * x38 + x131 * x212 * x33 + x133 * x209 * x33)
result[51] += x185 * (x146 * x15 * x205 + x146 * x18 * x202 + x15 * x151 * x202)
result[52] += x199 * (x140 * x15 * x212 + x140 * x18 * x209 + x141 * x15 * x209)
result[53] += x185 * (x131 * x18 * x219 + x133 * x15 * x219 + x226 * x246 * x83)
result[54] += x137 * (x248 * x250 * x85 + x248 * x56 * x95 + x249 * x250)
result[55] += x143 * (x248 * x33 * x97 + x248 * x38 * x96 + x249 * x33 * x96)
result[56] += x143 * (x254 * x33 * x85 + x254 * x38 + x258 * x33 * x95)
result[57] += x137 * (x114 * x15 * x249 + x114 * x18 * x248 + x117 * x15 * x248)
result[58] += x143 * (x15 * x253 * x97 + x18 * x253 * x96 + x246 * x258 * x94)
result[59] += x137 * (x18 * x260 * x95 + x246 * x260 * x85 + x262 * x5)
result[60] += x93 * (x101 * x267 * x48 + x263 * x266 + x266 * x48 * x90)
result[61] += x107 * (x101 * x269 * x30 + x269 * x271 * x90 + x270 * x28)
result[62] += x107 * (x108 * x267 * x271 + x109 * x265 * x30 + x110 * x265 * x29)
result[63] += x93 * (
x242
* (
x10 * (2.0 * ax * x273 - x272)
+ x2
* (
3.0 * x195
+ 3.0 * x196
+ 3.0 * x197
+ 2.0 * x235
+ 2.0 * x236
+ x237 * x66
)
+ x241 * x83
)
+ x274 * x9
+ x274 * x90
)
result[64] += x107 * (x108 * x269 * x275 + x108 * x270 + x110 * x14 * x269)
result[65] += x93 * (x126 * x14 * x267 + x126 * x276 * x9 + x129 * x276)
result[66] += x137 * (x152 * x228 * x263 + x152 * x229 * x48 + x154 * x228 * x48)
result[67] += x143 * (x152 * x233 * x30 + x154 * x233 * x29 + x238 * x271 * x88)
result[68] += x143 * (x158 * x228 * x30 + x158 * x229 * x29 + x159 * x228 * x29)
result[69] += x137 * (x14 * x154 * x240 + x240 * x275 * x88 + x243 * x88)
result[70] += x143 * (x14 * x158 * x238 + x158 * x277 * x9 + x159 * x277)
result[71] += x137 * (x14 * x168 * x228 + x228 * x278 * x9 + x229 * x278)
result[72] += x177 * (x171 * x202 * x263 + x171 * x205 * x48 + x174 * x202 * x48)
result[73] += x185 * (x180 * x202 * x30 + x180 * x205 * x29 + x183 * x202 * x29)
result[74] += x185 * (x171 * x209 * x30 + x171 * x212 * x29 + x174 * x209 * x29)
result[75] += x177 * (x14 * x198 * x202 + x202 * x279 * x9 + x205 * x279)
result[76] += x185 * (x14 * x183 * x209 + x209 * x280 * x9 + x212 * x280)
result[77] += x177 * (x14 * x171 * x226 + x171 * x281 * x9 + x174 * x281)
result[78] += x137 * (x131 * x248 * x263 + x131 * x249 * x48 + x133 * x248 * x48)
result[79] += x143 * (x140 * x248 * x30 + x140 * x249 * x29 + x141 * x248 * x29)
result[80] += x143 * (x131 * x253 * x30 + x133 * x253 * x29 + x258 * x28 * x282)
result[81] += x137 * (x14 * x151 * x248 + x248 * x283 * x9 + x249 * x283)
result[82] += x143 * (x14 * x140 * x258 + x140 * x284 * x9 + x141 * x284)
result[83] += x137 * (x133 * x14 * x260 + x260 * x282 * x9 + x262 * x83)
result[84] += x93 * (x263 * x287 + x287 * x48 * x85 + x288 * x48 * x95)
result[85] += x107 * (x286 * x29 * x97 + x286 * x30 * x96 + x288 * x289 * x94)
result[86] += x107 * (x28 * x292 + x289 * x291 * x85 + x291 * x30 * x95)
result[87] += x93 * (x114 * x14 * x288 + x114 * x293 * x9 + x117 * x293)
result[88] += x107 * (x14 * x291 * x97 + x245 * x291 * x9 * x94 + x292 * x94)
result[89] += x93 * (
x245
* (
x10 * (2.0 * ax * x295 - x294)
+ x2
* (
3.0 * x223
+ 3.0 * x224
+ 3.0 * x225
+ 2.0 * x255
+ 2.0 * x256
+ x257 * x66
)
+ x261 * x88
)
+ x296 * x85
+ x296 * x9
)
[docs]
@numba.jit(
func_type.signature,
nopython=True,
nogil=True,
fastmath=True,
cache=True,
)
def kinetic3d_24(ax, da, A, bx, db, B, R, result):
"""See docstring of kinetic3d_42."""
# Call equivalent function and write to result
tmp = numpy.zeros_like(result)
kinetic3d_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 kinetic3d_33(ax, da, A, bx, db, B, R, result):
"""Cartesian 3D (ff) kinetic energy 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
x5 = 2.0 * x4**2
x6 = x0 + x5
x7 = ax * x6 - 1.0
x8 = x0 * x7
x9 = 3.0 * x8
x10 = x2 + B[0]
x11 = 2.0 * x3
x12 = x10 * x11
x13 = x0 + x12
x14 = 2.0 * x0
x15 = bx * x14
x16 = x15 + 1.0
x17 = -ax * x6 + x16
x18 = -x17
x19 = 4.0 * x10
x20 = x19 * x3
x21 = 2.0 * x10**2
x22 = x0 + x21
x23 = -x14 * (bx * x22 - 1.0) + x18 * x21
x24 = 4.0 * bx * x0 * x13 - x18 * x20 - x23 - x9
x25 = -x10
x26 = 2.0 * x25**2
x27 = 3.0 * x0
x28 = x25 * x4
x29 = 4.0 * x28
x30 = x27 + x29
x31 = x0 * (x26 + x30)
x32 = -2.0 * x1 + A[0] + B[0]
x33 = -x0 * x32
x34 = x0 + 2.0 * x28
x35 = x25 * x34
x36 = x33 + x35
x37 = 2.0 * x36
x38 = x14 + x29
x39 = -bx * (x25 * x37 + x31) + x38
x40 = ax * x0
x41 = 4.0 * x40
x42 = x10 * x15 - x10 * x7 + x15 * x3 - x3 * x7
x43 = -x0 * x42
x44 = -2.0 * bx * x0 * x13 + x12 * x18 + x8
x45 = -x44
x46 = x10 * x45
x47 = x0 * x32
x48 = x10 * x13
x49 = x47 + x48
x50 = x14 * (-bx * x49 - x1 + A[0])
x51 = x43 - x46 + x50
x52 = ax * x51
x53 = ax * x3
x54 = x31 + x37 * x4
x55 = -ax * x54 + x0 + x26
x56 = bx * x0
x57 = 6.0 * x56
x58 = -ax * x0 * x24 + x11 * x52 + x15 * x55
x59 = -x58
x60 = ax * x43
x61 = -B[0]
x62 = x13 * x3
x63 = x47 + x62
x64 = ax * x63
x65 = -x15 * (x1 + x61 + x64)
x66 = -x45 * x53 + x65
x67 = x14 * (ax * x46 - ax * x50 - 2.0 * x60 - x66)
x68 = x34 * x4
x69 = 2.0 * x33
x70 = x14 * (x35 + x68 + x69)
x71 = x25 * x54 + x70
x72 = ax * x14
x73 = x10 * x59 + x67 + x72 * (-bx * x71 + 2.0 * x68 + x69)
x74 = ax * A[1] + bx * B[1]
x75 = x0 * x74
x76 = -x75
x77 = x76 + A[1]
x78 = -x77
x79 = 2.0 * x78**2
x80 = ax * (x0 + x79)
x81 = x80 - 1.0
x82 = x21 + x27
x83 = x0 * (x20 + x82)
x84 = x11 * x49 + x83
x85 = x14 * (2.0 * x47 + x48 + x62)
x86 = x10 * x84 + x85
x87 = ax * (x0 * (x19 * x49 + 6.0 * x3 * x49 + 5.0 * x83) + x11 * x86)
x88 = ax * A[2] + bx * B[2]
x89 = x0 * x88
x90 = -x89
x91 = x90 + A[2]
x92 = -x91
x93 = 2.0 * x92**2
x94 = ax * (x0 + x93)
x95 = x94 - 1.0
x96 = 4.0 * x25 * x36
x97 = 2.0 * x4
x98 = ax * x56
x99 = -B[1]
x100 = -B[2]
x101 = (
5.56832799683170785
* da
* db
* numpy.exp(-x98 * ((x100 + A[2]) ** 2 + (x61 + A[0]) ** 2 + (x99 + A[1]) ** 2))
)
x102 = numpy.sqrt(x0) * x101
x103 = 0.00833333333333333333 * x0 * x102
x104 = x0 * (x15 * (-ax * (x4 * x54 + x70) + 2.0 * x35 + x69) + x3 * x59 + x67)
x105 = x16 - x80
x106 = x40 * (x3 * x84 + x85)
x107 = 2.0 * x91**2
x108 = ax * (x0 + x107)
x109 = x108 - 1.0
x110 = x76 + B[1]
x111 = 0.0166666666666666667 * x110
x112 = 2.2360679774997897
x113 = x102 * x112
x114 = x111 * x113
x115 = x16 - x94
x116 = 2.0 * x77**2
x117 = ax * (x0 + x116)
x118 = x117 - 1.0
x119 = x90 + B[2]
x120 = 0.0166666666666666667 * x119
x121 = x113 * x120
x122 = 2.0 * x110**2
x123 = x0 + x122
x124 = 2.0 * x3**2
x125 = ax * (x0 + x124)
x126 = x125 - 1.0
x127 = ax * x124 * x18 - x126 * x15
x128 = x60 + x66
x129 = (
x0 * (-4.0 * ax * bx * x0 * x13 + ax * x9 + x127 + x18 * x19 * x53)
+ x11 * x128
- x15 * (ax * (x0 * (x30 + x5) + x97 * (x33 + x68)) - x38)
)
x130 = x0 * x81
x131 = -x105
x132 = x122 * x131 - x14 * (bx * x123 - 1.0)
x133 = x130 + x132
x134 = x124 + x27
x135 = ax * (x0 * (x134 + x20) + x11 * x63)
x136 = x0**1.5 * x101
x137 = x112 * x136
x138 = 0.00833333333333333333 * x137
x139 = x0 * x135
x140 = -x115
x141 = 3.87298334620741689 * x102
x142 = x111 * x141
x143 = 2.0 * x119**2
x144 = x0 + x143
x145 = x0 * x95
x146 = -x14 * (bx * x144 - 1.0) + x140 * x143
x147 = x145 + x146
x148 = x122 + x27
x149 = x14 * x17
x150 = ax * x134
x151 = ax * x8 + x127
x152 = -x15 * (x150 - 2.0) + x151
x153 = -ax * x149 + x152
x154 = x105 * x14
x155 = x133 - x14 * (bx * x148 - 2.0)
x156 = -x154 + x155
x157 = x136 * x3
x158 = x14 * x18
x159 = ax * x158 + x152
x160 = -x133
x161 = x123 * x140
x162 = x137 * x3
x163 = x120 * x162
x164 = -x147
x165 = x131 * x144
x166 = x111 * x162
x167 = x143 + x27
x168 = x115 * x14
x169 = -x14 * (bx * x167 - 2.0) + x147
x170 = -x168 + x169
x171 = x0 * x73
x172 = x40 * x86
x173 = 0.0166666666666666667 * x113
x174 = x173 * x77
x175 = x110 * x77
x176 = 2.0 * x175
x177 = x0 + x176
x178 = x130 + x131 * x176 - x15 * x177
x179 = ax * x84
x180 = 0.0416666666666666667 * x136
x181 = x0 * x179
x182 = 0.0833333333333333333 * x102
x183 = x182 * (-x0 * x59 + x131 * x181 + x140 * x181)
x184 = -x14 * x74 + A[1] + B[1]
x185 = x0 * x184
x186 = x110 * x177
x187 = x185 + x186
x188 = x0 * x42
x189 = -ax * x188 + x44 * x53 + x65
x190 = x110 * x15 - x110 * x81 + x15 * x77 - x77 * x81
x191 = x0 * x190
x192 = x14 * (-bx * x187 - x75 + A[1])
x193 = x110 * x178 - x191 + x192
x194 = 0.0833333333333333333 * x136
x195 = -x178
x196 = x140 * x177
x197 = 1.73205080756887729
x198 = x119 * x194
x199 = x197 * x198
x200 = x194 * x77
x201 = 4.0 * x175
x202 = x0 * (x148 + x201)
x203 = 2.0 * x110
x204 = x187 * x203 + x202
x205 = x27 * x81
x206 = x131 * x201
x207 = 4.0 * bx * x0 * x177 - x132 - x205 - x206
x208 = x0 * x207
x209 = -x110
x210 = 2.0 * x209**2
x211 = x209 * x78
x212 = 4.0 * x211
x213 = x212 + x27
x214 = x210 + x213
x215 = x0 * x214
x216 = -x184
x217 = x0 * x216
x218 = x0 + 2.0 * x211
x219 = x209 * x218
x220 = x217 + x219
x221 = 2.0 * x220
x222 = x14 + x212
x223 = -bx * (x209 * x221 + x215) + x222
x224 = -x190
x225 = x0 * x224
x226 = x110 * x195
x227 = x192 + x225 - x226
x228 = x14 * x223 + x203 * x227 - x208
x229 = -x151
x230 = x140 * x187
x231 = x14 * x140
x232 = x169 + x231
x233 = x137 * x77
x234 = x120 * x233
x235 = x173 * x91
x236 = x119 * x91
x237 = 2.0 * x236
x238 = x0 + x237
x239 = x140 * x237 + x145 - x15 * x238
x240 = x194 * x91
x241 = -x239
x242 = x131 * x238
x243 = x110 * x194
x244 = x197 * x243
x245 = -x14 * x88 + A[2] + B[2]
x246 = x0 * x245
x247 = x119 * x238
x248 = x246 + x247
x249 = x119 * x15 - x119 * x95 + x15 * x91 - x91 * x95
x250 = x0 * x249
x251 = x14 * (-bx * x248 - x89 + A[2])
x252 = x119 * x239 - x250 + x251
x253 = x131 * x14
x254 = x155 + x253
x255 = x137 * x91
x256 = x111 * x255
x257 = -x249
x258 = x0 * x257
x259 = x119 * x241
x260 = x251 + x258 - x259
x261 = x131 * x248
x262 = 4.0 * x236
x263 = x0 * (x167 + x262)
x264 = 2.0 * x119
x265 = x248 * x264 + x263
x266 = x27 * x95
x267 = x140 * x262
x268 = 4.0 * bx * x0 * x238 - x146 - x266 - x267
x269 = x0 * x268
x270 = -x119
x271 = 2.0 * x270**2
x272 = x270 * x92
x273 = 4.0 * x272
x274 = x27 + x273
x275 = x271 + x274
x276 = x0 * x275
x277 = -x245
x278 = x0 * x277
x279 = x0 + 2.0 * x272
x280 = x270 * x279
x281 = x278 + x280
x282 = 2.0 * x281
x283 = x14 + x273
x284 = -bx * (x270 * x282 + x276) + x283
x285 = x14 * x284 + x260 * x264 - x269
x286 = 2.0 * x10
x287 = x286 * x49 + x83
x288 = ax * x116 * x131 - x118 * x15
x289 = ax * x130 + x288
x290 = -x0 * x24 + x14 * x39 + x286 * x51
x291 = ax * x77
x292 = x177 * x77
x293 = x185 + x292
x294 = ax * x293
x295 = -x15 * (x294 + x75 + x99)
x296 = -ax * x191 + x178 * x291 + x295
x297 = x10 * x44 - x188 + x50
x298 = -x289
x299 = x117 * x140
x300 = x227 * x291
x301 = x215 + x221 * x78
x302 = -ax * x301 + x0 + x210
x303 = -ax * x208 + x15 * x302 + 2.0 * x300
x304 = 2.0 * x77
x305 = x187 * x304 + x202
x306 = ax * x44
x307 = ax * x305
x308 = -x195 * x291 + x295
x309 = ax * x225 + x308
x310 = x140 * x294
x311 = -x303
x312 = x14 * (-ax * x192 + ax * x226 - x224 * x72 - x308)
x313 = x218 * x78
x314 = x14 * x216
x315 = x14 * (x219 + x313 + x314)
x316 = x209 * x301 + x315
x317 = x110 * x311 + x312 + x72 * (-bx * x316 + 2.0 * x313 + x314)
x318 = x0 * x317
x319 = x14 * (x14 * x184 + x186 + x292)
x320 = x110 * x305 + x319
x321 = x320 * x40
x322 = x173 * x3
x323 = x0 * x307
x324 = -x0 * x311 + x140 * x323 + x18 * x323
x325 = x182 * x3
x326 = x144 * x18
x327 = x194 * x3
x328 = x0 * x287
x329 = 0.0166666666666666667 * x141
x330 = x329 * x91
x331 = ax * x91
x332 = x194 * x197
x333 = x331 * x332
x334 = x291 * x332
x335 = x0 * x204
x336 = x18 * x238
x337 = x332 * x53
x338 = x18 * x248
x339 = x0 * x265
x340 = ax * x107 * x140 - x109 * x15
x341 = ax * x145 + x340
x342 = -x341
x343 = x108 * x131
x344 = x238 * x91
x345 = x246 + x344
x346 = ax * x345
x347 = -x15 * (x100 + x346 + x89)
x348 = -ax * x250 + x239 * x331 + x347
x349 = -x241 * x331 + x347
x350 = ax * x258 + x349
x351 = x131 * x346
x352 = x260 * x331
x353 = x276 + x282 * x92
x354 = -ax * x353 + x0 + x271
x355 = -ax * x269 + x15 * x354 + 2.0 * x352
x356 = 2.0 * x91
x357 = x248 * x356 + x263
x358 = ax * x357
x359 = x108 * x18
x360 = x18 * x346
x361 = -x355
x362 = x0 * x358
x363 = -x0 * x361 + x131 * x362 + x18 * x362
x364 = x14 * (-ax * x251 + ax * x259 - x257 * x72 - x349)
x365 = x279 * x92
x366 = x14 * x277
x367 = x14 * (x280 + x365 + x366)
x368 = x270 * x353 + x367
x369 = x119 * x361 + x364 + x72 * (-bx * x368 + 2.0 * x365 + x366)
x370 = x0 * x369
x371 = x14 * (x14 * x245 + x247 + x344)
x372 = x119 * x357 + x371
x373 = x372 * x40
x374 = x116 + x27
x375 = ax * x374
x376 = -x15 * (x375 - 2.0) + x289
x377 = -ax * x154 + x376
x378 = x23 + x8
x379 = -x14 * (bx * x82 - 2.0) + x378
x380 = -x149 + x379
x381 = x136 * x77
x382 = 0.0166666666666666667 * x10
x383 = 2.0 * x78
x384 = (
x0 * (-4.0 * ax * bx * x0 * x177 + ax * x205 + ax * x206 + x288)
- x15 * (ax * (x0 * (x213 + x79) + x383 * (x217 + x313)) - x222)
+ x304 * x309
)
x385 = ax * (x0 * (x201 + x374) + x293 * x304)
x386 = ax * x253 + x376
x387 = -x378
x388 = x0 * (
x15 * (-ax * (x301 * x78 + x315) + 2.0 * x219 + x314) + x311 * x77 + x312
)
x389 = x40 * (x305 * x77 + x319)
x390 = x10 * x173
x391 = x0 * x385
x392 = x233 * x382
x393 = 4.0 * x110
x394 = ax * (x0 * (x187 * x393 + 6.0 * x187 * x77 + 5.0 * x202) + x304 * x320)
x395 = 4.0 * x209 * x220
x396 = x158 + x379
x397 = x255 * x382
x398 = x10 * x182
x399 = x10 * x194
x400 = x197 * x399
x401 = x107 + x27
x402 = ax * x401
x403 = -x15 * (x402 - 2.0) + x341
x404 = -ax * x168 + x403
x405 = x136 * x91
x406 = ax * x231 + x403
x407 = 2.0 * x92
x408 = (
x0 * (-4.0 * ax * bx * x0 * x238 + ax * x266 + ax * x267 + x340)
- x15 * (ax * (x0 * (x274 + x93) + x407 * (x278 + x365)) - x283)
+ x350 * x356
)
x409 = ax * (x0 * (x262 + x401) + x345 * x356)
x410 = x0 * x409
x411 = x0 * (
x15 * (-ax * (x353 * x92 + x367) + 2.0 * x280 + x366) + x361 * x91 + x364
)
x412 = x40 * (x357 * x91 + x371)
x413 = 4.0 * x119
x414 = ax * (x0 * (x248 * x413 + 6.0 * x248 * x91 + 5.0 * x263) + x356 * x372)
x415 = 4.0 * x270 * x281
# 100 item(s)
result[0] += -x103 * (
x0 * (-5.0 * ax * x0 * x24 + x19 * x52 + x39 * x41 + 6.0 * x51 * x53 + x55 * x57)
- x11 * x73
+ x15
* (-ax * (x0 * (5.0 * x31 + 6.0 * x36 * x4 + x96) + x71 * x97) + 2.0 * x31 + x96)
+ x81 * x87
+ x87 * x95
)
result[1] += x114 * (x104 + x105 * x106 - x106 * x109)
result[2] += x121 * (x104 + x106 * x115 - x106 * x118)
result[3] += -x138 * (x109 * x123 * x135 + x123 * x129 + x133 * x135)
result[4] += -x119 * x142 * (x0 * x129 + x131 * x139 + x139 * x140)
result[5] += -x138 * (x118 * x135 * x144 + x129 * x144 + x135 * x147)
result[6] += -x111 * x157 * (x109 * x148 * x150 + x148 * x153 + x150 * x156)
result[7] += x163 * (-x123 * x159 + x150 * x160 - x150 * x161)
result[8] += x166 * (-x144 * x159 + x150 * x164 - x150 * x165)
result[9] += -x120 * x157 * (x118 * x150 * x167 + x150 * x170 + x153 * x167)
result[10] += x174 * (x105 * x172 - x109 * x172 + x171)
result[11] += -x180 * (x109 * x177 * x179 + x177 * x58 + x178 * x179)
result[12] += -x119 * x183 * x77
result[13] += -x194 * (x109 * x187 * x64 + x187 * x189 + x193 * x64)
result[14] += x199 * (-x128 * x177 + x195 * x64 - x196 * x64)
result[15] += x200 * (-x128 * x144 + x164 * x64 - x165 * x64)
result[16] += -x138 * (x109 * x125 * x204 + x125 * x228 + x151 * x204)
result[17] += x198 * (-x125 * x227 - x125 * x230 + x187 * x229)
result[18] += -x180 * (x125 * x144 * x178 + x125 * x147 * x177 + x144 * x151 * x177)
result[19] += x234 * (-x125 * x131 * x167 - x125 * x232 + x167 * x229)
result[20] += x235 * (x115 * x172 - x118 * x172 + x171)
result[21] += -x110 * x183 * x91
result[22] += -x180 * (x118 * x179 * x238 + x179 * x239 + x238 * x58)
result[23] += x240 * (-x123 * x128 + x160 * x64 - x161 * x64)
result[24] += x244 * (-x128 * x238 + x241 * x64 - x242 * x64)
result[25] += -x194 * (x118 * x248 * x64 + x189 * x248 + x252 * x64)
result[26] += x256 * (-x125 * x140 * x148 - x125 * x254 + x148 * x229)
result[27] += -x180 * (x123 * x125 * x239 + x123 * x151 * x238 + x125 * x133 * x238)
result[28] += x243 * (-x125 * x260 - x125 * x261 + x229 * x248)
result[29] += -x138 * (x118 * x125 * x265 + x125 * x285 + x151 * x265)
result[30] += -x138 * (x109 * x117 * x287 + x117 * x290 + x287 * x289)
result[31] += -x194 * (x109 * x294 * x49 + x294 * x297 + x296 * x49)
result[32] += x198 * (-x117 * x51 + x298 * x49 - x299 * x49)
result[33] += -x180 * (x109 * x13 * x307 + x13 * x303 + x305 * x306)
result[34] += x199 * (-x13 * x309 - x13 * x310 + x294 * x45)
result[35] += -x180 * (x117 * x13 * x147 + x117 * x144 * x44 + x13 * x144 * x289)
result[36] += x322 * (-x109 * x321 + x17 * x321 + x318)
result[37] += -x119 * x324 * x325
result[38] += x327 * (-x144 * x309 + x164 * x294 - x294 * x326)
result[39] += x163 * (-x117 * x167 * x18 - x117 * x232 + x167 * x298)
result[40] += -x291 * x330 * (x0 * x290 + x131 * x328 + x140 * x328)
result[41] += x333 * (-x177 * x51 + x195 * x49 - x196 * x49)
result[42] += x334 * (-x238 * x51 + x241 * x49 - x242 * x49)
result[43] += x333 * (-x13 * x227 - x13 * x230 + x187 * x45)
result[44] += (
-0.125 * ax * x136 * (x13 * x177 * x239 + x13 * x178 * x238 + x177 * x238 * x44)
)
result[45] += x334 * (-x13 * x260 - x13 * x261 + x248 * x45)
result[46] += -x330 * x53 * (x0 * x228 + x140 * x335 + x18 * x335)
result[47] += x337 * (x187 * x241 - x187 * x336 - x227 * x238)
result[48] += x337 * (-x177 * x260 - x177 * x338 + x195 * x248)
result[49] += -x329 * x53 * x77 * (x0 * x285 + x131 * x339 + x18 * x339)
result[50] += -x138 * (x108 * x118 * x287 + x108 * x290 + x287 * x341)
result[51] += x243 * (-x108 * x51 + x342 * x49 - x343 * x49)
result[52] += -x194 * (x118 * x346 * x49 + x297 * x346 + x348 * x49)
result[53] += -x180 * (x108 * x123 * x44 + x108 * x13 * x133 + x123 * x13 * x341)
result[54] += x244 * (-x13 * x350 - x13 * x351 + x346 * x45)
result[55] += -x180 * (x118 * x13 * x358 + x13 * x355 + x306 * x357)
result[56] += x166 * (-x108 * x254 + x148 * x342 - x148 * x359)
result[57] += x327 * (-x123 * x350 - x123 * x360 + x160 * x346)
result[58] += -x110 * x325 * x363
result[59] += x322 * (-x118 * x373 + x17 * x373 + x370)
result[60] += -x381 * x382 * (x109 * x375 * x82 + x375 * x380 + x377 * x82)
result[61] += -x138 * (x109 * x22 * x385 + x22 * x384 + x378 * x385)
result[62] += x234 * (-x140 * x22 * x375 - x22 * x386 + x375 * x387)
result[63] += x390 * (-x109 * x389 + x17 * x389 + x388)
result[64] += -x10 * x120 * x141 * (x0 * x384 + x140 * x391 + x18 * x391)
result[65] += x392 * (-x144 * x386 + x164 * x375 - x326 * x375)
result[66] += -x103 * (
x0
* (
-5.0 * ax * x0 * x207
+ ax * x227 * x393
+ x223 * x41
+ 6.0 * x300
+ x302 * x57
)
+ x15
* (
-ax * (x0 * (5.0 * x215 + 6.0 * x220 * x78 + x395) + x316 * x383)
+ x14 * x214
+ x395
)
- x304 * x317
+ x394 * x7
+ x394 * x95
)
result[67] += x121 * (x115 * x389 - x126 * x389 + x388)
result[68] += -x138 * (x126 * x144 * x385 + x144 * x384 + x147 * x385)
result[69] += -x120 * x381 * (x126 * x167 * x375 + x167 * x377 + x170 * x375)
result[70] += x397 * (-x117 * x396 + x298 * x82 - x299 * x82)
result[71] += x240 * (-x22 * x309 - x22 * x310 + x294 * x387)
result[72] += -x180 * (x117 * x22 * x239 + x117 * x238 * x378 + x22 * x238 * x289)
result[73] += -x324 * x398 * x91
result[74] += x400 * (-x238 * x309 + x241 * x294 - x294 * x336)
result[75] += x399 * (-x117 * x260 - x117 * x338 + x248 * x298)
result[76] += x235 * (x115 * x321 - x126 * x321 + x318)
result[77] += -x180 * (x126 * x238 * x307 + x238 * x303 + x239 * x307)
result[78] += -x194 * (x126 * x248 * x294 + x248 * x296 + x252 * x294)
result[79] += -x138 * (x117 * x126 * x265 + x117 * x285 + x265 * x289)
result[80] += x392 * (-x108 * x396 + x342 * x82 - x343 * x82)
result[81] += -x180 * (x108 * x177 * x378 + x108 * x178 * x22 + x177 * x22 * x341)
result[82] += x200 * (-x22 * x350 - x22 * x351 + x346 * x387)
result[83] += x399 * (-x108 * x227 + x187 * x342 - x187 * x359)
result[84] += x400 * (-x177 * x350 - x177 * x360 + x195 * x346)
result[85] += -x363 * x398 * x77
result[86] += -x138 * (x108 * x126 * x204 + x108 * x228 + x204 * x341)
result[87] += -x194 * (x126 * x187 * x346 + x187 * x348 + x193 * x346)
result[88] += -x180 * (x126 * x177 * x358 + x177 * x355 + x178 * x358)
result[89] += x174 * (x105 * x373 - x126 * x373 + x370)
result[90] += -x382 * x405 * (x118 * x402 * x82 + x380 * x402 + x404 * x82)
result[91] += x256 * (-x131 * x22 * x402 - x22 * x406 + x387 * x402)
result[92] += -x138 * (x118 * x22 * x409 + x22 * x408 + x378 * x409)
result[93] += x397 * (-x123 * x18 * x402 - x123 * x406 + x160 * x402)
result[94] += -x10 * x142 * (x0 * x408 + x131 * x410 + x18 * x410)
result[95] += x390 * (-x118 * x412 + x17 * x412 + x411)
result[96] += -x111 * x405 * (x126 * x148 * x402 + x148 * x404 + x156 * x402)
result[97] += -x138 * (x123 * x126 * x409 + x123 * x408 + x133 * x409)
result[98] += x114 * (x105 * x412 - x126 * x412 + x411)
result[99] += -x103 * (
x0
* (
-5.0 * ax * x0 * x268
+ ax * x260 * x413
+ x284 * x41
+ 6.0 * x352
+ x354 * x57
)
+ x15
* (
-ax * (x0 * (5.0 * x276 + 6.0 * x281 * x92 + x415) + x368 * x407)
+ x14 * x275
+ x415
)
- x356 * x369
+ x414 * x7
+ x414 * x81
)
[docs]
@numba.jit(
func_type.signature,
nopython=True,
nogil=True,
fastmath=True,
cache=True,
)
def kinetic3d_43(ax, da, A, bx, db, B, R, result):
"""Cartesian 3D (gf) kinetic energy integral.
Generated code; DO NOT modify by hand!"""
x0 = 2.0 * ax
x1 = 2.0 * bx
x2 = (x0 + x1) ** (-1.0)
x3 = (ax + bx) ** (-1.0)
x4 = -x3 * (ax * A[0] + bx * B[0])
x5 = -x4 - A[0]
x6 = -x4 - B[0]
x7 = -ax
x8 = x5**2
x9 = 2.0 * ax**2
x10 = -x7 - x9 * (x2 + x8)
x11 = ax * x3
x12 = bx * x11
x13 = numpy.exp(-x12 * (A[0] - B[0]) ** 2)
x14 = 1.77245385090551603 * numpy.sqrt(x3)
x15 = x13 * x14
x16 = x15 * x6
x17 = x10 * x16
x18 = bx * x3
x19 = x0 * x18
x20 = x16 * x19 + x17
x21 = x15 * x6**2
x22 = x15 * x2
x23 = x21 + x22
x24 = -x15
x25 = x11 * (x1 * x23 + x24) + x20 * x6
x26 = x10 * x22
x27 = 3.0 * x26
x28 = x20 * x5
x29 = x15 * x5
x30 = x29 * x6
x31 = x22 + x30
x32 = 4.0 * x12
x33 = x27 + 2.0 * x28 + x31 * x32
x34 = x2 * (x25 + x33)
x35 = x10 * x29
x36 = x19 * x29 + x35
x37 = x2 * (x20 + x36)
x38 = x19 * x31 + x26 + x28
x39 = x38 * x6
x40 = x2 * (x16 + x29)
x41 = x31 * x6
x42 = x40 + x41
x43 = x1 * x42 - x29
x44 = x11 * x43 + x37 + x39
x45 = x44 * x5
x46 = 3.0 * x22
x47 = 2.0 * x30
x48 = x46 + x47
x49 = x2 * (x21 + x48)
x50 = x42 * x5
x51 = x49 + x50
x52 = x18 * (2.0 * ax * x51 - x23)
x53 = x34 + x45 + x52
x54 = x5 * x53
x55 = x53 * x6
x56 = x38 * x5
x57 = x0 * x3
x58 = x31 * x5
x59 = x40 + x58
x60 = x0 * x59 - x16
x61 = x1 * x3
x62 = x2 * (4.0 * x37 + 2.0 * x39 + x43 * x57 + 2.0 * x56 + x60 * x61)
x63 = 2.0 * x58
x64 = 2.0 * x41
x65 = x2 * (4.0 * x40 + x63 + x64)
x66 = x51 * x6
x67 = x65 + x66
x68 = 2.0 * x40
x69 = x11 * (2.0 * bx * x67 - x63 - x68)
x70 = x5 * x51
x71 = x65 + x70
x72 = x18 * (2.0 * ax * x71 - x64 - x68)
x73 = x44 * x6
x74 = x42 * x6
x75 = x49 + x74
x76 = 2.0 * x22
x77 = x47 + x76
x78 = 2.0 * bx * x75 - x77
x79 = 3.0 * x45 + 3.0 * x52
x80 = x55 + x62 + x69
x81 = 2.0 * x74
x82 = 3.0 * x50
x83 = x2 * (5.0 * x49 + x81 + x82) + x5 * x67
x84 = (
-x18 * (-2.0 * ax * x83 + 2.0 * x49 + x81)
+ x2 * (5.0 * x34 + x57 * x78 + 2.0 * x73 + x79)
+ x5 * x80
)
x85 = 3.0 * x66
x86 = x2 * (6.0 * x65 + 3.0 * x70 + x85) + x5 * x83
x87 = numpy.exp(-x12 * (A[1] - B[1]) ** 2)
x88 = numpy.exp(-x12 * (A[2] - B[2]) ** 2)
x89 = 3.14159265358979324 * x3 * x88
x90 = x87 * x89
x91 = -x3 * (ax * A[1] + bx * B[1])
x92 = -x91 - A[1]
x93 = x92**2
x94 = -x7 - x9 * (x2 + x93)
x95 = x86 * x90
x96 = -x3 * (ax * A[2] + bx * B[2])
x97 = -x96 - A[2]
x98 = x97**2
x99 = -x7 - x9 * (x2 + x98)
x100 = da * db
x101 = 0.00952380952380952381 * x100
x102 = 2.64575131106459059 * x101
x103 = -x91 - B[1]
x104 = x14 * x87
x105 = x103 * x104
x106 = x105 * x94
x107 = x105 * x19 + x106
x108 = x15 * x8
x109 = x2 * (x108 + x48)
x110 = x5 * x59
x111 = 3.0 * x49 + x82
x112 = x2 * (2.0 * x109 + 2.0 * x110 + x111) + x5 * x71
x113 = x14 * x88
x114 = x36 * x5
x115 = x108 + x22
x116 = x18 * (x0 * x115 + x24)
x117 = x114 + x116
x118 = x2 * (x117 + x33)
x119 = x18 * x60
x120 = x119 + x37 + x56
x121 = x120 * x5
x122 = x109 + x110
x123 = 2.0 * ax * x122 - x77
x124 = x54 + x62 + x72
x125 = x90 * (
x124 * x5
+ x18 * (2.0 * ax * x112 - x111)
+ x2 * (2.0 * x118 + 2.0 * x121 + x123 * x61 + 3.0 * x34 + x79)
)
x126 = x112 * x90
x127 = 5.91607978309961604 * x101
x128 = -x96 - B[2]
x129 = x113 * x128
x130 = x129 * x99
x131 = x129 * x19 + x130
x132 = x104 * x2
x133 = x132 * x94
x134 = x103**2 * x104
x135 = x132 + x134
x136 = -x104
x137 = x103 * x107 + x11 * (x1 * x135 + x136)
x138 = x133 + x137
x139 = x5 * (x115 + x76)
x140 = 3.0 * x40 + 3.0 * x58
x141 = x122 * x5 + x2 * (x139 + x140)
x142 = x113 * x141
x143 = x117 + x26
x144 = x143 * x5 + x18 * (x0 * x139 - 2.0 * x29) + x2 * (x29 * x32 + 2.0 * x35)
x145 = x118 + x121 + x123 * x18
x146 = (
x145 * x5
+ x18 * (2.0 * ax * x141 - x140)
+ x2 * (3.0 * x119 + x144 + 3.0 * x37 + 3.0 * x56)
)
x147 = x128 * x90
x148 = 10.2469507659595984 * x101
x149 = x113 * x2
x150 = x149 * x99
x151 = x113 * x128**2
x152 = x149 + x151
x153 = -x113
x154 = x11 * (x1 * x152 + x153) + x128 * x131
x155 = x150 + x154
x156 = x104 * x141
x157 = 2.0 * x132
x158 = x103 * (x135 + x157)
x159 = x103 * x138 + x11 * (x1 * x158 - 2.0 * x105) + x2 * (x105 * x32 + 2.0 * x106)
x160 = 3.0 * x108 + x46
x161 = x139 * x5 + x160 * x2
x162 = x113 * x161
x163 = (
x144 * x5 + x18 * (2.0 * ax * x161 - x160) + x2 * (3.0 * x114 + 3.0 * x116 + x27)
)
x164 = 2.0 * x149
x165 = x128 * (x152 + x164)
x166 = x11 * (x1 * x165 - 2.0 * x129) + x128 * x155 + x2 * (x129 * x32 + 2.0 * x130)
x167 = x104 * x161
x168 = x104 * x92
x169 = x168 * x94
x170 = x168 * x19 + x169
x171 = x84 * x90
x172 = x83 * x90
x173 = 0.0666666666666666667 * x100
x174 = x107 * x92
x175 = x103 * x168
x176 = x132 + x175
x177 = x133 + x174 + x176 * x19
x178 = x113 * x71
x179 = 2.2360679774997897 * x173
x180 = x2 * (x105 + x168)
x181 = x103 * x176
x182 = x180 + x181
x183 = x113 * x182
x184 = x2 * (x107 + x170)
x185 = x103 * x177
x186 = x1 * x182 - x168
x187 = x11 * x186 + x184 + x185
x188 = 3.87298334620741689
x189 = x173 * x188
x190 = 3.0 * x132
x191 = 2.0 * x175
x192 = x190 + x191
x193 = x2 * (x134 + x192)
x194 = x103 * x182
x195 = x193 + x194
x196 = x113 * x195
x197 = 3.0 * x133
x198 = 2.0 * x174 + x176 * x32 + x197
x199 = x2 * (x137 + x198)
x200 = x103 * x187
x201 = x157 + x191
x202 = 2.0 * bx * x195 - x201
x203 = x11 * x202 + x199 + x200
x204 = x113 * x97
x205 = x204 * x99
x206 = x19 * x204 + x205
x207 = x90 * x97
x208 = x131 * x97
x209 = x128 * x204
x210 = x149 + x209
x211 = x150 + x19 * x210 + x208
x212 = x104 * x71
x213 = x2 * (x129 + x204)
x214 = x128 * x210
x215 = x213 + x214
x216 = x104 * x215
x217 = x2 * (x131 + x206)
x218 = x128 * x211
x219 = x1 * x215 - x204
x220 = x11 * x219 + x217 + x218
x221 = 3.0 * x149
x222 = 2.0 * x209
x223 = x221 + x222
x224 = x2 * (x151 + x223)
x225 = x128 * x215
x226 = x224 + x225
x227 = x104 * x226
x228 = 3.0 * x150
x229 = 2.0 * x208 + x210 * x32 + x228
x230 = x2 * (x154 + x229)
x231 = x128 * x220
x232 = x164 + x222
x233 = 2.0 * bx * x226 - x232
x234 = x11 * x233 + x230 + x231
x235 = x170 * x92
x236 = x104 * x93
x237 = x132 + x236
x238 = x18 * (x0 * x237 + x136)
x239 = x235 + x238
x240 = x133 + x239
x241 = x113 * x67
x242 = 0.0222222222222222222 * x100 * x188
x243 = x176 * x92
x244 = x180 + x243
x245 = x113 * x244
x246 = x177 * x92
x247 = x0 * x244 - x105
x248 = x18 * x247
x249 = x184 + x246 + x248
x250 = 1.73205080756887729
x251 = 0.111111111111111111 * x100 * x250
x252 = x187 * x92
x253 = x182 * x92
x254 = x193 + x253
x255 = x18 * (2.0 * ax * x254 - x135)
x256 = x199 + x252 + x255
x257 = x113 * x59
x258 = 0.333333333333333333 * x100
x259 = 2.0 * x243
x260 = 2.0 * x181
x261 = x2 * (4.0 * x180 + x259 + x260)
x262 = x103 * x254
x263 = x261 + x262
x264 = x113 * x263
x265 = x2 * (4.0 * x184 + 2.0 * x185 + x186 * x57 + 2.0 * x246 + x247 * x61)
x266 = x103 * x256
x267 = 2.0 * x180
x268 = x11 * (2.0 * bx * x263 - x259 - x267)
x269 = x265 + x266 + x268
x270 = x250 * x258
x271 = x206 * x97
x272 = x113 * x98
x273 = x149 + x272
x274 = x18 * (x0 * x273 + x153)
x275 = x271 + x274
x276 = x150 + x275
x277 = x104 * x67
x278 = x210 * x97
x279 = x213 + x278
x280 = x104 * x279
x281 = x211 * x97
x282 = x0 * x279 - x129
x283 = x18 * x282
x284 = x217 + x281 + x283
x285 = x220 * x97
x286 = x215 * x97
x287 = x224 + x286
x288 = x18 * (2.0 * ax * x287 - x152)
x289 = x230 + x285 + x288
x290 = x104 * x59
x291 = 2.0 * x278
x292 = 2.0 * x214
x293 = x2 * (4.0 * x213 + x291 + x292)
x294 = x128 * x287
x295 = x293 + x294
x296 = x104 * x295
x297 = x2 * (4.0 * x217 + 2.0 * x218 + x219 * x57 + 2.0 * x281 + x282 * x61)
x298 = x128 * x289
x299 = 2.0 * x213
x300 = x11 * (2.0 * bx * x295 - x291 - x299)
x301 = x297 + x298 + x300
x302 = x92 * (x157 + x237)
x303 = x18 * (x0 * x302 - 2.0 * x168) + x2 * (x168 * x32 + 2.0 * x169) + x240 * x92
x304 = x113 * x75
x305 = x11 * x78 + x34 + x73
x306 = x2 * (x198 + x239)
x307 = x249 * x92
x308 = x2 * (x192 + x236)
x309 = x244 * x92
x310 = x308 + x309
x311 = 2.0 * ax * x310 - x201
x312 = x18 * x311 + x306 + x307
x313 = x113 * x42
x314 = x254 * x92
x315 = x261 + x314
x316 = x113 * x315
x317 = x256 * x92
x318 = x18 * (2.0 * ax * x315 - x260 - x267)
x319 = x265 + x317 + x318
x320 = 2.0 * x194
x321 = 3.0 * x253
x322 = x2 * (5.0 * x193 + x320 + x321) + x263 * x92
x323 = 3.0 * x252 + 3.0 * x255
x324 = (
-x18 * (-2.0 * ax * x322 + 2.0 * x193 + x320)
+ x2 * (5.0 * x199 + 2.0 * x200 + x202 * x57 + x323)
+ x269 * x92
)
x325 = x13 * x89
x326 = x324 * x325
x327 = x325 * x5
x328 = 3.14159265358979324 * x13 * x3 * x87
x329 = x328 * x5
x330 = x97 * (x164 + x273)
x331 = x18 * (x0 * x330 - 2.0 * x204) + x2 * (x204 * x32 + 2.0 * x205) + x276 * x97
x332 = x104 * x75
x333 = x2 * (x229 + x275)
x334 = x284 * x97
x335 = x2 * (x223 + x272)
x336 = x279 * x97
x337 = x335 + x336
x338 = 2.0 * ax * x337 - x232
x339 = x18 * x338 + x333 + x334
x340 = x104 * x42
x341 = x287 * x97
x342 = x293 + x341
x343 = x104 * x342
x344 = x289 * x97
x345 = x18 * (2.0 * ax * x342 - x292 - x299)
x346 = x297 + x344 + x345
x347 = 2.0 * x225
x348 = 3.0 * x286
x349 = x2 * (5.0 * x224 + x347 + x348) + x295 * x97
x350 = 3.0 * x285 + 3.0 * x288
x351 = (
-x18 * (-2.0 * ax * x349 + 2.0 * x224 + x347)
+ x2 * (5.0 * x230 + 2.0 * x231 + x233 * x57 + x350)
+ x301 * x97
)
x352 = x328 * x351
x353 = x25 + x26
x354 = x6 * (x23 + x76)
x355 = x11 * (x1 * x354 - 2.0 * x16) + x2 * (x16 * x32 + 2.0 * x17) + x353 * x6
x356 = x190 + 3.0 * x236
x357 = x2 * x356 + x302 * x92
x358 = x113 * x357
x359 = (
x18 * (2.0 * ax * x357 - x356)
+ x2 * (x197 + 3.0 * x235 + 3.0 * x238)
+ x303 * x92
)
x360 = 3.0 * x180 + 3.0 * x243
x361 = x2 * (x302 + x360) + x310 * x92
x362 = x113 * x361
x363 = (
x18 * (2.0 * ax * x361 - x360)
+ x2 * (3.0 * x184 + 3.0 * x246 + 3.0 * x248 + x303)
+ x312 * x92
)
x364 = 3.0 * x193 + x321
x365 = x2 * (2.0 * x308 + 2.0 * x309 + x364) + x315 * x92
x366 = x325 * (
x18 * (2.0 * ax * x365 - x364)
+ x2 * (3.0 * x199 + 2.0 * x306 + 2.0 * x307 + x311 * x61 + x323)
+ x319 * x92
)
x367 = x325 * x6
x368 = 3.0 * x262
x369 = x2 * (6.0 * x261 + 3.0 * x314 + x368) + x322 * x92
x370 = x325 * x369
x371 = x10 * x325
x372 = x15 * x361
x373 = x15 * x357
x374 = x15 * x315
x375 = x15 * x215
x376 = x15 * x226
x377 = x15 * x263
x378 = x15 * x279
x379 = x15 * x244
x380 = x15 * x295
x381 = x328 * x92
x382 = x15 * x195
x383 = x15 * x182
x384 = x15 * x342
x385 = x221 + 3.0 * x272
x386 = x2 * x385 + x330 * x97
x387 = x104 * x386
x388 = (
x18 * (2.0 * ax * x386 - x385)
+ x2 * (x228 + 3.0 * x271 + 3.0 * x274)
+ x331 * x97
)
x389 = 3.0 * x213 + 3.0 * x278
x390 = x2 * (x330 + x389) + x337 * x97
x391 = x104 * x390
x392 = (
x18 * (2.0 * ax * x390 - x389)
+ x2 * (3.0 * x217 + 3.0 * x281 + 3.0 * x283 + x331)
+ x339 * x97
)
x393 = x328 * x6
x394 = 3.0 * x224 + x348
x395 = x2 * (2.0 * x335 + 2.0 * x336 + x394) + x342 * x97
x396 = x328 * (
x18 * (2.0 * ax * x395 - x394)
+ x2 * (3.0 * x230 + 2.0 * x333 + 2.0 * x334 + x338 * x61 + x350)
+ x346 * x97
)
x397 = x15 * x386
x398 = x15 * x390
x399 = 3.0 * x294
x400 = x2 * (6.0 * x293 + 3.0 * x341 + x399) + x349 * x97
x401 = x328 * x400
# 150 item(s)
result[0] += x102 * (
x90
* (
-x18 * (-2.0 * ax * x86 + 3.0 * x65 + x85)
+ 3.0 * x2 * (x54 + x55 + 2.0 * x62 + x69 + x72)
+ x5 * x84
)
+ x94 * x95
+ x95 * x99
)
result[1] += x127 * (x103 * x125 + x103 * x126 * x99 + x107 * x112 * x113)
result[2] += x127 * (x104 * x112 * x131 + x125 * x128 + x126 * x128 * x94)
result[3] += x127 * (x113 * x135 * x146 + x135 * x142 * x99 + x138 * x142)
result[4] += x148 * (x103 * x146 * x147 + x105 * x131 * x141 + x107 * x129 * x141)
result[5] += x127 * (x104 * x146 * x152 + x152 * x156 * x94 + x155 * x156)
result[6] += x102 * (x113 * x158 * x163 + x158 * x162 * x99 + x159 * x162)
result[7] += x127 * (x129 * x135 * x163 + x129 * x138 * x161 + x131 * x135 * x161)
result[8] += x127 * (x105 * x152 * x163 + x105 * x155 * x161 + x107 * x152 * x161)
result[9] += x102 * (x104 * x163 * x165 + x165 * x167 * x94 + x166 * x167)
result[10] += x173 * (x113 * x170 * x83 + x171 * x92 + x172 * x92 * x99)
result[11] += x179 * (x113 * x124 * x176 + x176 * x178 * x99 + x177 * x178)
result[12] += x179 * (x124 * x147 * x92 + x129 * x170 * x71 + x131 * x168 * x71)
result[13] += x179 * (x113 * x122 * x187 + x122 * x183 * x99 + x145 * x183)
result[14] += x189 * (x122 * x129 * x177 + x122 * x131 * x176 + x129 * x145 * x176)
result[15] += x179 * (x122 * x152 * x170 + x122 * x155 * x168 + x145 * x152 * x168)
result[16] += x173 * (x113 * x139 * x203 + x139 * x196 * x99 + x144 * x196)
result[17] += x179 * (x129 * x139 * x187 + x129 * x144 * x182 + x131 * x139 * x182)
result[18] += x179 * (x139 * x152 * x177 + x139 * x155 * x176 + x144 * x152 * x176)
result[19] += x173 * (x139 * x165 * x170 + x139 * x166 * x168 + x144 * x165 * x168)
result[20] += x173 * (x104 * x206 * x83 + x171 * x97 + x172 * x94 * x97)
result[21] += x179 * (x103 * x124 * x207 + x105 * x206 * x71 + x107 * x204 * x71)
result[22] += x179 * (x104 * x124 * x210 + x210 * x212 * x94 + x211 * x212)
result[23] += x179 * (x122 * x135 * x206 + x122 * x138 * x204 + x135 * x145 * x204)
result[24] += x189 * (x105 * x122 * x211 + x105 * x145 * x210 + x107 * x122 * x210)
result[25] += x179 * (x104 * x122 * x220 + x122 * x216 * x94 + x145 * x216)
result[26] += x173 * (x139 * x158 * x206 + x139 * x159 * x204 + x144 * x158 * x204)
result[27] += x179 * (x135 * x139 * x211 + x135 * x144 * x210 + x138 * x139 * x210)
result[28] += x179 * (x105 * x139 * x220 + x105 * x144 * x215 + x107 * x139 * x215)
result[29] += x173 * (x104 * x139 * x234 + x139 * x227 * x94 + x144 * x227)
result[30] += x242 * (x113 * x237 * x80 + x237 * x241 * x99 + x240 * x241)
result[31] += x251 * (x113 * x249 * x51 + x245 * x51 * x99 + x245 * x53)
result[32] += x251 * (x129 * x237 * x53 + x129 * x240 * x51 + x131 * x237 * x51)
result[33] += x251 * (x113 * x120 * x254 + x254 * x257 * x99 + x256 * x257)
result[34] += x258 * (x120 * x129 * x244 + x129 * x249 * x59 + x131 * x244 * x59)
result[35] += x251 * (x120 * x152 * x237 + x152 * x240 * x59 + x155 * x237 * x59)
result[36] += x242 * (x113 * x115 * x269 + x115 * x264 * x99 + x143 * x264)
result[37] += x251 * (x115 * x129 * x256 + x115 * x131 * x254 + x129 * x143 * x254)
result[38] += x251 * (x115 * x152 * x249 + x115 * x155 * x244 + x143 * x152 * x244)
result[39] += x242 * (x115 * x165 * x240 + x115 * x166 * x237 + x143 * x165 * x237)
result[40] += x179 * (x168 * x206 * x67 + x170 * x204 * x67 + x207 * x80 * x92)
result[41] += x258 * (x176 * x204 * x53 + x176 * x206 * x51 + x177 * x204 * x51)
result[42] += x258 * (x168 * x210 * x53 + x168 * x211 * x51 + x170 * x210 * x51)
result[43] += x258 * (x120 * x182 * x204 + x182 * x206 * x59 + x187 * x204 * x59)
result[44] += x270 * (x120 * x176 * x210 + x176 * x211 * x59 + x177 * x210 * x59)
result[45] += x258 * (x120 * x168 * x215 + x168 * x220 * x59 + x170 * x215 * x59)
result[46] += x179 * (x115 * x195 * x206 + x115 * x203 * x204 + x143 * x195 * x204)
result[47] += x258 * (x115 * x182 * x211 + x115 * x187 * x210 + x143 * x182 * x210)
result[48] += x258 * (x115 * x176 * x220 + x115 * x177 * x215 + x143 * x176 * x215)
result[49] += x179 * (x115 * x168 * x234 + x115 * x170 * x226 + x143 * x168 * x226)
result[50] += x242 * (x104 * x273 * x80 + x273 * x277 * x94 + x276 * x277)
result[51] += x251 * (x105 * x273 * x53 + x105 * x276 * x51 + x107 * x273 * x51)
result[52] += x251 * (x104 * x284 * x51 + x280 * x51 * x94 + x280 * x53)
result[53] += x251 * (x120 * x135 * x273 + x135 * x276 * x59 + x138 * x273 * x59)
result[54] += x258 * (x105 * x120 * x279 + x105 * x284 * x59 + x107 * x279 * x59)
result[55] += x251 * (x104 * x120 * x287 + x287 * x290 * x94 + x289 * x290)
result[56] += x242 * (x115 * x158 * x276 + x115 * x159 * x273 + x143 * x158 * x273)
result[57] += x251 * (x115 * x135 * x284 + x115 * x138 * x279 + x135 * x143 * x279)
result[58] += x251 * (x105 * x115 * x289 + x105 * x143 * x287 + x107 * x115 * x287)
result[59] += x242 * (x104 * x115 * x301 + x115 * x296 * x94 + x143 * x296)
result[60] += x173 * (x113 * x302 * x305 + x302 * x304 * x99 + x303 * x304)
result[61] += x179 * (x113 * x310 * x44 + x310 * x313 * x99 + x312 * x313)
result[62] += x179 * (x129 * x302 * x44 + x129 * x303 * x42 + x131 * x302 * x42)
result[63] += x179 * (x113 * x31 * x319 + x31 * x316 * x99 + x316 * x38)
result[64] += x189 * (x129 * x31 * x312 + x129 * x310 * x38 + x131 * x31 * x310)
result[65] += x179 * (x152 * x302 * x38 + x152 * x303 * x31 + x155 * x302 * x31)
result[66] += x173 * (x113 * x322 * x36 + x322 * x327 * x99 + x326 * x5)
result[67] += x179 * (x128 * x319 * x327 + x129 * x315 * x36 + x131 * x29 * x315)
result[68] += x179 * (x152 * x29 * x312 + x152 * x310 * x36 + x155 * x29 * x310)
result[69] += x173 * (x165 * x29 * x303 + x165 * x302 * x36 + x166 * x29 * x302)
result[70] += x179 * (x204 * x237 * x305 + x204 * x240 * x75 + x206 * x237 * x75)
result[71] += x258 * (x204 * x244 * x44 + x204 * x249 * x42 + x206 * x244 * x42)
result[72] += x258 * (x210 * x237 * x44 + x210 * x240 * x42 + x211 * x237 * x42)
result[73] += x258 * (x204 * x254 * x38 + x204 * x256 * x31 + x206 * x254 * x31)
result[74] += x270 * (x210 * x244 * x38 + x210 * x249 * x31 + x211 * x244 * x31)
result[75] += x258 * (x215 * x237 * x38 + x215 * x240 * x31 + x220 * x237 * x31)
result[76] += x179 * (x204 * x263 * x36 + x206 * x263 * x29 + x269 * x327 * x97)
result[77] += x258 * (x210 * x254 * x36 + x210 * x256 * x29 + x211 * x254 * x29)
result[78] += x258 * (x215 * x244 * x36 + x215 * x249 * x29 + x220 * x244 * x29)
result[79] += x179 * (x226 * x237 * x36 + x226 * x240 * x29 + x234 * x237 * x29)
result[80] += x179 * (x168 * x273 * x305 + x168 * x276 * x75 + x170 * x273 * x75)
result[81] += x258 * (x176 * x273 * x44 + x176 * x276 * x42 + x177 * x273 * x42)
result[82] += x258 * (x168 * x279 * x44 + x168 * x284 * x42 + x170 * x279 * x42)
result[83] += x258 * (x182 * x273 * x38 + x182 * x276 * x31 + x187 * x273 * x31)
result[84] += x270 * (x176 * x279 * x38 + x176 * x284 * x31 + x177 * x279 * x31)
result[85] += x258 * (x168 * x287 * x38 + x168 * x289 * x31 + x170 * x287 * x31)
result[86] += x179 * (x195 * x273 * x36 + x195 * x276 * x29 + x203 * x273 * x29)
result[87] += x258 * (x182 * x279 * x36 + x182 * x284 * x29 + x187 * x279 * x29)
result[88] += x258 * (x176 * x287 * x36 + x176 * x289 * x29 + x177 * x287 * x29)
result[89] += x179 * (x168 * x295 * x36 + x170 * x29 * x295 + x301 * x329 * x92)
result[90] += x173 * (x104 * x305 * x330 + x330 * x332 * x94 + x331 * x332)
result[91] += x179 * (x105 * x330 * x44 + x105 * x331 * x42 + x107 * x330 * x42)
result[92] += x179 * (x104 * x337 * x44 + x337 * x340 * x94 + x339 * x340)
result[93] += x179 * (x135 * x31 * x331 + x135 * x330 * x38 + x138 * x31 * x330)
result[94] += x189 * (x105 * x31 * x339 + x105 * x337 * x38 + x107 * x31 * x337)
result[95] += x179 * (x104 * x31 * x346 + x31 * x343 * x94 + x343 * x38)
result[96] += x173 * (x158 * x29 * x331 + x158 * x330 * x36 + x159 * x29 * x330)
result[97] += x179 * (x135 * x29 * x339 + x135 * x337 * x36 + x138 * x29 * x337)
result[98] += x179 * (x103 * x329 * x346 + x105 * x342 * x36 + x107 * x29 * x342)
result[99] += x173 * (x104 * x349 * x36 + x329 * x349 * x94 + x352 * x5)
result[100] += x102 * (x113 * x354 * x359 + x354 * x358 * x99 + x355 * x358)
result[101] += x127 * (x113 * x23 * x363 + x23 * x362 * x99 + x353 * x362)
result[102] += x127 * (x129 * x23 * x359 + x129 * x353 * x357 + x131 * x23 * x357)
result[103] += x127 * (x113 * x20 * x365 + x365 * x367 * x99 + x366 * x6)
result[104] += x148 * (x128 * x363 * x367 + x129 * x20 * x361 + x131 * x16 * x361)
result[105] += x127 * (x152 * x16 * x359 + x152 * x20 * x357 + x155 * x16 * x357)
result[106] += x102 * (
x10 * x370
+ x325
* (
-x18 * (-2.0 * ax * x369 + 3.0 * x261 + x368)
+ 3.0 * x2 * (2.0 * x265 + x266 + x268 + x317 + x318)
+ x324 * x92
)
+ x370 * x99
)
result[107] += x127 * (x128 * x365 * x371 + x128 * x366 + x131 * x15 * x365)
result[108] += x127 * (x10 * x152 * x372 + x15 * x152 * x363 + x155 * x372)
result[109] += x102 * (x10 * x165 * x373 + x15 * x165 * x359 + x166 * x373)
result[110] += x173 * (x204 * x302 * x355 + x204 * x303 * x354 + x206 * x302 * x354)
result[111] += x179 * (x204 * x23 * x312 + x204 * x310 * x353 + x206 * x23 * x310)
result[112] += x179 * (x210 * x23 * x303 + x210 * x302 * x353 + x211 * x23 * x302)
result[113] += x179 * (x16 * x206 * x315 + x20 * x204 * x315 + x319 * x367 * x97)
result[114] += x189 * (x16 * x210 * x312 + x16 * x211 * x310 + x20 * x210 * x310)
result[115] += x179 * (x16 * x215 * x303 + x16 * x220 * x302 + x20 * x215 * x302)
result[116] += x173 * (x15 * x206 * x322 + x322 * x371 * x97 + x326 * x97)
result[117] += x179 * (x10 * x210 * x374 + x15 * x210 * x319 + x211 * x374)
result[118] += x179 * (x10 * x310 * x375 + x15 * x220 * x310 + x312 * x375)
result[119] += x173 * (x10 * x302 * x376 + x15 * x234 * x302 + x303 * x376)
result[120] += x242 * (x237 * x273 * x355 + x237 * x276 * x354 + x240 * x273 * x354)
result[121] += x251 * (x23 * x244 * x276 + x23 * x249 * x273 + x244 * x273 * x353)
result[122] += x251 * (x23 * x237 * x284 + x23 * x240 * x279 + x237 * x279 * x353)
result[123] += x251 * (x16 * x254 * x276 + x16 * x256 * x273 + x20 * x254 * x273)
result[124] += x258 * (x16 * x244 * x284 + x16 * x249 * x279 + x20 * x244 * x279)
result[125] += x251 * (x16 * x237 * x289 + x16 * x240 * x287 + x20 * x237 * x287)
result[126] += x242 * (x10 * x273 * x377 + x15 * x269 * x273 + x276 * x377)
result[127] += x251 * (x10 * x254 * x378 + x15 * x254 * x284 + x256 * x378)
result[128] += x251 * (x10 * x287 * x379 + x15 * x249 * x287 + x289 * x379)
result[129] += x242 * (x10 * x237 * x380 + x15 * x237 * x301 + x240 * x380)
result[130] += x173 * (x168 * x330 * x355 + x168 * x331 * x354 + x170 * x330 * x354)
result[131] += x179 * (x176 * x23 * x331 + x176 * x330 * x353 + x177 * x23 * x330)
result[132] += x179 * (x168 * x23 * x339 + x168 * x337 * x353 + x170 * x23 * x337)
result[133] += x179 * (x16 * x182 * x331 + x16 * x187 * x330 + x182 * x20 * x330)
result[134] += x189 * (x16 * x176 * x339 + x16 * x177 * x337 + x176 * x20 * x337)
result[135] += x179 * (x16 * x170 * x342 + x168 * x20 * x342 + x346 * x381 * x6)
result[136] += x173 * (x10 * x330 * x382 + x15 * x203 * x330 + x331 * x382)
result[137] += x179 * (x10 * x337 * x383 + x15 * x187 * x337 + x339 * x383)
result[138] += x179 * (x10 * x176 * x384 + x15 * x176 * x346 + x177 * x384)
result[139] += x173 * (x10 * x349 * x381 + x15 * x170 * x349 + x352 * x92)
result[140] += x102 * (x104 * x354 * x388 + x354 * x387 * x94 + x355 * x387)
result[141] += x127 * (x105 * x23 * x388 + x105 * x353 * x386 + x107 * x23 * x386)
result[142] += x127 * (x104 * x23 * x392 + x23 * x391 * x94 + x353 * x391)
result[143] += x127 * (x135 * x16 * x388 + x135 * x20 * x386 + x138 * x16 * x386)
result[144] += x148 * (x103 * x392 * x393 + x105 * x20 * x390 + x107 * x16 * x390)
result[145] += x127 * (x104 * x20 * x395 + x393 * x395 * x94 + x396 * x6)
result[146] += x102 * (x10 * x158 * x397 + x15 * x158 * x388 + x159 * x397)
result[147] += x127 * (x10 * x135 * x398 + x135 * x15 * x392 + x138 * x398)
result[148] += x127 * (x10 * x103 * x328 * x395 + x103 * x396 + x107 * x15 * x395)
result[149] += x102 * (
x10 * x401
+ x328
* (
-x18 * (-2.0 * ax * x400 + 3.0 * x293 + x399)
+ 3.0 * x2 * (2.0 * x297 + x298 + x300 + x344 + x345)
+ x351 * x97
)
+ x401 * x94
)
[docs]
@numba.jit(
func_type.signature,
nopython=True,
nogil=True,
fastmath=True,
cache=True,
)
def kinetic3d_34(ax, da, A, bx, db, B, R, result):
"""See docstring of kinetic3d_43."""
# Call equivalent function and write to result
tmp = numpy.zeros_like(result)
kinetic3d_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 kinetic3d_44(ax, da, A, bx, db, B, R, result):
"""Cartesian 3D (gg) kinetic energy integral.
Generated code; DO NOT modify by hand!"""
x0 = 2.0 * ax
x1 = 2.0 * bx
x2 = (x0 + x1) ** (-1.0)
x3 = (ax + bx) ** (-1.0)
x4 = -x3 * (ax * A[0] + bx * B[0])
x5 = -x4 - B[0]
x6 = -x4 - A[0]
x7 = -ax
x8 = x6**2
x9 = 2.0 * ax**2
x10 = -x7 - x9 * (x2 + x8)
x11 = ax * x3
x12 = bx * x11
x13 = numpy.exp(-x12 * (A[0] - B[0]) ** 2)
x14 = 1.77245385090551603 * numpy.sqrt(x3)
x15 = x13 * x14
x16 = x15 * x5
x17 = x10 * x16
x18 = bx * x3
x19 = x0 * x18
x20 = x16 * x19 + x17
x21 = x20 * x6
x22 = x15 * x2
x23 = x15 * x6
x24 = x23 * x5
x25 = x22 + x24
x26 = x10 * x22
x27 = x19 * x25 + x21 + x26
x28 = x27 * x6
x29 = x27 * x5
x30 = x10 * x23
x31 = x19 * x23 + x30
x32 = x2 * (x20 + x31)
x33 = x2 * (x16 + x23)
x34 = x25 * x5
x35 = x33 + x34
x36 = x1 * x35 - x23
x37 = x0 * x3
x38 = x25 * x6
x39 = x33 + x38
x40 = x0 * x39 - x16
x41 = x1 * x3
x42 = x2 * (2.0 * x28 + 2.0 * x29 + 4.0 * x32 + x36 * x37 + x40 * x41)
x43 = x20 * x5
x44 = x15 * x5**2
x45 = x22 + x44
x46 = -x15
x47 = x11 * (x1 * x45 + x46)
x48 = x43 + x47
x49 = 3.0 * x26
x50 = 4.0 * x12
x51 = 2.0 * x21 + x25 * x50 + x49
x52 = x2 * (x48 + x51)
x53 = x11 * x36
x54 = x29 + x32 + x53
x55 = x54 * x6
x56 = 3.0 * x22
x57 = 2.0 * x24
x58 = x56 + x57
x59 = x2 * (x44 + x58)
x60 = x35 * x6
x61 = x59 + x60
x62 = x18 * (2.0 * ax * x61 - x45)
x63 = x52 + x55 + x62
x64 = x5 * x63
x65 = 2.0 * x38
x66 = 2.0 * x34
x67 = x2 * (4.0 * x33 + x65 + x66)
x68 = x5 * x61
x69 = x67 + x68
x70 = 2.0 * x33
x71 = x11 * (2.0 * bx * x69 - x65 - x70)
x72 = x42 + x64 + x71
x73 = x5 * x72
x74 = x6 * x72
x75 = x5 * x54
x76 = x35 * x5
x77 = x59 + x76
x78 = 2.0 * x22
x79 = x57 + x78
x80 = 2.0 * bx * x77 - x79
x81 = 3.0 * x55 + 3.0 * x62
x82 = x2 * (x37 * x80 + 5.0 * x52 + 2.0 * x75 + x81)
x83 = 2.0 * x76
x84 = 3.0 * x60
x85 = x2 * (5.0 * x59 + x83 + x84)
x86 = x5 * x69
x87 = x85 + x86
x88 = 3.0 * x59 + x84
x89 = x11 * (2.0 * bx * x87 - x88)
x90 = x6 * x69
x91 = x85 + x90
x92 = x18 * (2.0 * ax * x91 - 2.0 * x59 - x83)
x93 = x6 * x63
x94 = x6 * x61
x95 = x67 + x94
x96 = x18 * (2.0 * ax * x95 - x66 - x70)
x97 = 3.0 * x2 * (2.0 * x42 + x64 + x71 + x93 + x96)
x98 = x74 + x82 + x92
x99 = 3.0 * x94
x100 = 3.0 * x68
x101 = x2 * (x100 + 6.0 * x67 + x99)
x102 = x101 + x5 * x91
x103 = 3.0 * x67
x104 = -x11 * (-2.0 * bx * x102 + x103 + x99) + x5 * x98 + x97
x105 = 3.0 * x86
x106 = x102 * x6 + x2 * (x105 + 7.0 * x85 + 4.0 * x90)
x107 = numpy.exp(-x12 * (A[1] - B[1]) ** 2)
x108 = numpy.exp(-x12 * (A[2] - B[2]) ** 2)
x109 = 3.14159265358979324 * x108 * x3
x110 = x107 * x109
x111 = -x3 * (ax * A[1] + bx * B[1])
x112 = -x111 - A[1]
x113 = x112**2
x114 = -x7 - x9 * (x113 + x2)
x115 = x106 * x110
x116 = -x3 * (ax * A[2] + bx * B[2])
x117 = -x116 - A[2]
x118 = x117**2
x119 = -x7 - x9 * (x118 + x2)
x120 = da * db
x121 = 0.00952380952380952381 * x120
x122 = -x111 - B[1]
x123 = x107 * x14
x124 = x122 * x123
x125 = x114 * x124
x126 = x124 * x19 + x125
x127 = x101 + x6 * x91
x128 = x108 * x14
x129 = x110 * (-x18 * (-2.0 * ax * x127 + x100 + x103) + x6 * x98 + x97)
x130 = x110 * x127
x131 = 2.64575131106459059 * x121
x132 = -x116 - B[2]
x133 = x128 * x132
x134 = x119 * x133
x135 = x133 * x19 + x134
x136 = x123 * x2
x137 = x114 * x136
x138 = x122 * x126
x139 = x122**2 * x123
x140 = x136 + x139
x141 = -x123
x142 = x11 * (x1 * x140 + x141)
x143 = x138 + x142
x144 = x137 + x143
x145 = x15 * x8
x146 = x2 * (x145 + x58)
x147 = x39 * x6
x148 = x2 * (2.0 * x146 + 2.0 * x147 + x88) + x6 * x95
x149 = x128 * x148
x150 = x31 * x6
x151 = x145 + x22
x152 = x18 * (x0 * x151 + x46)
x153 = x150 + x152
x154 = x2 * (x153 + x51)
x155 = x18 * x40
x156 = x155 + x28 + x32
x157 = x156 * x6
x158 = x146 + x147
x159 = 2.0 * ax * x158 - x79
x160 = x42 + x93 + x96
x161 = (
x160 * x6
+ x18 * (2.0 * ax * x148 - x88)
+ x2 * (2.0 * x154 + 2.0 * x157 + x159 * x41 + 3.0 * x52 + x81)
)
x162 = 0.0325300024316177726 * x120
x163 = x110 * x132
x164 = 5.91607978309961604 * x121
x165 = x128 * x2
x166 = x119 * x165
x167 = x132 * x135
x168 = x128 * x132**2
x169 = x165 + x168
x170 = -x128
x171 = x11 * (x1 * x169 + x170)
x172 = x167 + x171
x173 = x166 + x172
x174 = x123 * x148
x175 = 2.0 * x136
x176 = x122 * (x140 + x175)
x177 = x11 * (x1 * x176 - 2.0 * x124) + x122 * x144 + x2 * (x124 * x50 + 2.0 * x125)
x178 = x6 * (x151 + x78)
x179 = 3.0 * x33
x180 = x179 + 3.0 * x38
x181 = x158 * x6 + x2 * (x178 + x180)
x182 = x128 * x181
x183 = 3.0 * x32
x184 = x153 + x26
x185 = x18 * (x0 * x178 - 2.0 * x23) + x184 * x6 + x2 * (x23 * x50 + 2.0 * x30)
x186 = x154 + x157 + x159 * x18
x187 = (
x18 * (2.0 * ax * x181 - x180)
+ x186 * x6
+ x2 * (3.0 * x155 + x183 + x185 + 3.0 * x28)
)
x188 = 2.0 * x165
x189 = x132 * (x169 + x188)
x190 = x11 * (x1 * x189 - 2.0 * x133) + x132 * x173 + x2 * (x133 * x50 + 2.0 * x134)
x191 = x123 * x181
x192 = 3.0 * x137
x193 = 3.0 * x136
x194 = 3.0 * x139 + x193
x195 = x122 * x176 + x194 * x2
x196 = (
x11 * (2.0 * bx * x195 - x194)
+ x122 * x177
+ x2 * (3.0 * x138 + 3.0 * x142 + x192)
)
x197 = 3.0 * x145 + x56
x198 = x178 * x6 + x197 * x2
x199 = x128 * x198
x200 = (
x18 * (2.0 * ax * x198 - x197) + x185 * x6 + x2 * (3.0 * x150 + 3.0 * x152 + x49)
)
x201 = 3.0 * x166
x202 = 3.0 * x165
x203 = 3.0 * x168 + x202
x204 = x132 * x189 + x2 * x203
x205 = (
x11 * (2.0 * bx * x204 - x203)
+ x132 * x190
+ x2 * (3.0 * x167 + 3.0 * x171 + x201)
)
x206 = x123 * x198
x207 = x112 * x123
x208 = x114 * x207
x209 = x19 * x207 + x208
x210 = x104 * x110
x211 = x102 * x110
x212 = x112 * x126
x213 = x122 * x207
x214 = x136 + x213
x215 = x137 + x19 * x214 + x212
x216 = x128 * x91
x217 = 0.0666666666666666667 * x120
x218 = x2 * (x124 + x207)
x219 = x122 * x214
x220 = x218 + x219
x221 = x128 * x220
x222 = x2 * (x126 + x209)
x223 = x122 * x215
x224 = x1 * x220 - x207
x225 = x11 * x224
x226 = x222 + x223 + x225
x227 = 0.0860662965823870419 * x120
x228 = 2.2360679774997897 * x217
x229 = x192 + 2.0 * x212 + x214 * x50
x230 = x2 * (x143 + x229)
x231 = x122 * x226
x232 = 2.0 * x213
x233 = x193 + x232
x234 = x2 * (x139 + x233)
x235 = x122 * x220
x236 = x234 + x235
x237 = x175 + x232
x238 = 2.0 * bx * x236 - x237
x239 = x11 * x238 + x230 + x231
x240 = x128 * x158
x241 = 3.0 * x218
x242 = 3.0 * x219 + x241
x243 = x122 * x236 + x2 * (x176 + x242)
x244 = x128 * x243
x245 = 3.0 * x222
x246 = (
x11 * (2.0 * bx * x243 - x242)
+ x122 * x239
+ x2 * (x177 + 3.0 * x223 + 3.0 * x225 + x245)
)
x247 = x117 * x128
x248 = x119 * x247
x249 = x19 * x247 + x248
x250 = x110 * x117
x251 = x117 * x135
x252 = x132 * x247
x253 = x165 + x252
x254 = x166 + x19 * x253 + x251
x255 = x123 * x91
x256 = x2 * (x133 + x247)
x257 = x132 * x253
x258 = x256 + x257
x259 = x123 * x258
x260 = x2 * (x135 + x249)
x261 = x132 * x254
x262 = x1 * x258 - x247
x263 = x11 * x262
x264 = x260 + x261 + x263
x265 = x201 + 2.0 * x251 + x253 * x50
x266 = x2 * (x172 + x265)
x267 = x132 * x264
x268 = 2.0 * x252
x269 = x202 + x268
x270 = x2 * (x168 + x269)
x271 = x132 * x258
x272 = x270 + x271
x273 = x188 + x268
x274 = 2.0 * bx * x272 - x273
x275 = x11 * x274 + x266 + x267
x276 = x123 * x158
x277 = 3.0 * x256
x278 = 3.0 * x257 + x277
x279 = x132 * x272 + x2 * (x189 + x278)
x280 = x123 * x279
x281 = 3.0 * x260
x282 = (
x11 * (2.0 * bx * x279 - x278)
+ x132 * x275
+ x2 * (x190 + 3.0 * x261 + 3.0 * x263 + x281)
)
x283 = x112 * x209
x284 = x113 * x123
x285 = x136 + x284
x286 = x18 * (x0 * x285 + x141)
x287 = x283 + x286
x288 = x137 + x287
x289 = x128 * x87
x290 = x73 + x82 + x89
x291 = x112 * x214
x292 = x218 + x291
x293 = x128 * x292
x294 = x112 * x215
x295 = x0 * x292 - x124
x296 = x18 * x295
x297 = x222 + x294 + x296
x298 = x112 * x226
x299 = x112 * x220
x300 = x234 + x299
x301 = x18 * (2.0 * ax * x300 - x140)
x302 = x230 + x298 + x301
x303 = x128 * x61
x304 = 0.111111111111111111 * x120
x305 = 1.73205080756887729 * x304
x306 = x2 * (4.0 * x222 + 2.0 * x223 + x224 * x37 + 2.0 * x294 + x295 * x41)
x307 = x122 * x302
x308 = 2.0 * x291
x309 = 2.0 * x219
x310 = x2 * (4.0 * x218 + x308 + x309)
x311 = x122 * x300
x312 = x310 + x311
x313 = 2.0 * x218
x314 = x11 * (2.0 * bx * x312 - x308 - x313)
x315 = x306 + x307 + x314
x316 = x128 * x39
x317 = 2.0 * x235
x318 = 3.0 * x299
x319 = x2 * (5.0 * x234 + x317 + x318)
x320 = x122 * x312
x321 = x319 + x320
x322 = x128 * x321
x323 = 3.0 * x298 + 3.0 * x301
x324 = x2 * (5.0 * x230 + 2.0 * x231 + x238 * x37 + x323)
x325 = x122 * x315
x326 = 3.0 * x234 + x318
x327 = x11 * (2.0 * bx * x321 - x326)
x328 = x324 + x325 + x327
x329 = 0.333333333333333333 * x120
x330 = x117 * x249
x331 = x118 * x128
x332 = x165 + x331
x333 = x18 * (x0 * x332 + x170)
x334 = x330 + x333
x335 = x166 + x334
x336 = x123 * x87
x337 = x117 * x253
x338 = x256 + x337
x339 = x123 * x338
x340 = x117 * x254
x341 = x0 * x338 - x133
x342 = x18 * x341
x343 = x260 + x340 + x342
x344 = x117 * x264
x345 = x117 * x258
x346 = x270 + x345
x347 = x18 * (2.0 * ax * x346 - x169)
x348 = x266 + x344 + x347
x349 = x123 * x61
x350 = x2 * (4.0 * x260 + 2.0 * x261 + x262 * x37 + 2.0 * x340 + x341 * x41)
x351 = x132 * x348
x352 = 2.0 * x337
x353 = 2.0 * x257
x354 = x2 * (4.0 * x256 + x352 + x353)
x355 = x132 * x346
x356 = x354 + x355
x357 = 2.0 * x256
x358 = x11 * (2.0 * bx * x356 - x352 - x357)
x359 = x350 + x351 + x358
x360 = x123 * x39
x361 = 2.0 * x271
x362 = 3.0 * x345
x363 = x2 * (5.0 * x270 + x361 + x362)
x364 = x132 * x356
x365 = x363 + x364
x366 = x123 * x365
x367 = 3.0 * x344 + 3.0 * x347
x368 = x2 * (5.0 * x266 + 2.0 * x267 + x274 * x37 + x367)
x369 = x132 * x359
x370 = 3.0 * x270 + x362
x371 = x11 * (2.0 * bx * x365 - x370)
x372 = x368 + x369 + x371
x373 = x112 * (x175 + x285)
x374 = x112 * x288 + x18 * (x0 * x373 - 2.0 * x207) + x2 * (x207 * x50 + 2.0 * x208)
x375 = x5 * (x45 + x78)
x376 = x179 + 3.0 * x34
x377 = x2 * (x375 + x376) + x5 * x77
x378 = x128 * x377
x379 = x26 + x48
x380 = x11 * (x1 * x375 - 2.0 * x16) + x2 * (x16 * x50 + 2.0 * x17) + x379 * x5
x381 = x11 * x80 + x52 + x75
x382 = (
x11 * (2.0 * bx * x377 - x376)
+ x2 * (x183 + 3.0 * x29 + x380 + 3.0 * x53)
+ x381 * x5
)
x383 = x2 * (x233 + x284)
x384 = x112 * x292
x385 = x383 + x384
x386 = x128 * x385
x387 = x2 * (x229 + x287)
x388 = x112 * x297
x389 = 2.0 * ax * x385 - x237
x390 = x18 * x389 + x387 + x388
x391 = x112 * x302
x392 = x112 * x300
x393 = x310 + x392
x394 = x18 * (2.0 * ax * x393 - x309 - x313)
x395 = x306 + x391 + x394
x396 = x128 * x35
x397 = x112 * x312
x398 = x319 + x397
x399 = x128 * x398
x400 = x112 * x315
x401 = x18 * (2.0 * ax * x398 - 2.0 * x234 - x317)
x402 = x324 + x400 + x401
x403 = 3.0 * x392
x404 = 3.0 * x311
x405 = x2 * (6.0 * x310 + x403 + x404)
x406 = x122 * x398 + x405
x407 = 3.0 * x2 * (2.0 * x306 + x307 + x314 + x391 + x394)
x408 = 3.0 * x310
x409 = -x11 * (-2.0 * bx * x406 + x403 + x408) + x122 * x402 + x407
x410 = x109 * x13
x411 = x409 * x410
x412 = x410 * x6
x413 = 3.14159265358979324 * x107 * x13 * x3
x414 = x413 * x6
x415 = x117 * (x188 + x332)
x416 = x117 * x335 + x18 * (x0 * x415 - 2.0 * x247) + x2 * (x247 * x50 + 2.0 * x248)
x417 = x123 * x377
x418 = x2 * (x269 + x331)
x419 = x117 * x338
x420 = x418 + x419
x421 = x123 * x420
x422 = x2 * (x265 + x334)
x423 = x117 * x343
x424 = 2.0 * ax * x420 - x273
x425 = x18 * x424 + x422 + x423
x426 = x117 * x348
x427 = x117 * x346
x428 = x354 + x427
x429 = x18 * (2.0 * ax * x428 - x353 - x357)
x430 = x350 + x426 + x429
x431 = x123 * x35
x432 = x117 * x356
x433 = x363 + x432
x434 = x123 * x433
x435 = x117 * x359
x436 = x18 * (2.0 * ax * x433 - 2.0 * x270 - x361)
x437 = x368 + x435 + x436
x438 = 3.0 * x427
x439 = 3.0 * x355
x440 = x2 * (6.0 * x354 + x438 + x439)
x441 = x132 * x433 + x440
x442 = 3.0 * x2 * (2.0 * x350 + x351 + x358 + x426 + x429)
x443 = 3.0 * x354
x444 = -x11 * (-2.0 * bx * x441 + x438 + x443) + x132 * x437 + x442
x445 = x413 * x444
x446 = 3.0 * x44 + x56
x447 = x2 * x446 + x375 * x5
x448 = x11 * (2.0 * bx * x447 - x446) + x2 * (3.0 * x43 + 3.0 * x47 + x49) + x380 * x5
x449 = x193 + 3.0 * x284
x450 = x112 * x373 + x2 * x449
x451 = x128 * x450
x452 = (
x112 * x374
+ x18 * (2.0 * ax * x450 - x449)
+ x2 * (x192 + 3.0 * x283 + 3.0 * x286)
)
x453 = x241 + 3.0 * x291
x454 = x112 * x385 + x2 * (x373 + x453)
x455 = x128 * x454
x456 = (
x112 * x390
+ x18 * (2.0 * ax * x454 - x453)
+ x2 * (x245 + 3.0 * x294 + 3.0 * x296 + x374)
)
x457 = x112 * x393 + x2 * (x326 + 2.0 * x383 + 2.0 * x384)
x458 = x128 * x457
x459 = (
x112 * x395
+ x18 * (2.0 * ax * x457 - x326)
+ x2 * (3.0 * x230 + x323 + 2.0 * x387 + 2.0 * x388 + x389 * x41)
)
x460 = x112 * x398 + x405
x461 = x410 * (x112 * x402 - x18 * (-2.0 * ax * x460 + x404 + x408) + x407)
x462 = x410 * x5
x463 = 3.0 * x320
x464 = x112 * x406 + x2 * (7.0 * x319 + 4.0 * x397 + x463)
x465 = x410 * x464
x466 = x10 * x410
x467 = x15 * x457
x468 = x15 * x454
x469 = x15 * x450
x470 = x15 * x398
x471 = x15 * x258
x472 = x15 * x385
x473 = x15 * x279
x474 = x15 * x321
x475 = x15 * x338
x476 = x15 * x300
x477 = x15 * x292
x478 = x15 * x365
x479 = x112 * x413
x480 = x15 * x243
x481 = x15 * x420
x482 = x15 * x220
x483 = x15 * x433
x484 = x202 + 3.0 * x331
x485 = x117 * x415 + x2 * x484
x486 = x123 * x485
x487 = (
x117 * x416
+ x18 * (2.0 * ax * x485 - x484)
+ x2 * (x201 + 3.0 * x330 + 3.0 * x333)
)
x488 = x277 + 3.0 * x337
x489 = x117 * x420 + x2 * (x415 + x488)
x490 = x123 * x489
x491 = (
x117 * x425
+ x18 * (2.0 * ax * x489 - x488)
+ x2 * (x281 + 3.0 * x340 + 3.0 * x342 + x416)
)
x492 = x117 * x428 + x2 * (x370 + 2.0 * x418 + 2.0 * x419)
x493 = x123 * x492
x494 = (
x117 * x430
+ x18 * (2.0 * ax * x492 - x370)
+ x2 * (3.0 * x266 + x367 + x41 * x424 + 2.0 * x422 + 2.0 * x423)
)
x495 = x413 * x5
x496 = x117 * x433 + x440
x497 = x413 * (x117 * x437 - x18 * (-2.0 * ax * x496 + x439 + x443) + x442)
x498 = x15 * x485
x499 = x15 * x489
x500 = x15 * x492
x501 = 3.0 * x364
x502 = x117 * x441 + x2 * (7.0 * x363 + 4.0 * x432 + x501)
x503 = x413 * x502
# 225 item(s)
result[0] += x121 * (
x110
* (
x104 * x6
- x18 * (-2.0 * ax * x106 + x105 + 3.0 * x85)
+ x2 * (3.0 * x73 + 4.0 * x74 + 7.0 * x82 + 3.0 * x89 + 4.0 * x92)
)
+ x114 * x115
+ x115 * x119
)
result[1] += x131 * (x119 * x122 * x130 + x122 * x129 + x126 * x127 * x128)
result[2] += x131 * (x114 * x130 * x132 + x123 * x127 * x135 + x129 * x132)
result[3] += x162 * (x119 * x140 * x149 + x128 * x140 * x161 + x144 * x149)
result[4] += x164 * (x122 * x161 * x163 + x124 * x135 * x148 + x126 * x133 * x148)
result[5] += x162 * (x114 * x169 * x174 + x123 * x161 * x169 + x173 * x174)
result[6] += x131 * (x119 * x176 * x182 + x128 * x176 * x187 + x177 * x182)
result[7] += x164 * (x133 * x140 * x187 + x133 * x144 * x181 + x135 * x140 * x181)
result[8] += x164 * (x124 * x169 * x187 + x124 * x173 * x181 + x126 * x169 * x181)
result[9] += x131 * (x114 * x189 * x191 + x123 * x187 * x189 + x190 * x191)
result[10] += x121 * (x119 * x195 * x199 + x128 * x195 * x200 + x196 * x199)
result[11] += x131 * (x133 * x176 * x200 + x133 * x177 * x198 + x135 * x176 * x198)
result[12] += x162 * (x140 * x169 * x200 + x140 * x173 * x198 + x144 * x169 * x198)
result[13] += x131 * (x124 * x189 * x200 + x124 * x190 * x198 + x126 * x189 * x198)
result[14] += x121 * (x114 * x204 * x206 + x123 * x200 * x204 + x205 * x206)
result[15] += x131 * (x102 * x128 * x209 + x112 * x119 * x211 + x112 * x210)
result[16] += x217 * (x119 * x214 * x216 + x128 * x214 * x98 + x215 * x216)
result[17] += x217 * (x112 * x163 * x98 + x133 * x209 * x91 + x135 * x207 * x91)
result[18] += x227 * (x119 * x221 * x95 + x128 * x226 * x95 + x160 * x221)
result[19] += x228 * (x133 * x160 * x214 + x133 * x215 * x95 + x135 * x214 * x95)
result[20] += x227 * (x160 * x169 * x207 + x169 * x209 * x95 + x173 * x207 * x95)
result[21] += x217 * (x119 * x236 * x240 + x128 * x186 * x236 + x239 * x240)
result[22] += x228 * (x133 * x158 * x226 + x133 * x186 * x220 + x135 * x158 * x220)
result[23] += x228 * (x158 * x169 * x215 + x158 * x173 * x214 + x169 * x186 * x214)
result[24] += x217 * (x158 * x189 * x209 + x158 * x190 * x207 + x186 * x189 * x207)
result[25] += x131 * (x119 * x178 * x244 + x128 * x178 * x246 + x185 * x244)
result[26] += x217 * (x133 * x178 * x239 + x133 * x185 * x236 + x135 * x178 * x236)
result[27] += x227 * (x169 * x178 * x226 + x169 * x185 * x220 + x173 * x178 * x220)
result[28] += x217 * (x178 * x189 * x215 + x178 * x190 * x214 + x185 * x189 * x214)
result[29] += x131 * (x178 * x204 * x209 + x178 * x205 * x207 + x185 * x204 * x207)
result[30] += x131 * (x102 * x123 * x249 + x114 * x117 * x211 + x117 * x210)
result[31] += x217 * (x122 * x250 * x98 + x124 * x249 * x91 + x126 * x247 * x91)
result[32] += x217 * (x114 * x253 * x255 + x123 * x253 * x98 + x254 * x255)
result[33] += x227 * (x140 * x160 * x247 + x140 * x249 * x95 + x144 * x247 * x95)
result[34] += x228 * (x124 * x160 * x253 + x124 * x254 * x95 + x126 * x253 * x95)
result[35] += x227 * (x114 * x259 * x95 + x123 * x264 * x95 + x160 * x259)
result[36] += x217 * (x158 * x176 * x249 + x158 * x177 * x247 + x176 * x186 * x247)
result[37] += x228 * (x140 * x158 * x254 + x140 * x186 * x253 + x144 * x158 * x253)
result[38] += x228 * (x124 * x158 * x264 + x124 * x186 * x258 + x126 * x158 * x258)
result[39] += x217 * (x114 * x272 * x276 + x123 * x186 * x272 + x275 * x276)
result[40] += x131 * (x178 * x195 * x249 + x178 * x196 * x247 + x185 * x195 * x247)
result[41] += x217 * (x176 * x178 * x254 + x176 * x185 * x253 + x177 * x178 * x253)
result[42] += x227 * (x140 * x178 * x264 + x140 * x185 * x258 + x144 * x178 * x258)
result[43] += x217 * (x124 * x178 * x275 + x124 * x185 * x272 + x126 * x178 * x272)
result[44] += x131 * (x114 * x178 * x280 + x123 * x178 * x282 + x185 * x280)
result[45] += x162 * (x119 * x285 * x289 + x128 * x285 * x290 + x288 * x289)
result[46] += x227 * (x119 * x293 * x69 + x128 * x297 * x69 + x293 * x72)
result[47] += x227 * (x133 * x285 * x72 + x133 * x288 * x69 + x135 * x285 * x69)
result[48] += x304 * (x119 * x300 * x303 + x128 * x300 * x63 + x302 * x303)
result[49] += x305 * (x133 * x292 * x63 + x133 * x297 * x61 + x135 * x292 * x61)
result[50] += x304 * (x169 * x285 * x63 + x169 * x288 * x61 + x173 * x285 * x61)
result[51] += x227 * (x119 * x312 * x316 + x128 * x156 * x312 + x315 * x316)
result[52] += x305 * (x133 * x156 * x300 + x133 * x302 * x39 + x135 * x300 * x39)
result[53] += x305 * (x156 * x169 * x292 + x169 * x297 * x39 + x173 * x292 * x39)
result[54] += x227 * (x156 * x189 * x285 + x189 * x288 * x39 + x190 * x285 * x39)
result[55] += x162 * (x119 * x151 * x322 + x128 * x151 * x328 + x184 * x322)
result[56] += x227 * (x133 * x151 * x315 + x133 * x184 * x312 + x135 * x151 * x312)
result[57] += x304 * (x151 * x169 * x302 + x151 * x173 * x300 + x169 * x184 * x300)
result[58] += x227 * (x151 * x189 * x297 + x151 * x190 * x292 + x184 * x189 * x292)
result[59] += x162 * (x151 * x204 * x288 + x151 * x205 * x285 + x184 * x204 * x285)
result[60] += x164 * (x112 * x250 * x290 + x207 * x249 * x87 + x209 * x247 * x87)
result[61] += x228 * (x214 * x247 * x72 + x214 * x249 * x69 + x215 * x247 * x69)
result[62] += x228 * (x207 * x253 * x72 + x207 * x254 * x69 + x209 * x253 * x69)
result[63] += x305 * (x220 * x247 * x63 + x220 * x249 * x61 + x226 * x247 * x61)
result[64] += x329 * (x214 * x253 * x63 + x214 * x254 * x61 + x215 * x253 * x61)
result[65] += x305 * (x207 * x258 * x63 + x207 * x264 * x61 + x209 * x258 * x61)
result[66] += x228 * (x156 * x236 * x247 + x236 * x249 * x39 + x239 * x247 * x39)
result[67] += x329 * (x156 * x220 * x253 + x220 * x254 * x39 + x226 * x253 * x39)
result[68] += x329 * (x156 * x214 * x258 + x214 * x264 * x39 + x215 * x258 * x39)
result[69] += x228 * (x156 * x207 * x272 + x207 * x275 * x39 + x209 * x272 * x39)
result[70] += x164 * (x151 * x243 * x249 + x151 * x246 * x247 + x184 * x243 * x247)
result[71] += x228 * (x151 * x236 * x254 + x151 * x239 * x253 + x184 * x236 * x253)
result[72] += x305 * (x151 * x220 * x264 + x151 * x226 * x258 + x184 * x220 * x258)
result[73] += x228 * (x151 * x214 * x275 + x151 * x215 * x272 + x184 * x214 * x272)
result[74] += x164 * (x151 * x207 * x282 + x151 * x209 * x279 + x184 * x207 * x279)
result[75] += x162 * (x114 * x332 * x336 + x123 * x290 * x332 + x335 * x336)
result[76] += x227 * (x124 * x332 * x72 + x124 * x335 * x69 + x126 * x332 * x69)
result[77] += x227 * (x114 * x339 * x69 + x123 * x343 * x69 + x339 * x72)
result[78] += x304 * (x140 * x332 * x63 + x140 * x335 * x61 + x144 * x332 * x61)
result[79] += x305 * (x124 * x338 * x63 + x124 * x343 * x61 + x126 * x338 * x61)
result[80] += x304 * (x114 * x346 * x349 + x123 * x346 * x63 + x348 * x349)
result[81] += x227 * (x156 * x176 * x332 + x176 * x335 * x39 + x177 * x332 * x39)
result[82] += x305 * (x140 * x156 * x338 + x140 * x343 * x39 + x144 * x338 * x39)
result[83] += x305 * (x124 * x156 * x346 + x124 * x348 * x39 + x126 * x346 * x39)
result[84] += x227 * (x114 * x356 * x360 + x123 * x156 * x356 + x359 * x360)
result[85] += x162 * (x151 * x195 * x335 + x151 * x196 * x332 + x184 * x195 * x332)
result[86] += x227 * (x151 * x176 * x343 + x151 * x177 * x338 + x176 * x184 * x338)
result[87] += x304 * (x140 * x151 * x348 + x140 * x184 * x346 + x144 * x151 * x346)
result[88] += x227 * (x124 * x151 * x359 + x124 * x184 * x356 + x126 * x151 * x356)
result[89] += x162 * (x114 * x151 * x366 + x123 * x151 * x372 + x184 * x366)
result[90] += x131 * (x119 * x373 * x378 + x128 * x373 * x382 + x374 * x378)
result[91] += x217 * (x119 * x386 * x77 + x128 * x390 * x77 + x381 * x386)
result[92] += x217 * (x133 * x373 * x381 + x133 * x374 * x77 + x135 * x373 * x77)
result[93] += x227 * (x119 * x393 * x396 + x128 * x393 * x54 + x395 * x396)
result[94] += x228 * (x133 * x35 * x390 + x133 * x385 * x54 + x135 * x35 * x385)
result[95] += x227 * (x169 * x35 * x374 + x169 * x373 * x54 + x173 * x35 * x373)
result[96] += x217 * (x119 * x25 * x399 + x128 * x25 * x402 + x27 * x399)
result[97] += x228 * (x133 * x25 * x395 + x133 * x27 * x393 + x135 * x25 * x393)
result[98] += x228 * (x169 * x25 * x390 + x169 * x27 * x385 + x173 * x25 * x385)
result[99] += x217 * (x189 * x25 * x374 + x189 * x27 * x373 + x190 * x25 * x373)
result[100] += x131 * (x119 * x406 * x412 + x128 * x31 * x406 + x411 * x6)
result[101] += x217 * (x132 * x402 * x412 + x133 * x31 * x398 + x135 * x23 * x398)
result[102] += x227 * (x169 * x23 * x395 + x169 * x31 * x393 + x173 * x23 * x393)
result[103] += x217 * (x189 * x23 * x390 + x189 * x31 * x385 + x190 * x23 * x385)
result[104] += x131 * (x204 * x23 * x374 + x204 * x31 * x373 + x205 * x23 * x373)
result[105] += x164 * (x247 * x285 * x382 + x247 * x288 * x377 + x249 * x285 * x377)
result[106] += x228 * (x247 * x292 * x381 + x247 * x297 * x77 + x249 * x292 * x77)
result[107] += x228 * (x253 * x285 * x381 + x253 * x288 * x77 + x254 * x285 * x77)
result[108] += x305 * (x247 * x300 * x54 + x247 * x302 * x35 + x249 * x300 * x35)
result[109] += x329 * (x253 * x292 * x54 + x253 * x297 * x35 + x254 * x292 * x35)
result[110] += x305 * (x258 * x285 * x54 + x258 * x288 * x35 + x264 * x285 * x35)
result[111] += x228 * (x247 * x25 * x315 + x247 * x27 * x312 + x249 * x25 * x312)
result[112] += x329 * (x25 * x253 * x302 + x25 * x254 * x300 + x253 * x27 * x300)
result[113] += x329 * (x25 * x258 * x297 + x25 * x264 * x292 + x258 * x27 * x292)
result[114] += x228 * (x25 * x272 * x288 + x25 * x275 * x285 + x27 * x272 * x285)
result[115] += x164 * (x117 * x328 * x412 + x23 * x249 * x321 + x247 * x31 * x321)
result[116] += x228 * (x23 * x253 * x315 + x23 * x254 * x312 + x253 * x31 * x312)
result[117] += x305 * (x23 * x258 * x302 + x23 * x264 * x300 + x258 * x300 * x31)
result[118] += x228 * (x23 * x272 * x297 + x23 * x275 * x292 + x272 * x292 * x31)
result[119] += x164 * (x23 * x279 * x288 + x23 * x282 * x285 + x279 * x285 * x31)
result[120] += x164 * (x207 * x332 * x382 + x207 * x335 * x377 + x209 * x332 * x377)
result[121] += x228 * (x214 * x332 * x381 + x214 * x335 * x77 + x215 * x332 * x77)
result[122] += x228 * (x207 * x338 * x381 + x207 * x343 * x77 + x209 * x338 * x77)
result[123] += x305 * (x220 * x332 * x54 + x220 * x335 * x35 + x226 * x332 * x35)
result[124] += x329 * (x214 * x338 * x54 + x214 * x343 * x35 + x215 * x338 * x35)
result[125] += x305 * (x207 * x346 * x54 + x207 * x348 * x35 + x209 * x346 * x35)
result[126] += x228 * (x236 * x25 * x335 + x236 * x27 * x332 + x239 * x25 * x332)
result[127] += x329 * (x220 * x25 * x343 + x220 * x27 * x338 + x226 * x25 * x338)
result[128] += x329 * (x214 * x25 * x348 + x214 * x27 * x346 + x215 * x25 * x346)
result[129] += x228 * (x207 * x25 * x359 + x207 * x27 * x356 + x209 * x25 * x356)
result[130] += x164 * (x23 * x243 * x335 + x23 * x246 * x332 + x243 * x31 * x332)
result[131] += x228 * (x23 * x236 * x343 + x23 * x239 * x338 + x236 * x31 * x338)
result[132] += x305 * (x220 * x23 * x348 + x220 * x31 * x346 + x226 * x23 * x346)
result[133] += x228 * (x214 * x23 * x359 + x214 * x31 * x356 + x215 * x23 * x356)
result[134] += x164 * (x112 * x372 * x414 + x207 * x31 * x365 + x209 * x23 * x365)
result[135] += x131 * (x114 * x415 * x417 + x123 * x382 * x415 + x416 * x417)
result[136] += x217 * (x124 * x381 * x415 + x124 * x416 * x77 + x126 * x415 * x77)
result[137] += x217 * (x114 * x421 * x77 + x123 * x425 * x77 + x381 * x421)
result[138] += x227 * (x140 * x35 * x416 + x140 * x415 * x54 + x144 * x35 * x415)
result[139] += x228 * (x124 * x35 * x425 + x124 * x420 * x54 + x126 * x35 * x420)
result[140] += x227 * (x114 * x428 * x431 + x123 * x428 * x54 + x430 * x431)
result[141] += x217 * (x176 * x25 * x416 + x176 * x27 * x415 + x177 * x25 * x415)
result[142] += x228 * (x140 * x25 * x425 + x140 * x27 * x420 + x144 * x25 * x420)
result[143] += x228 * (x124 * x25 * x430 + x124 * x27 * x428 + x126 * x25 * x428)
result[144] += x217 * (x114 * x25 * x434 + x123 * x25 * x437 + x27 * x434)
result[145] += x131 * (x195 * x23 * x416 + x195 * x31 * x415 + x196 * x23 * x415)
result[146] += x217 * (x176 * x23 * x425 + x176 * x31 * x420 + x177 * x23 * x420)
result[147] += x227 * (x140 * x23 * x430 + x140 * x31 * x428 + x144 * x23 * x428)
result[148] += x217 * (x122 * x414 * x437 + x124 * x31 * x433 + x126 * x23 * x433)
result[149] += x131 * (x114 * x414 * x441 + x123 * x31 * x441 + x445 * x6)
result[150] += x121 * (x119 * x447 * x451 + x128 * x447 * x452 + x448 * x451)
result[151] += x131 * (x119 * x375 * x455 + x128 * x375 * x456 + x380 * x455)
result[152] += x131 * (x133 * x375 * x452 + x133 * x380 * x450 + x135 * x375 * x450)
result[153] += x162 * (x119 * x45 * x458 + x128 * x45 * x459 + x379 * x458)
result[154] += x164 * (x133 * x379 * x454 + x133 * x45 * x456 + x135 * x45 * x454)
result[155] += x162 * (x169 * x379 * x450 + x169 * x45 * x452 + x173 * x45 * x450)
result[156] += x131 * (x119 * x460 * x462 + x128 * x20 * x460 + x461 * x5)
result[157] += x164 * (x132 * x459 * x462 + x133 * x20 * x457 + x135 * x16 * x457)
result[158] += x164 * (x16 * x169 * x456 + x16 * x173 * x454 + x169 * x20 * x454)
result[159] += x131 * (x16 * x189 * x452 + x16 * x190 * x450 + x189 * x20 * x450)
result[160] += x121 * (
x10 * x465
+ x119 * x465
+ x410
* (
x112 * x409
- x18 * (-2.0 * ax * x464 + 3.0 * x319 + x463)
+ x2 * (7.0 * x324 + 3.0 * x325 + 3.0 * x327 + 4.0 * x400 + 4.0 * x401)
)
)
result[161] += x131 * (x132 * x460 * x466 + x132 * x461 + x135 * x15 * x460)
result[162] += x162 * (x10 * x169 * x467 + x15 * x169 * x459 + x173 * x467)
result[163] += x131 * (x10 * x189 * x468 + x15 * x189 * x456 + x190 * x468)
result[164] += x121 * (x10 * x204 * x469 + x15 * x204 * x452 + x205 * x469)
result[165] += x131 * (x247 * x373 * x448 + x247 * x374 * x447 + x249 * x373 * x447)
result[166] += x217 * (x247 * x375 * x390 + x247 * x380 * x385 + x249 * x375 * x385)
result[167] += x217 * (x253 * x373 * x380 + x253 * x374 * x375 + x254 * x373 * x375)
result[168] += x227 * (x247 * x379 * x393 + x247 * x395 * x45 + x249 * x393 * x45)
result[169] += x228 * (x253 * x379 * x385 + x253 * x390 * x45 + x254 * x385 * x45)
result[170] += x227 * (x258 * x373 * x379 + x258 * x374 * x45 + x264 * x373 * x45)
result[171] += x217 * (x117 * x402 * x462 + x16 * x249 * x398 + x20 * x247 * x398)
result[172] += x228 * (x16 * x253 * x395 + x16 * x254 * x393 + x20 * x253 * x393)
result[173] += x228 * (x16 * x258 * x390 + x16 * x264 * x385 + x20 * x258 * x385)
result[174] += x217 * (x16 * x272 * x374 + x16 * x275 * x373 + x20 * x272 * x373)
result[175] += x131 * (x117 * x406 * x466 + x117 * x411 + x15 * x249 * x406)
result[176] += x217 * (x10 * x253 * x470 + x15 * x253 * x402 + x254 * x470)
result[177] += x227 * (x10 * x393 * x471 + x15 * x264 * x393 + x395 * x471)
result[178] += x217 * (x10 * x272 * x472 + x15 * x272 * x390 + x275 * x472)
result[179] += x131 * (x10 * x373 * x473 + x15 * x282 * x373 + x374 * x473)
result[180] += x162 * (x285 * x332 * x448 + x285 * x335 * x447 + x288 * x332 * x447)
result[181] += x227 * (x292 * x332 * x380 + x292 * x335 * x375 + x297 * x332 * x375)
result[182] += x227 * (x285 * x338 * x380 + x285 * x343 * x375 + x288 * x338 * x375)
result[183] += x304 * (x300 * x332 * x379 + x300 * x335 * x45 + x302 * x332 * x45)
result[184] += x305 * (x292 * x338 * x379 + x292 * x343 * x45 + x297 * x338 * x45)
result[185] += x304 * (x285 * x346 * x379 + x285 * x348 * x45 + x288 * x346 * x45)
result[186] += x227 * (x16 * x312 * x335 + x16 * x315 * x332 + x20 * x312 * x332)
result[187] += x305 * (x16 * x300 * x343 + x16 * x302 * x338 + x20 * x300 * x338)
result[188] += x305 * (x16 * x292 * x348 + x16 * x297 * x346 + x20 * x292 * x346)
result[189] += x227 * (x16 * x285 * x359 + x16 * x288 * x356 + x20 * x285 * x356)
result[190] += x162 * (x10 * x332 * x474 + x15 * x328 * x332 + x335 * x474)
result[191] += x227 * (x10 * x312 * x475 + x15 * x312 * x343 + x315 * x475)
result[192] += x304 * (x10 * x346 * x476 + x15 * x302 * x346 + x348 * x476)
result[193] += x227 * (x10 * x356 * x477 + x15 * x297 * x356 + x359 * x477)
result[194] += x162 * (x10 * x285 * x478 + x15 * x285 * x372 + x288 * x478)
result[195] += x131 * (x207 * x415 * x448 + x207 * x416 * x447 + x209 * x415 * x447)
result[196] += x217 * (x214 * x375 * x416 + x214 * x380 * x415 + x215 * x375 * x415)
result[197] += x217 * (x207 * x375 * x425 + x207 * x380 * x420 + x209 * x375 * x420)
result[198] += x227 * (x220 * x379 * x415 + x220 * x416 * x45 + x226 * x415 * x45)
result[199] += x228 * (x214 * x379 * x420 + x214 * x425 * x45 + x215 * x420 * x45)
result[200] += x227 * (x207 * x379 * x428 + x207 * x430 * x45 + x209 * x428 * x45)
result[201] += x217 * (x16 * x236 * x416 + x16 * x239 * x415 + x20 * x236 * x415)
result[202] += x228 * (x16 * x220 * x425 + x16 * x226 * x420 + x20 * x220 * x420)
result[203] += x228 * (x16 * x214 * x430 + x16 * x215 * x428 + x20 * x214 * x428)
result[204] += x217 * (x16 * x209 * x433 + x20 * x207 * x433 + x437 * x479 * x5)
result[205] += x131 * (x10 * x415 * x480 + x15 * x246 * x415 + x416 * x480)
result[206] += x217 * (x10 * x236 * x481 + x15 * x236 * x425 + x239 * x481)
result[207] += x227 * (x10 * x428 * x482 + x15 * x226 * x428 + x430 * x482)
result[208] += x217 * (x10 * x214 * x483 + x15 * x214 * x437 + x215 * x483)
result[209] += x131 * (x10 * x441 * x479 + x112 * x445 + x15 * x209 * x441)
result[210] += x121 * (x114 * x447 * x486 + x123 * x447 * x487 + x448 * x486)
result[211] += x131 * (x124 * x375 * x487 + x124 * x380 * x485 + x126 * x375 * x485)
result[212] += x131 * (x114 * x375 * x490 + x123 * x375 * x491 + x380 * x490)
result[213] += x162 * (x140 * x379 * x485 + x140 * x45 * x487 + x144 * x45 * x485)
result[214] += x164 * (x124 * x379 * x489 + x124 * x45 * x491 + x126 * x45 * x489)
result[215] += x162 * (x114 * x45 * x493 + x123 * x45 * x494 + x379 * x493)
result[216] += x131 * (x16 * x176 * x487 + x16 * x177 * x485 + x176 * x20 * x485)
result[217] += x164 * (x140 * x16 * x491 + x140 * x20 * x489 + x144 * x16 * x489)
result[218] += x164 * (x122 * x494 * x495 + x124 * x20 * x492 + x126 * x16 * x492)
result[219] += x131 * (x114 * x495 * x496 + x123 * x20 * x496 + x497 * x5)
result[220] += x121 * (x10 * x195 * x498 + x15 * x195 * x487 + x196 * x498)
result[221] += x131 * (x10 * x176 * x499 + x15 * x176 * x491 + x177 * x499)
result[222] += x162 * (x10 * x140 * x500 + x140 * x15 * x494 + x144 * x500)
result[223] += x131 * (x10 * x122 * x413 * x496 + x122 * x497 + x126 * x15 * x496)
result[224] += x121 * (
x10 * x503
+ x114 * x503
+ x413
* (
x117 * x444
- x18 * (-2.0 * ax * x502 + 3.0 * x363 + x501)
+ x2 * (7.0 * x368 + 3.0 * x369 + 3.0 * x371 + 4.0 * x435 + 4.0 * x436)
)
)
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)] = kinetic3d_00
func_dict[(1, 0)] = kinetic3d_10
func_dict[(0, 1)] = kinetic3d_01
func_dict[(2, 0)] = kinetic3d_20
func_dict[(0, 2)] = kinetic3d_02
func_dict[(3, 0)] = kinetic3d_30
func_dict[(0, 3)] = kinetic3d_03
func_dict[(4, 0)] = kinetic3d_40
func_dict[(0, 4)] = kinetic3d_04
func_dict[(1, 1)] = kinetic3d_11
func_dict[(2, 1)] = kinetic3d_21
func_dict[(1, 2)] = kinetic3d_12
func_dict[(3, 1)] = kinetic3d_31
func_dict[(1, 3)] = kinetic3d_13
func_dict[(4, 1)] = kinetic3d_41
func_dict[(1, 4)] = kinetic3d_14
func_dict[(2, 2)] = kinetic3d_22
func_dict[(3, 2)] = kinetic3d_32
func_dict[(2, 3)] = kinetic3d_23
func_dict[(4, 2)] = kinetic3d_42
func_dict[(2, 4)] = kinetic3d_24
func_dict[(3, 3)] = kinetic3d_33
func_dict[(4, 3)] = kinetic3d_43
func_dict[(3, 4)] = kinetic3d_34
func_dict[(4, 4)] = kinetic3d_44
return func_dict