"""
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
"""
"""
Diagonal of the quadrupole moment matrix with operators x², y², z².
for rr in (xx, yy, zz):
for bf_a in basis_functions_a:
for bf_b in basis_functions_b:
quadrupole_integrals(bf_a, bf_b, rr)
"""
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 diag_quadrupole3d_00(ax, da, A, bx, db, B, R, result):
"""Cartesian 3D (ss) quadrupole moment integrals
for operators x², y² and z². The origin is at R.
Generated code; DO NOT modify by hand!"""
x0 = (ax + bx) ** (-1.0)
x1 = 0.5 * x0
x2 = ax * bx * x0
x3 = (
5.56832799683170785
* da
* db
* x0**1.5
* numpy.exp(-x2 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2))
)
# 3 item(s)
result[0] += x3 * (x1 + (-x0 * (ax * A[0] + bx * B[0]) + R[0]) ** 2)
result[1] += x3 * (x1 + (-x0 * (ax * A[1] + bx * B[1]) + R[1]) ** 2)
result[2] += x3 * (x1 + (-x0 * (ax * A[2] + bx * B[2]) + R[2]) ** 2)
[docs]
@numba.jit(
func_type.signature,
nopython=True,
nogil=True,
fastmath=True,
cache=True,
)
def diag_quadrupole3d_10(ax, da, A, bx, db, B, R, result):
"""Cartesian 3D (ps) quadrupole moment integrals
for operators x², y² and z². The origin is at R.
Generated code; DO NOT modify by hand!"""
x0 = (ax + bx) ** (-1.0)
x1 = x0 * (ax * A[0] + bx * B[0])
x2 = -x1
x3 = x2 + R[0]
x4 = x2 + A[0]
x5 = 0.5 * x0
x6 = ax * bx * x0
x7 = (
5.56832799683170785
* da
* db
* numpy.sqrt(x0)
* numpy.exp(-x6 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2))
)
x8 = x5 * x7
x9 = x0 * (ax * A[1] + bx * B[1])
x10 = -x9
x11 = x10 + A[1]
x12 = x0 * x7
x13 = x12 * (x3**2 + x5)
x14 = x0 * (ax * A[2] + bx * B[2])
x15 = -x14
x16 = x15 + A[2]
x17 = x10 + R[1]
x18 = x12 * (x17**2 + x5)
x19 = x15 + R[2]
x20 = x12 * (x19**2 + x5)
# 9 item(s)
result[0] += -x8 * (x0 * (-2.0 * x1 + A[0] + R[0]) + x3 * (x0 + 2.0 * x3 * x4))
result[1] += -x11 * x13
result[2] += -x13 * x16
result[3] += -x18 * x4
result[4] += -x8 * (x0 * (-2.0 * x9 + A[1] + R[1]) + x17 * (x0 + 2.0 * x11 * x17))
result[5] += -x16 * x18
result[6] += -x20 * x4
result[7] += -x11 * x20
result[8] += -x8 * (x0 * (-2.0 * x14 + A[2] + R[2]) + x19 * (x0 + 2.0 * x16 * x19))
[docs]
@numba.jit(
func_type.signature,
nopython=True,
nogil=True,
fastmath=True,
cache=True,
)
def diag_quadrupole3d_01(ax, da, A, bx, db, B, R, result):
"""See docstring of diag_quadrupole3d_10."""
# Call equivalent function and write to result
tmp = numpy.zeros_like(result)
diag_quadrupole3d_10(bx, db, B, ax, da, A, R, tmp)
result[:] += numpy.transpose(tmp.reshape(3, 3, 1), axes=(0, 2, 1)).flatten()
[docs]
@numba.jit(
func_type.signature,
nopython=True,
nogil=True,
fastmath=True,
cache=True,
)
def diag_quadrupole3d_20(ax, da, A, bx, db, B, R, result):
"""Cartesian 3D (ds) quadrupole moment integrals
for operators x², y² and z². The origin is at R.
Generated code; DO NOT modify by hand!"""
x0 = (ax + bx) ** (-1.0)
x1 = x0 * (ax * A[0] + bx * B[0])
x2 = -x1
x3 = x2 + R[0]
x4 = x3**2
x5 = 3.0 * x0
x6 = x2 + A[0]
x7 = x3 * x6
x8 = x0 * (-2.0 * x1 + A[0] + R[0]) + x3 * (x0 + 2.0 * x7)
x9 = 1.73205080756887729
x10 = 5.56832799683170785
x11 = ax * bx * x0
x12 = numpy.exp(-x11 * (A[0] - B[0]) ** 2)
x13 = numpy.exp(-x11 * (A[1] - B[1]) ** 2)
x14 = numpy.exp(-x11 * (A[2] - B[2]) ** 2)
x15 = da * db * numpy.sqrt(x0) * x10 * x12 * x13 * x14
x16 = x0 * x15
x17 = 0.0833333333333333333 * x16 * x9
x18 = x0 * (ax * A[1] + bx * B[1])
x19 = -x18
x20 = x19 + A[1]
x21 = 0.5 * x0
x22 = x15 * x21
x23 = x22 * x8
x24 = x0 * (ax * A[2] + bx * B[2])
x25 = -x24
x26 = x25 + A[2]
x27 = x20**2 + x21
x28 = x21 + x4
x29 = 0.333333333333333333 * da * db * x0**1.5 * x10 * x12 * x13 * x14 * x9
x30 = x28 * x29
x31 = x16 * x26
x32 = x21 + x26**2
x33 = x21 + x6**2
x34 = x19 + R[1]
x35 = x34**2
x36 = x21 + x35
x37 = x29 * x36
x38 = x20 * x34
x39 = x0 * (-2.0 * x18 + A[1] + R[1]) + x34 * (x0 + 2.0 * x38)
x40 = x22 * x39
x41 = x25 + R[2]
x42 = x41**2
x43 = x21 + x42
x44 = x29 * x43
x45 = x26 * x41
x46 = x0 * (-2.0 * x24 + A[2] + R[2]) + x41 * (x0 + 2.0 * x45)
x47 = x22 * x46
# 18 item(s)
result[0] += x17 * (x0 * (2.0 * x4 + x5 + 4.0 * x7) + 2.0 * x6 * x8)
result[1] += x20 * x23
result[2] += x23 * x26
result[3] += x27 * x30
result[4] += x20 * x28 * x31
result[5] += x30 * x32
result[6] += x33 * x37
result[7] += x40 * x6
result[8] += x31 * x36 * x6
result[9] += x17 * (x0 * (2.0 * x35 + 4.0 * x38 + x5) + 2.0 * x20 * x39)
result[10] += x26 * x40
result[11] += x32 * x37
result[12] += x33 * x44
result[13] += x16 * x20 * x43 * x6
result[14] += x47 * x6
result[15] += x27 * x44
result[16] += x20 * x47
result[17] += x17 * (x0 * (2.0 * x42 + 4.0 * x45 + x5) + 2.0 * x26 * x46)
[docs]
@numba.jit(
func_type.signature,
nopython=True,
nogil=True,
fastmath=True,
cache=True,
)
def diag_quadrupole3d_02(ax, da, A, bx, db, B, R, result):
"""See docstring of diag_quadrupole3d_20."""
# Call equivalent function and write to result
tmp = numpy.zeros_like(result)
diag_quadrupole3d_20(bx, db, B, ax, da, A, R, tmp)
result[:] += numpy.transpose(tmp.reshape(3, 6, 1), axes=(0, 2, 1)).flatten()
[docs]
@numba.jit(
func_type.signature,
nopython=True,
nogil=True,
fastmath=True,
cache=True,
)
def diag_quadrupole3d_30(ax, da, A, bx, db, B, R, result):
"""Cartesian 3D (fs) quadrupole moment integrals
for operators x², y² and z². The origin is at R.
Generated code; DO NOT modify by hand!"""
x0 = (ax + bx) ** (-1.0)
x1 = x0 * (ax * A[0] + bx * B[0])
x2 = -x1
x3 = x2 + A[0]
x4 = x2 + R[0]
x5 = x4**2
x6 = 3.0 * x0
x7 = x3 * x4
x8 = x0 * (-2.0 * x1 + A[0] + R[0])
x9 = x0 + 2.0 * x7
x10 = x4 * x9
x11 = x10 + x8
x12 = x0 * (2.0 * x5 + x6 + 4.0 * x7) + 2.0 * x11 * x3
x13 = 2.0 * x0
x14 = 3.87298334620741689
x15 = ax * bx * x0
x16 = (
5.56832799683170785
* da
* db
* numpy.exp(-x15 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2))
)
x17 = numpy.sqrt(x0) * x16
x18 = x0 * x17
x19 = 0.0166666666666666667 * x14 * x18
x20 = x0 * (ax * A[1] + bx * B[1])
x21 = -x20
x22 = x21 + A[1]
x23 = 1.73205080756887729
x24 = 0.0833333333333333333 * x18 * x23
x25 = x12 * x24
x26 = x0 * (ax * A[2] + bx * B[2])
x27 = -x26
x28 = x27 + A[2]
x29 = x22**2
x30 = 0.5 * x0
x31 = x29 + x30
x32 = x0**1.5 * x16
x33 = x23 * x32
x34 = 0.166666666666666667 * x33
x35 = x11 * x34
x36 = x17 * x28 * x30
x37 = x28**2
x38 = x30 + x37
x39 = x30 + x5
x40 = x22 * x39
x41 = 1.5 * x0
x42 = 0.0666666666666666667 * x14 * x32
x43 = x42 * (x29 + x41)
x44 = x28 * x39
x45 = 0.333333333333333333 * x33
x46 = x31 * x45
x47 = x38 * x45
x48 = x42 * (x37 + x41)
x49 = x21 + R[1]
x50 = x49**2
x51 = x30 + x50
x52 = x3 * x51
x53 = x3**2
x54 = x42 * (x41 + x53)
x55 = x30 + x53
x56 = x0 * (-2.0 * x20 + A[1] + R[1])
x57 = x22 * x49
x58 = x0 + 2.0 * x57
x59 = x49 * x58
x60 = x56 + x59
x61 = x34 * x60
x62 = x28 * x51
x63 = x45 * x55
x64 = x0 * (2.0 * x50 + 4.0 * x57 + x6) + 2.0 * x22 * x60
x65 = x24 * x64
x66 = x27 + R[2]
x67 = x66**2
x68 = x30 + x67
x69 = x3 * x68
x70 = x22 * x68
x71 = x0 * (-2.0 * x26 + A[2] + R[2])
x72 = x28 * x66
x73 = x0 + 2.0 * x72
x74 = x66 * x73
x75 = x71 + x74
x76 = x34 * x75
x77 = x0 * (x6 + 2.0 * x67 + 4.0 * x72) + 2.0 * x28 * x75
x78 = x24 * x77
# 30 item(s)
result[0] += -x19 * (x12 * x3 + x13 * (x10 + x3 * x9 + 2.0 * x8))
result[1] += -x22 * x25
result[2] += -x25 * x28
result[3] += -x31 * x35
result[4] += -x11 * x22 * x36
result[5] += -x35 * x38
result[6] += -x40 * x43
result[7] += -x44 * x46
result[8] += -x40 * x47
result[9] += -x44 * x48
result[10] += -x52 * x54
result[11] += -x55 * x61
result[12] += -x62 * x63
result[13] += -x3 * x65
result[14] += -x3 * x36 * x60
result[15] += -x47 * x52
result[16] += -x19 * (x13 * (x22 * x58 + 2.0 * x56 + x59) + x22 * x64)
result[17] += -x28 * x65
result[18] += -x38 * x61
result[19] += -x48 * x62
result[20] += -x54 * x69
result[21] += -x63 * x70
result[22] += -x55 * x76
result[23] += -x46 * x69
result[24] += -x17 * x22 * x3 * x30 * x75
result[25] += -x3 * x78
result[26] += -x43 * x70
result[27] += -x31 * x76
result[28] += -x22 * x78
result[29] += -x19 * (x13 * (x28 * x73 + 2.0 * x71 + x74) + x28 * x77)
[docs]
@numba.jit(
func_type.signature,
nopython=True,
nogil=True,
fastmath=True,
cache=True,
)
def diag_quadrupole3d_03(ax, da, A, bx, db, B, R, result):
"""See docstring of diag_quadrupole3d_30."""
# Call equivalent function and write to result
tmp = numpy.zeros_like(result)
diag_quadrupole3d_30(bx, db, B, ax, da, A, R, tmp)
result[:] += numpy.transpose(tmp.reshape(3, 10, 1), axes=(0, 2, 1)).flatten()
[docs]
@numba.jit(
func_type.signature,
nopython=True,
nogil=True,
fastmath=True,
cache=True,
)
def diag_quadrupole3d_40(ax, da, A, bx, db, B, R, result):
"""Cartesian 3D (gs) quadrupole moment integrals
for operators x², y² and z². The origin is at R.
Generated code; DO NOT modify by hand!"""
x0 = 0.5 / (ax + bx)
x1 = (ax + bx) ** (-1.0)
x2 = -x1 * (ax * A[0] + bx * B[0])
x3 = -x2 - A[0]
x4 = ax * bx * x1
x5 = numpy.exp(-x4 * (A[0] - B[0]) ** 2)
x6 = 1.77245385090551603 * numpy.sqrt(x1)
x7 = x5 * x6
x8 = x3**2 * x7
x9 = x0 * x7
x10 = 3.0 * x9
x11 = 2.0 * x3
x12 = -x2 - R[0]
x13 = x12 * x7
x14 = x10 + x11 * x13
x15 = 2.0 * x0
x16 = x3 * x7
x17 = x0 * (x13 + x16)
x18 = x12 * x16 + x9
x19 = x18 * x3
x20 = x12**2 * x7
x21 = x0 * (x14 + x20)
x22 = x12 * x18
x23 = x17 + x22
x24 = x23 * x3
x25 = x21 + x24
x26 = 2.0 * x0 * (2.0 * x17 + x19 + x22) + x25 * x3
x27 = da * db
x28 = 0.0975900072948533179 * x27
x29 = numpy.exp(-x4 * (A[1] - B[1]) ** 2)
x30 = numpy.exp(-x4 * (A[2] - B[2]) ** 2)
x31 = 3.14159265358979324 * x1 * x30
x32 = x29 * x31
x33 = -x1 * (ax * A[1] + bx * B[1])
x34 = -x33 - A[1]
x35 = 0.258198889747161126 * x27
x36 = x34 * x35
x37 = x26 * x32
x38 = -x1 * (ax * A[2] + bx * B[2])
x39 = -x38 - A[2]
x40 = x35 * x39
x41 = x30 * x6
x42 = x29 * x6
x43 = x34**2 * x42
x44 = x0 * x42
x45 = x43 + x44
x46 = 0.333333333333333333 * x27
x47 = x45 * x46
x48 = 1.73205080756887729
x49 = x39 * x46 * x48
x50 = x39**2 * x41
x51 = x0 * x41
x52 = x50 + x51
x53 = x46 * x52
x54 = x34 * x42
x55 = x15 * x54 + x34 * x45
x56 = x23 * x35
x57 = x39 * x41
x58 = x23 * x48
x59 = x15 * x57 + x39 * x52
x60 = 3.0 * x44
x61 = x0 * (3.0 * x43 + x60) + x34 * x55
x62 = x20 + x9
x63 = x28 * x62
x64 = x35 * x62
x65 = 3.0 * x51
x66 = x0 * (3.0 * x50 + x65) + x39 * x59
x67 = x8 + x9
x68 = x15 * x16 + x3 * x67
x69 = x0 * (x10 + 3.0 * x8) + x3 * x68
x70 = -x33 - R[1]
x71 = x42 * x70**2
x72 = x44 + x71
x73 = x28 * x72
x74 = x42 * x70
x75 = x0 * (x54 + x74)
x76 = x44 + x54 * x70
x77 = x70 * x76
x78 = x75 + x77
x79 = x35 * x78
x80 = x35 * x72
x81 = 2.0 * x34
x82 = x60 + x74 * x81
x83 = x0 * (x71 + x82)
x84 = x34 * x78
x85 = x83 + x84
x86 = x46 * x67
x87 = x48 * x78
x88 = x34 * x76
x89 = 2.0 * x0 * (2.0 * x75 + x77 + x88) + x34 * x85
x90 = x31 * x89
x91 = x3 * x5
x92 = x35 * x91
x93 = x28 * x5
x94 = -x38 - R[2]
x95 = x41 * x94**2
x96 = x51 + x95
x97 = x28 * x96
x98 = x35 * x96
x99 = x41 * x94
x100 = x0 * (x57 + x99)
x101 = x51 + x57 * x94
x102 = x101 * x94
x103 = x100 + x102
x104 = x103 * x35
x105 = x103 * x48
x106 = 2.0 * x39
x107 = x106 * x99 + x65
x108 = x0 * (x107 + x95)
x109 = x103 * x39
x110 = x108 + x109
x111 = 3.14159265358979324 * x1 * x29
x112 = x101 * x39
x113 = 2.0 * x0 * (2.0 * x100 + x102 + x112) + x110 * x39
x114 = x111 * x113
# 45 item(s)
result[0] += (
x28
* x32
* (x0 * (x11 * (x17 + x19) + x15 * (x14 + x8) + 3.0 * x21 + 3.0 * x24) + x26 * x3)
)
result[1] += x36 * x37
result[2] += x37 * x40
result[3] += x25 * x41 * x47
result[4] += x25 * x32 * x34 * x49
result[5] += x25 * x42 * x53
result[6] += x41 * x55 * x56
result[7] += x47 * x57 * x58
result[8] += x53 * x54 * x58
result[9] += x42 * x56 * x59
result[10] += x41 * x61 * x63
result[11] += x55 * x57 * x64
result[12] += x45 * x53 * x62
result[13] += x54 * x59 * x64
result[14] += x42 * x63 * x66
result[15] += x41 * x69 * x73
result[16] += x41 * x68 * x79
result[17] += x57 * x68 * x80
result[18] += x41 * x85 * x86
result[19] += x57 * x86 * x87
result[20] += x53 * x67 * x72
result[21] += x90 * x92
result[22] += x31 * x49 * x85 * x91
result[23] += x16 * x53 * x87
result[24] += x16 * x59 * x80
result[25] += (
x31
* x93
* (
x0 * (x15 * (x43 + x82) + x81 * (x75 + x88) + 3.0 * x83 + 3.0 * x84)
+ x34 * x89
)
)
result[26] += x40 * x5 * x90
result[27] += x53 * x7 * x85
result[28] += x59 * x7 * x79
result[29] += x66 * x7 * x73
result[30] += x42 * x69 * x97
result[31] += x54 * x68 * x98
result[32] += x104 * x42 * x68
result[33] += x47 * x67 * x96
result[34] += x105 * x54 * x86
result[35] += x110 * x42 * x86
result[36] += x16 * x55 * x98
result[37] += x105 * x16 * x47
result[38] += x110 * x111 * x34 * x46 * x48 * x91
result[39] += x114 * x92
result[40] += x61 * x7 * x97
result[41] += x104 * x55 * x7
result[42] += x110 * x47 * x7
result[43] += x114 * x36 * x5
result[44] += (
x111
* x93
* (
x0 * (x106 * (x100 + x112) + 3.0 * x108 + 3.0 * x109 + x15 * (x107 + x50))
+ x113 * x39
)
)
[docs]
@numba.jit(
func_type.signature,
nopython=True,
nogil=True,
fastmath=True,
cache=True,
)
def diag_quadrupole3d_04(ax, da, A, bx, db, B, R, result):
"""See docstring of diag_quadrupole3d_40."""
# Call equivalent function and write to result
tmp = numpy.zeros_like(result)
diag_quadrupole3d_40(bx, db, B, ax, da, A, R, tmp)
result[:] += numpy.transpose(tmp.reshape(3, 15, 1), axes=(0, 2, 1)).flatten()
[docs]
@numba.jit(
func_type.signature,
nopython=True,
nogil=True,
fastmath=True,
cache=True,
)
def diag_quadrupole3d_11(ax, da, A, bx, db, B, R, result):
"""Cartesian 3D (pp) quadrupole moment integrals
for operators x², y² and z². The origin is at R.
Generated code; DO NOT modify by hand!"""
x0 = (ax + bx) ** (-1.0)
x1 = 3.0 * x0
x2 = x0 * (ax * A[0] + bx * B[0])
x3 = -x2
x4 = x3 + A[0]
x5 = x3 + B[0]
x6 = x4 * x5
x7 = x3 + R[0]
x8 = 2.0 * x7
x9 = x4 * x8
x10 = x5 * x8
x11 = -2.0 * x2 + R[0]
x12 = x0 * (x11 + B[0])
x13 = x0 + x10
x14 = ax * bx * x0
x15 = (
5.56832799683170785
* da
* db
* numpy.exp(-x14 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2))
)
x16 = numpy.sqrt(x0) * x15
x17 = x0 * x16
x18 = 0.25 * x17
x19 = x0 * (ax * A[1] + bx * B[1])
x20 = -x19
x21 = x20 + B[1]
x22 = 0.5 * x0
x23 = x16 * x22
x24 = x23 * (x0 * (x11 + A[0]) + x7 * (x0 + x9))
x25 = x0 * (ax * A[2] + bx * B[2])
x26 = -x25
x27 = x26 + B[2]
x28 = x20 + A[1]
x29 = x23 * (x12 + x13 * x7)
x30 = x21 * x28
x31 = x22 + x30
x32 = x22 + x7**2
x33 = x0**1.5 * x15
x34 = x32 * x33
x35 = x17 * x32
x36 = x26 + A[2]
x37 = x27 * x36
x38 = x22 + x37
x39 = x22 + x6
x40 = x20 + R[1]
x41 = x22 + x40**2
x42 = x33 * x41
x43 = -2.0 * x19 + R[1]
x44 = x0 * (x43 + B[1])
x45 = 2.0 * x40
x46 = x21 * x45
x47 = x0 + x46
x48 = x23 * (x40 * x47 + x44)
x49 = x17 * x41
x50 = x28 * x45
x51 = x23 * (x0 * (x43 + A[1]) + x40 * (x0 + x50))
x52 = x26 + R[2]
x53 = x22 + x52**2
x54 = x33 * x53
x55 = x17 * x53
x56 = -2.0 * x25 + R[2]
x57 = x0 * (x56 + B[2])
x58 = 2.0 * x52
x59 = x27 * x58
x60 = x0 + x59
x61 = x23 * (x52 * x60 + x57)
x62 = x36 * x58
x63 = x23 * (x0 * (x56 + A[2]) + x52 * (x0 + x62))
# 27 item(s)
result[0] += x18 * (x0 * (x1 + x10 + 2.0 * x6 + x9) + x8 * (x12 + x13 * x4))
result[1] += x21 * x24
result[2] += x24 * x27
result[3] += x28 * x29
result[4] += x31 * x34
result[5] += x27 * x28 * x35
result[6] += x29 * x36
result[7] += x21 * x35 * x36
result[8] += x34 * x38
result[9] += x39 * x42
result[10] += x4 * x48
result[11] += x27 * x4 * x49
result[12] += x5 * x51
result[13] += x18 * (x0 * (x1 + 2.0 * x30 + x46 + x50) + x45 * (x28 * x47 + x44))
result[14] += x27 * x51
result[15] += x36 * x49 * x5
result[16] += x36 * x48
result[17] += x38 * x42
result[18] += x39 * x54
result[19] += x21 * x4 * x55
result[20] += x4 * x61
result[21] += x28 * x5 * x55
result[22] += x31 * x54
result[23] += x28 * x61
result[24] += x5 * x63
result[25] += x21 * x63
result[26] += x18 * (x0 * (x1 + 2.0 * x37 + x59 + x62) + x58 * (x36 * x60 + x57))
[docs]
@numba.jit(
func_type.signature,
nopython=True,
nogil=True,
fastmath=True,
cache=True,
)
def diag_quadrupole3d_21(ax, da, A, bx, db, B, R, result):
"""Cartesian 3D (dp) quadrupole moment integrals
for operators x², y² and z². The origin is at R.
Generated code; DO NOT modify by hand!"""
x0 = (ax + bx) ** (-1.0)
x1 = x0 * (ax * A[0] + bx * B[0])
x2 = -x1
x3 = x2 + R[0]
x4 = x2 + B[0]
x5 = 2.0 * x3
x6 = x4 * x5
x7 = x0 + x6
x8 = x3 * x7
x9 = x2 + A[0]
x10 = x7 * x9
x11 = -2.0 * x1
x12 = x11 + R[0]
x13 = x12 + B[0]
x14 = 3.0 * x0
x15 = x5 * x9
x16 = x0 * (x12 + A[0]) + x3 * (x0 + x15)
x17 = x4 * x9
x18 = 2.0 * x17
x19 = x0 * x13
x20 = x0 * (x14 + x15 + x18 + x6) + x5 * (x10 + x19)
x21 = 1.73205080756887729
x22 = ax * bx * x0
x23 = (
5.56832799683170785
* da
* db
* numpy.exp(-x22 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2))
)
x24 = numpy.sqrt(x0) * x23
x25 = x0 * x24
x26 = 0.0833333333333333333 * x21 * x25
x27 = x0 * (ax * A[1] + bx * B[1])
x28 = -x27
x29 = x28 + B[1]
x30 = x3**2
x31 = x26 * (x0 * (x14 + 4.0 * x3 * x9 + 2.0 * x30) + 2.0 * x16 * x9)
x32 = x0 * (ax * A[2] + bx * B[2])
x33 = -x32
x34 = x33 + B[2]
x35 = x28 + A[1]
x36 = 0.25 * x25
x37 = x20 * x36
x38 = 0.5 * x0
x39 = x29 * x35
x40 = x0**1.5 * x23
x41 = x40 * (x38 + x39)
x42 = 0.5 * x16
x43 = x24 * x38
x44 = x16 * x43
x45 = x33 + A[2]
x46 = x34 * x45
x47 = x40 * (x38 + x46)
x48 = x35**2 + x38
x49 = x19 + x8
x50 = x21 * x40
x51 = 0.166666666666666667 * x50
x52 = x49 * x51
x53 = -2.0 * x27
x54 = x53 + B[1]
x55 = 2.0 * x39
x56 = x0 * (x54 + A[1]) + x35 * (x0 + x55)
x57 = x30 + x38
x58 = x51 * x57
x59 = 0.333333333333333333 * x50
x60 = x57 * x59
x61 = x43 * x45
x62 = x38 + x45**2
x63 = -2.0 * x32
x64 = x63 + B[2]
x65 = 2.0 * x46
x66 = x0 * (x64 + A[2]) + x45 * (x0 + x65)
x67 = x0 * (x11 + A[0] + B[0]) + x9 * (x0 + x18)
x68 = x28 + R[1]
x69 = x68**2
x70 = x38 + x69
x71 = x51 * x70
x72 = x38 + x9**2
x73 = x54 + R[1]
x74 = x0 * x73
x75 = 2.0 * x68
x76 = x29 * x75
x77 = x0 + x76
x78 = x68 * x77
x79 = x74 + x78
x80 = x51 * x79
x81 = x59 * x70
x82 = x40 * (x17 + x38)
x83 = x35 * x75
x84 = x0 * (x53 + A[1] + R[1]) + x68 * (x0 + x83)
x85 = 0.5 * x84
x86 = x35 * x77
x87 = x0 * (x14 + x55 + x76 + x83) + x75 * (x74 + x86)
x88 = x36 * x87
x89 = x43 * x9
x90 = x26 * (x0 * (x14 + 4.0 * x35 * x68 + 2.0 * x69) + 2.0 * x35 * x84)
x91 = x33 + R[2]
x92 = x91**2
x93 = x38 + x92
x94 = x51 * x93
x95 = x59 * x93
x96 = x64 + R[2]
x97 = x0 * x96
x98 = 2.0 * x91
x99 = x34 * x98
x100 = x0 + x99
x101 = x100 * x91
x102 = x101 + x97
x103 = x102 * x51
x104 = x45 * x98
x105 = x0 * (x63 + A[2] + R[2]) + x91 * (x0 + x104)
x106 = 0.5 * x105
x107 = x100 * x45
x108 = x0 * (x104 + x14 + x65 + x99) + x98 * (x107 + x97)
x109 = x108 * x36
x110 = x26 * (x0 * (x14 + 4.0 * x45 * x91 + 2.0 * x92) + 2.0 * x105 * x45)
# 54 item(s)
result[0] += -x26 * (x0 * (2.0 * x10 + x13 * x14 + x16 + x8) + x20 * x9)
result[1] += -x29 * x31
result[2] += -x31 * x34
result[3] += -x35 * x37
result[4] += -x41 * x42
result[5] += -x34 * x35 * x44
result[6] += -x37 * x45
result[7] += -x29 * x44 * x45
result[8] += -x42 * x47
result[9] += -x48 * x52
result[10] += -x56 * x58
result[11] += -x34 * x48 * x60
result[12] += -x35 * x49 * x61
result[13] += -x41 * x45 * x57
result[14] += -x35 * x47 * x57
result[15] += -x52 * x62
result[16] += -x29 * x60 * x62
result[17] += -x58 * x66
result[18] += -x67 * x71
result[19] += -x72 * x80
result[20] += -x34 * x72 * x81
result[21] += -x82 * x85
result[22] += -x88 * x9
result[23] += -x34 * x84 * x89
result[24] += -x45 * x70 * x82
result[25] += -x61 * x79 * x9
result[26] += -x47 * x70 * x9
result[27] += -x4 * x90
result[28] += -x26 * (x0 * (x14 * x73 + x78 + x84 + 2.0 * x86) + x35 * x87)
result[29] += -x34 * x90
result[30] += -x4 * x61 * x84
result[31] += -x45 * x88
result[32] += -x47 * x85
result[33] += -x4 * x62 * x81
result[34] += -x62 * x80
result[35] += -x66 * x71
result[36] += -x67 * x94
result[37] += -x29 * x72 * x95
result[38] += -x103 * x72
result[39] += -x35 * x82 * x93
result[40] += -x41 * x9 * x93
result[41] += -x102 * x35 * x89
result[42] += -x106 * x82
result[43] += -x105 * x29 * x89
result[44] += -x109 * x9
result[45] += -x4 * x48 * x95
result[46] += -x56 * x94
result[47] += -x103 * x48
result[48] += -x105 * x35 * x4 * x43
result[49] += -x106 * x41
result[50] += -x109 * x35
result[51] += -x110 * x4
result[52] += -x110 * x29
result[53] += -x26 * (x0 * (x101 + x105 + 2.0 * x107 + x14 * x96) + x108 * x45)
[docs]
@numba.jit(
func_type.signature,
nopython=True,
nogil=True,
fastmath=True,
cache=True,
)
def diag_quadrupole3d_12(ax, da, A, bx, db, B, R, result):
"""See docstring of diag_quadrupole3d_21."""
# Call equivalent function and write to result
tmp = numpy.zeros_like(result)
diag_quadrupole3d_21(bx, db, B, ax, da, A, R, tmp)
result[:] += numpy.transpose(tmp.reshape(3, 6, 3), axes=(0, 2, 1)).flatten()
[docs]
@numba.jit(
func_type.signature,
nopython=True,
nogil=True,
fastmath=True,
cache=True,
)
def diag_quadrupole3d_31(ax, da, A, bx, db, B, R, result):
"""Cartesian 3D (fp) quadrupole moment integrals
for operators x², y² and z². The origin is at R.
Generated code; DO NOT modify by hand!"""
x0 = (ax + bx) ** (-1.0)
x1 = 3.0 * x0
x2 = x0 * (ax * A[0] + bx * B[0])
x3 = -x2
x4 = x3 + A[0]
x5 = x3 + B[0]
x6 = x4 * x5
x7 = 2.0 * x6
x8 = x3 + R[0]
x9 = x4 * x8
x10 = 2.0 * x9
x11 = 2.0 * x8
x12 = x11 * x5
x13 = x0 * (x1 + x10 + x12 + x7)
x14 = -2.0 * x2
x15 = x14 + R[0]
x16 = x15 + B[0]
x17 = x0 * x16
x18 = x0 + x12
x19 = x18 * x4
x20 = x17 + x19
x21 = 4.0 * x20
x22 = x8**2
x23 = x0 * (x15 + A[0])
x24 = x0 + x10
x25 = x24 * x8
x26 = x23 + x25
x27 = 2.0 * x4
x28 = x0 * (x1 + 2.0 * x22 + 4.0 * x9) + x26 * x27
x29 = x18 * x8
x30 = x11 * x20 + x13
x31 = x0 * (x1 * x16 + 2.0 * x19 + x26 + x29) + x30 * x4
x32 = ax * bx * x0
x33 = (
5.56832799683170785
* da
* db
* numpy.exp(-x32 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2))
)
x34 = 3.87298334620741689 * x33
x35 = x0**1.5
x36 = x34 * x35
x37 = 0.00833333333333333333 * x36
x38 = x0 * (ax * A[1] + bx * B[1])
x39 = -x38
x40 = x39 + B[1]
x41 = 2.0 * x0
x42 = 0.0166666666666666667 * x36
x43 = x42 * (x28 * x4 + x41 * (2.0 * x23 + x24 * x4 + x25))
x44 = x0 * (ax * A[2] + bx * B[2])
x45 = -x44
x46 = x45 + B[2]
x47 = x39 + A[1]
x48 = x33 * x35
x49 = x47 * x48
x50 = 1.73205080756887729
x51 = 0.0833333333333333333 * x50
x52 = x31 * x51
x53 = 0.5 * x0
x54 = x40 * x47
x55 = x0**1.5
x56 = x33 * x55
x57 = x56 * (x53 + x54)
x58 = x28 * x51
x59 = x45 + A[2]
x60 = x48 * x59
x61 = x46 * x59
x62 = x56 * (x53 + x61)
x63 = x47**2
x64 = x53 + x63
x65 = x51 * x56
x66 = x30 * x65
x67 = -2.0 * x38
x68 = x67 + B[1]
x69 = 2.0 * x54
x70 = x0 * (x68 + A[1]) + x47 * (x0 + x69)
x71 = x26 * x65
x72 = 0.166666666666666667 * x50
x73 = x64 * x72
x74 = x26 * x56
x75 = 0.25 * x49
x76 = 0.5 * x26
x77 = x59**2
x78 = x53 + x77
x79 = x72 * x78
x80 = -2.0 * x44
x81 = x80 + B[2]
x82 = 2.0 * x61
x83 = x0 * (x81 + A[2]) + x59 * (x0 + x82)
x84 = x17 + x29
x85 = x34 * x55
x86 = 0.0333333333333333333 * x85
x87 = x84 * x86
x88 = 1.5 * x0
x89 = x47 * (x63 + x88)
x90 = 2.0 * x47
x91 = x0 * (x1 + 4.0 * x54 + 2.0 * x63) + x70 * x90
x92 = x22 + x53
x93 = 0.0166666666666666667 * x85
x94 = x92 * x93
x95 = 0.0666666666666666667 * x85
x96 = x92 * x95
x97 = x56 * x59
x98 = x72 * x92
x99 = 0.333333333333333333 * x50
x100 = x92 * x99
x101 = x47 * x56
x102 = x59 * (x77 + x88)
x103 = 2.0 * x59
x104 = x0 * (x1 + 4.0 * x61 + 2.0 * x77) + x103 * x83
x105 = x4**2
x106 = x0 * (x14 + A[0] + B[0]) + x4 * (x0 + x7)
x107 = x0 * (x1 + 2.0 * x105 + 4.0 * x6) + x106 * x27
x108 = x39 + R[1]
x109 = x108**2
x110 = x109 + x53
x111 = x110 * x93
x112 = x68 + R[1]
x113 = x0 * x112
x114 = 2.0 * x108
x115 = x114 * x40
x116 = x0 + x115
x117 = x108 * x116
x118 = x113 + x117
x119 = x118 * x4
x120 = x105 + x88
x121 = x120 * x86
x122 = x110 * x95
x123 = x120 * x4
x124 = x0 * (x67 + A[1] + R[1])
x125 = x108 * x90
x126 = x0 + x125
x127 = x108 * x126
x128 = x124 + x127
x129 = x128 * x65
x130 = x105 + x53
x131 = x0 * (x1 + x115 + x125 + x69)
x132 = x116 * x47
x133 = x113 + x132
x134 = x114 * x133 + x131
x135 = x134 * x65
x136 = x130 * x72
x137 = x128 * x56
x138 = x110 * x72
x139 = x110 * x99
x140 = 4.0 * x47
x141 = x0 * (x1 + x108 * x140 + 2.0 * x109) + x128 * x90
x142 = x53 + x6
x143 = x142 * x65
x144 = x0 * (x1 * x112 + x117 + x128 + 2.0 * x132) + x134 * x47
x145 = x144 * x51
x146 = x4 * x48
x147 = x141 * x51
x148 = 0.5 * x128
x149 = x142 * x56
x150 = x4 * x56
x151 = x42 * (x141 * x47 + x41 * (2.0 * x124 + x126 * x47 + x127))
x152 = x45 + R[2]
x153 = x152**2
x154 = x153 + x53
x155 = x154 * x93
x156 = x154 * x95
x157 = x81 + R[2]
x158 = x0 * x157
x159 = 2.0 * x152
x160 = x159 * x46
x161 = x0 + x160
x162 = x152 * x161
x163 = x158 + x162
x164 = x154 * x72
x165 = x154 * x99
x166 = x0 * (x80 + A[2] + R[2])
x167 = x103 * x152
x168 = x0 + x167
x169 = x152 * x168
x170 = x166 + x169
x171 = x170 * x65
x172 = x170 * x56
x173 = x0 * (x1 + x160 + x167 + x82)
x174 = x161 * x59
x175 = x158 + x174
x176 = x159 * x175 + x173
x177 = x176 * x65
x178 = 0.5 * x170
x179 = 4.0 * x59
x180 = x0 * (x1 + x152 * x179 + 2.0 * x153) + x103 * x170
x181 = x180 * x51
x182 = x0 * (x1 * x157 + x162 + x170 + 2.0 * x174) + x176 * x59
x183 = x182 * x51
x184 = x42 * (x180 * x59 + x41 * (2.0 * x166 + x168 * x59 + x169))
# 90 item(s)
result[0] += x37 * (x0 * (4.0 * x13 + x21 * x4 + x21 * x8 + x28) + x27 * x31)
result[1] += x40 * x43
result[2] += x43 * x46
result[3] += x49 * x52
result[4] += x57 * x58
result[5] += x46 * x49 * x58
result[6] += x52 * x60
result[7] += x40 * x58 * x60
result[8] += x58 * x62
result[9] += x64 * x66
result[10] += x70 * x71
result[11] += x46 * x73 * x74
result[12] += x30 * x59 * x75
result[13] += x57 * x59 * x76
result[14] += x47 * x62 * x76
result[15] += x66 * x78
result[16] += x40 * x74 * x79
result[17] += x71 * x83
result[18] += x87 * x89
result[19] += x91 * x94
result[20] += x46 * x89 * x96
result[21] += x73 * x84 * x97
result[22] += x70 * x97 * x98
result[23] += x100 * x62 * x64
result[24] += x101 * x79 * x84
result[25] += x100 * x57 * x78
result[26] += x101 * x83 * x98
result[27] += x102 * x87
result[28] += x102 * x40 * x96
result[29] += x104 * x94
result[30] += x107 * x111
result[31] += x119 * x121
result[32] += x122 * x123 * x46
result[33] += x106 * x129
result[34] += x130 * x135
result[35] += x136 * x137 * x46
result[36] += x106 * x138 * x97
result[37] += x118 * x136 * x97
result[38] += x130 * x139 * x62
result[39] += x141 * x143
result[40] += x145 * x146
result[41] += x146 * x147 * x46
result[42] += x142 * x148 * x97
result[43] += 0.25 * x134 * x4 * x60
result[44] += x148 * x4 * x62
result[45] += x139 * x149 * x78
result[46] += x119 * x56 * x79
result[47] += x138 * x150 * x83
result[48] += x151 * x5
result[49] += x37 * (
x0 * (4.0 * x108 * x133 + 4.0 * x131 + x133 * x140 + x141) + x144 * x90
)
result[50] += x151 * x46
result[51] += x147 * x5 * x60
result[52] += x145 * x60
result[53] += x147 * x62
result[54] += x137 * x5 * x79
result[55] += x135 * x78
result[56] += x129 * x83
result[57] += x102 * x122 * x5
result[58] += x102 * x118 * x86
result[59] += x104 * x111
result[60] += x107 * x155
result[61] += x123 * x156 * x40
result[62] += x121 * x163 * x4
result[63] += x101 * x106 * x164
result[64] += x130 * x165 * x57
result[65] += x101 * x136 * x163
result[66] += x106 * x171
result[67] += x136 * x172 * x40
result[68] += x130 * x177
result[69] += x149 * x165 * x64
result[70] += x150 * x164 * x70
result[71] += x150 * x163 * x73
result[72] += x101 * x142 * x178
result[73] += x178 * x4 * x57
result[74] += x176 * x4 * x75
result[75] += x143 * x180
result[76] += x146 * x181 * x40
result[77] += x146 * x183
result[78] += x156 * x5 * x89
result[79] += x155 * x91
result[80] += x163 * x86 * x89
result[81] += x172 * x5 * x73
result[82] += x171 * x70
result[83] += x177 * x64
result[84] += x181 * x49 * x5
result[85] += x181 * x57
result[86] += x183 * x49
result[87] += x184 * x5
result[88] += x184 * x40
result[89] += x37 * (
x0 * (4.0 * x152 * x175 + 4.0 * x173 + x175 * x179 + x180) + x103 * x182
)
[docs]
@numba.jit(
func_type.signature,
nopython=True,
nogil=True,
fastmath=True,
cache=True,
)
def diag_quadrupole3d_13(ax, da, A, bx, db, B, R, result):
"""See docstring of diag_quadrupole3d_31."""
# Call equivalent function and write to result
tmp = numpy.zeros_like(result)
diag_quadrupole3d_31(bx, db, B, ax, da, A, R, tmp)
result[:] += numpy.transpose(tmp.reshape(3, 10, 3), axes=(0, 2, 1)).flatten()
[docs]
@numba.jit(
func_type.signature,
nopython=True,
nogil=True,
fastmath=True,
cache=True,
)
def diag_quadrupole3d_41(ax, da, A, bx, db, B, R, result):
"""Cartesian 3D (gp) quadrupole moment integrals
for operators x², y² and z². The origin is at R.
Generated code; DO NOT modify by hand!"""
x0 = 0.5 / (ax + bx)
x1 = (ax + bx) ** (-1.0)
x2 = -x1 * (ax * A[0] + bx * B[0])
x3 = -x2 - A[0]
x4 = ax * bx * x1
x5 = numpy.exp(-x4 * (A[0] - B[0]) ** 2)
x6 = 1.77245385090551603 * numpy.sqrt(x1)
x7 = x5 * x6
x8 = x0 * x7
x9 = -x2 - B[0]
x10 = -x2 - R[0]
x11 = x10 * x7
x12 = x11 * x9
x13 = x12 + x8
x14 = x13 * x3
x15 = 2.0 * x14
x16 = x7 * x9
x17 = x0 * (x11 + x16)
x18 = x3 * x7
x19 = x0 * (x11 + x18)
x20 = x10 * x18
x21 = x20 + x8
x22 = x21 * x3
x23 = x19 + x22
x24 = x0 * (x16 + x18)
x25 = x18 * x9
x26 = x25 + x8
x27 = x26 * x3
x28 = x24 + x27
x29 = 2.0 * x0
x30 = 3.0 * x8
x31 = x0 * (x12 + x20 + x25 + x30)
x32 = x14 + x17
x33 = x3 * x32
x34 = 2.0 * x3
x35 = x10 * x13
x36 = x10 * x21
x37 = x19 + x36
x38 = x0 * (x15 + 3.0 * x17 + x35 + x37)
x39 = x10 * x32
x40 = x31 + x39
x41 = x3 * x40
x42 = x10**2 * x7
x43 = x11 * x34 + x30
x44 = x0 * (x42 + x43)
x45 = x3 * x37
x46 = x44 + x45
x47 = 2.0 * x0 * (2.0 * x19 + x22 + x36) + x3 * x46
x48 = x38 + x41
x49 = x0 * (4.0 * x31 + 2.0 * x33 + 2.0 * x39 + x46) + x3 * x48
x50 = da * db
x51 = 0.0975900072948533179
x52 = x50 * x51
x53 = numpy.exp(-x4 * (A[1] - B[1]) ** 2)
x54 = numpy.exp(-x4 * (A[2] - B[2]) ** 2)
x55 = 3.14159265358979324 * x1 * x54
x56 = x53 * x55
x57 = x52 * x56
x58 = -x1 * (ax * A[1] + bx * B[1])
x59 = -x58 - B[1]
x60 = x3**2 * x7
x61 = x57 * (x0 * (x23 * x34 + x29 * (x43 + x60) + 3.0 * x44 + 3.0 * x45) + x3 * x47)
x62 = -x1 * (ax * A[2] + bx * B[2])
x63 = -x62 - B[2]
x64 = -x58 - A[1]
x65 = 0.258198889747161126
x66 = x50 * x65
x67 = x64 * x66
x68 = x49 * x56
x69 = x0 * x6
x70 = x53 * x69
x71 = x53 * x6
x72 = x64 * x71
x73 = x59 * x72
x74 = x70 + x73
x75 = x54 * x6
x76 = x47 * x66
x77 = x56 * x76
x78 = -x62 - A[2]
x79 = x66 * x78
x80 = x54 * x69
x81 = x75 * x78
x82 = x63 * x81
x83 = x80 + x82
x84 = x64**2 * x71
x85 = x70 + x84
x86 = 0.333333333333333333 * x50
x87 = x85 * x86
x88 = x59 * x71
x89 = x0 * (x72 + x88)
x90 = x64 * x74
x91 = x89 + x90
x92 = x75 * x86
x93 = x63 * x75
x94 = 1.73205080756887729
x95 = x78 * x86 * x94
x96 = x81 * x94
x97 = x46 * x86
x98 = x72 * x94
x99 = x75 * x78**2
x100 = x80 + x99
x101 = x100 * x86
x102 = x0 * (x81 + x93)
x103 = x78 * x83
x104 = x102 + x103
x105 = x104 * x86
x106 = x29 * x72 + x64 * x85
x107 = x66 * x75
x108 = 2.0 * x64
x109 = 3.0 * x70
x110 = x109 + x84
x111 = x0 * (x108 * x88 + x110) + x64 * x91
x112 = x37 * x66
x113 = x37 * x94
x114 = x81 * x86
x115 = x100 * x78 + x29 * x81
x116 = x66 * x71
x117 = 2.0 * x78
x118 = 3.0 * x80
x119 = x118 + x99
x120 = x0 * (x117 * x93 + x119) + x104 * x78
x121 = x0 * (x109 + 3.0 * x84) + x106 * x64
x122 = x17 + x35
x123 = x122 * x52
x124 = x0 * (x106 + 3.0 * x89 + 3.0 * x90) + x111 * x64
x125 = x42 + x8
x126 = x125 * x50
x127 = x126 * x51
x128 = x122 * x66
x129 = x126 * x65
x130 = x0 * (x118 + 3.0 * x99) + x115 * x78
x131 = x0 * (3.0 * x102 + 3.0 * x103 + x115) + x120 * x78
x132 = -x58 - R[1]
x133 = x132**2 * x71
x134 = x133 + x70
x135 = x60 + x8
x136 = x135 * x3 + x18 * x29
x137 = x0 * (x16 * x34 + x30 + x60) + x28 * x3
x138 = x0 * (x136 + 3.0 * x24 + 3.0 * x27) + x137 * x3
x139 = x52 * x75
x140 = x132 * x71
x141 = x0 * (x140 + x88)
x142 = x132 * x88
x143 = x142 + x70
x144 = x132 * x143
x145 = x141 + x144
x146 = x0 * (x30 + 3.0 * x60) + x136 * x3
x147 = x134 * x52
x148 = x0 * (x140 + x72)
x149 = x132 * x72
x150 = x149 + x70
x151 = x132 * x150
x152 = x148 + x151
x153 = x0 * (x109 + x142 + x149 + x73)
x154 = x143 * x64
x155 = x141 + x154
x156 = x132 * x155
x157 = x153 + x156
x158 = x136 * x66
x159 = x134 * x66
x160 = x108 * x140
x161 = x0 * (x109 + x133 + x160)
x162 = x152 * x64
x163 = x161 + x162
x164 = 2.0 * x154
x165 = x0 * (3.0 * x141 + x144 + x152 + x164)
x166 = x157 * x64
x167 = x165 + x166
x168 = x135 * x86
x169 = x152 * x94
x170 = x150 * x64
x171 = 2.0 * x0 * (2.0 * x148 + x151 + x170) + x163 * x64
x172 = x155 * x64
x173 = x0 * (4.0 * x153 + 2.0 * x156 + x163 + 2.0 * x172) + x167 * x64
x174 = x5 * x55
x175 = x173 * x174
x176 = x3 * x66
x177 = x171 * x174
x178 = x163 * x86
x179 = x18 * x94
x180 = x115 * x66
x181 = x148 + x170
x182 = x5 * x52
x183 = x182 * x55
x184 = x183 * (
x0 * (x108 * x181 + 3.0 * x161 + 3.0 * x162 + x29 * (x110 + x160)) + x171 * x64
)
x185 = x66 * x7
x186 = x52 * x7
x187 = -x62 - R[2]
x188 = x187**2 * x75
x189 = x188 + x80
x190 = x52 * x71
x191 = x189 * x52
x192 = x187 * x75
x193 = x0 * (x192 + x93)
x194 = x187 * x93
x195 = x194 + x80
x196 = x187 * x195
x197 = x193 + x196
x198 = x189 * x66
x199 = x0 * (x192 + x81)
x200 = x187 * x81
x201 = x200 + x80
x202 = x187 * x201
x203 = x199 + x202
x204 = x0 * (x118 + x194 + x200 + x82)
x205 = x195 * x78
x206 = x193 + x205
x207 = x187 * x206
x208 = x204 + x207
x209 = x189 * x86
x210 = x203 * x94
x211 = x210 * x86
x212 = x117 * x192
x213 = x0 * (x118 + x188 + x212)
x214 = x203 * x78
x215 = x213 + x214
x216 = x215 * x86
x217 = 2.0 * x205
x218 = x0 * (3.0 * x193 + x196 + x203 + x217)
x219 = x208 * x78
x220 = x218 + x219
x221 = x106 * x66
x222 = 3.14159265358979324 * x1 * x53
x223 = x222 * x5
x224 = x201 * x78
x225 = 2.0 * x0 * (2.0 * x199 + x202 + x224) + x215 * x78
x226 = x223 * x225
x227 = x206 * x78
x228 = x0 * (4.0 * x204 + 2.0 * x207 + x215 + 2.0 * x227) + x220 * x78
x229 = x223 * x228
x230 = x199 + x224
x231 = x182 * x222
x232 = x231 * (
x0 * (x117 * x230 + 3.0 * x213 + 3.0 * x214 + x29 * (x119 + x212)) + x225 * x78
)
# 135 item(s)
result[0] += x57 * (
x0
* (
x29 * (x15 + 2.0 * x17 + x23 + x28)
+ x34 * (x31 + x33)
+ 3.0 * x38
+ 3.0 * x41
+ x47
)
+ x3 * x49
)
result[1] += x59 * x61
result[2] += x61 * x63
result[3] += x67 * x68
result[4] += x74 * x75 * x76
result[5] += x63 * x64 * x77
result[6] += x68 * x79
result[7] += x59 * x77 * x78
result[8] += x71 * x76 * x83
result[9] += x48 * x75 * x87
result[10] += x46 * x91 * x92
result[11] += x46 * x87 * x93
result[12] += x48 * x56 * x64 * x95
result[13] += x74 * x96 * x97
result[14] += x83 * x97 * x98
result[15] += x101 * x48 * x71
result[16] += x101 * x46 * x88
result[17] += x105 * x46 * x71
result[18] += x106 * x107 * x40
result[19] += x107 * x111 * x37
result[20] += x106 * x112 * x93
result[21] += x40 * x87 * x96
result[22] += x113 * x114 * x91
result[23] += x113 * x83 * x87
result[24] += x101 * x40 * x98
result[25] += x101 * x113 * x74
result[26] += x105 * x113 * x72
result[27] += x115 * x116 * x40
result[28] += x112 * x115 * x88
result[29] += x116 * x120 * x37
result[30] += x121 * x123 * x75
result[31] += x124 * x127 * x75
result[32] += x121 * x127 * x93
result[33] += x106 * x128 * x81
result[34] += x111 * x129 * x81
result[35] += x106 * x129 * x83
result[36] += x101 * x122 * x85
result[37] += x101 * x125 * x91
result[38] += x105 * x125 * x85
result[39] += x115 * x128 * x72
result[40] += x115 * x129 * x74
result[41] += x120 * x129 * x72
result[42] += x123 * x130 * x71
result[43] += x127 * x130 * x88
result[44] += x127 * x131 * x71
result[45] += x134 * x138 * x139
result[46] += x139 * x145 * x146
result[47] += x146 * x147 * x93
result[48] += x107 * x137 * x152
result[49] += x107 * x136 * x157
result[50] += x152 * x158 * x93
result[51] += x137 * x159 * x81
result[52] += x145 * x158 * x81
result[53] += x136 * x159 * x83
result[54] += x163 * x28 * x92
result[55] += x167 * x168 * x75
result[56] += x163 * x168 * x93
result[57] += x114 * x169 * x28
result[58] += x157 * x168 * x96
result[59] += x168 * x169 * x83
result[60] += x101 * x134 * x28
result[61] += x101 * x135 * x145
result[62] += x105 * x134 * x135
result[63] += x107 * x171 * x26
result[64] += x175 * x176
result[65] += x176 * x177 * x63
result[66] += x178 * x26 * x96
result[67] += x167 * x174 * x3 * x95
result[68] += x178 * x179 * x83
result[69] += x101 * x169 * x26
result[70] += x101 * x157 * x179
result[71] += x105 * x169 * x18
result[72] += x115 * x159 * x26
result[73] += x145 * x18 * x180
result[74] += x120 * x159 * x18
result[75] += x184 * x9
result[76] += x183 * (
x0
* (
x108 * (x153 + x172)
+ 3.0 * x165
+ 3.0 * x166
+ x171
+ x29 * (2.0 * x141 + x164 + x181 + x91)
)
+ x173 * x64
)
result[77] += x184 * x63
result[78] += x177 * x79 * x9
result[79] += x175 * x79
result[80] += x171 * x185 * x83
result[81] += x101 * x16 * x163
result[82] += x101 * x167 * x7
result[83] += x105 * x163 * x7
result[84] += x152 * x16 * x180
result[85] += x115 * x157 * x185
result[86] += x120 * x152 * x185
result[87] += x130 * x147 * x16
result[88] += x130 * x145 * x186
result[89] += x131 * x134 * x186
result[90] += x138 * x189 * x190
result[91] += x146 * x191 * x88
result[92] += x146 * x190 * x197
result[93] += x137 * x198 * x72
result[94] += x136 * x198 * x74
result[95] += x158 * x197 * x72
result[96] += x116 * x137 * x203
result[97] += x158 * x203 * x88
result[98] += x116 * x136 * x208
result[99] += x209 * x28 * x85
result[100] += x135 * x209 * x91
result[101] += x135 * x197 * x87
result[102] += x211 * x28 * x72
result[103] += x168 * x210 * x74
result[104] += x168 * x208 * x98
result[105] += x216 * x28 * x71
result[106] += x168 * x215 * x88
result[107] += x168 * x220 * x71
result[108] += x106 * x198 * x26
result[109] += x111 * x18 * x198
result[110] += x18 * x197 * x221
result[111] += x210 * x26 * x87
result[112] += x18 * x211 * x91
result[113] += x179 * x208 * x87
result[114] += x216 * x26 * x98
result[115] += x179 * x216 * x74
result[116] += x220 * x223 * x3 * x64 * x86 * x94
result[117] += x116 * x225 * x26
result[118] += x176 * x226 * x59
result[119] += x176 * x229
result[120] += x121 * x16 * x191
result[121] += x124 * x186 * x189
result[122] += x121 * x186 * x197
result[123] += x16 * x203 * x221
result[124] += x111 * x185 * x203
result[125] += x106 * x185 * x208
result[126] += x16 * x215 * x87
result[127] += x216 * x7 * x91
result[128] += x220 * x7 * x87
result[129] += x226 * x67 * x9
result[130] += x185 * x225 * x74
result[131] += x229 * x67
result[132] += x232 * x9
result[133] += x232 * x59
result[134] += x231 * (
x0
* (
x117 * (x204 + x227)
+ 3.0 * x218
+ 3.0 * x219
+ x225
+ x29 * (x104 + 2.0 * x193 + x217 + x230)
)
+ x228 * x78
)
[docs]
@numba.jit(
func_type.signature,
nopython=True,
nogil=True,
fastmath=True,
cache=True,
)
def diag_quadrupole3d_14(ax, da, A, bx, db, B, R, result):
"""See docstring of diag_quadrupole3d_41."""
# Call equivalent function and write to result
tmp = numpy.zeros_like(result)
diag_quadrupole3d_41(bx, db, B, ax, da, A, R, tmp)
result[:] += numpy.transpose(tmp.reshape(3, 15, 3), axes=(0, 2, 1)).flatten()
[docs]
@numba.jit(
func_type.signature,
nopython=True,
nogil=True,
fastmath=True,
cache=True,
)
def diag_quadrupole3d_22(ax, da, A, bx, db, B, R, result):
"""Cartesian 3D (dd) quadrupole moment integrals
for operators x², y² and z². The origin is at R.
Generated code; DO NOT modify by hand!"""
x0 = (ax + bx) ** (-1.0)
x1 = 3.0 * x0
x2 = x0 * (ax * A[0] + bx * B[0])
x3 = -x2
x4 = x3 + A[0]
x5 = x3 + B[0]
x6 = x4 * x5
x7 = 2.0 * x6
x8 = x3 + R[0]
x9 = 2.0 * x8
x10 = x4 * x9
x11 = x5 * x8
x12 = 2.0 * x11
x13 = x0 * (x1 + x10 + x12 + x7)
x14 = -2.0 * x2
x15 = x14 + R[0]
x16 = x15 + B[0]
x17 = x0 * x16
x18 = x0 + x12
x19 = x18 * x4
x20 = x17 + x19
x21 = 4.0 * x20
x22 = x8**2
x23 = x1 + 2.0 * x22
x24 = x18 * x8
x25 = x17 + x24
x26 = x0 * (4.0 * x11 + x23) + 2.0 * x25 * x5
x27 = x0 * (x15 + A[0]) + x8 * (x0 + x10)
x28 = x0 * (x1 * x16 + 2.0 * x19 + x24 + x27)
x29 = x13 + x20 * x9
x30 = x28 + x29 * x5
x31 = 2.0 * x4
x32 = ax * bx * x0
x33 = (
5.56832799683170785
* da
* db
* numpy.exp(-x32 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2))
)
x34 = x0**1.5 * x33
x35 = 0.0416666666666666667 * x34
x36 = x0 * (ax * A[1] + bx * B[1])
x37 = -x36
x38 = x37 + B[1]
x39 = x34 * x38
x40 = 1.73205080756887729
x41 = 0.0833333333333333333 * x40
x42 = x41 * (x28 + x29 * x4)
x43 = x0 * (ax * A[2] + bx * B[2])
x44 = -x43
x45 = x44 + B[2]
x46 = x34 * x45
x47 = (
0.0833333333333333333 * x0 * (x23 + 4.0 * x4 * x8)
+ 0.0833333333333333333 * x27 * x31
)
x48 = x38**2
x49 = 0.5 * x0
x50 = x0**1.5 * x33
x51 = x50 * (x48 + x49)
x52 = x39 * x40
x53 = x45**2
x54 = x50 * (x49 + x53)
x55 = x37 + A[1]
x56 = x34 * x41
x57 = x30 * x56
x58 = x38 * x55
x59 = x50 * (x49 + x58)
x60 = 0.25 * x29
x61 = -2.0 * x36
x62 = x61 + B[1]
x63 = x0 * (x62 + A[1])
x64 = 2.0 * x58
x65 = x0 + x64
x66 = x38 * x65 + x63
x67 = 0.0833333333333333333 * x50
x68 = x40 * x67
x69 = x27 * x68
x70 = 0.5 * x27
x71 = 0.166666666666666667 * x40
x72 = x27 * x71
x73 = x44 + A[2]
x74 = x45 * x73
x75 = x49 + x74
x76 = x50 * x75
x77 = -2.0 * x43
x78 = x77 + B[2]
x79 = x0 * (x78 + A[2])
x80 = 2.0 * x74
x81 = x0 + x80
x82 = x45 * x81 + x79
x83 = x49 + x55**2
x84 = x26 * x67
x85 = x55 * x65 + x63
x86 = x25 * x68
x87 = x50 * x71
x88 = x45 * x87
x89 = 2.0 * x55
x90 = x0 * (x1 + 2.0 * x48 + 4.0 * x58) + x66 * x89
x91 = x22 + x49
x92 = x67 * x91
x93 = 0.333333333333333333 * x91
x94 = x56 * x73
x95 = 0.5 * x25
x96 = x87 * x91
x97 = x49 + x73**2
x98 = x87 * x97
x99 = x73 * x81 + x79
x100 = 2.0 * x73
x101 = x0 * (x1 + 2.0 * x53 + 4.0 * x74) + x100 * x82
x102 = x5**2
x103 = x0 * (x14 + A[0] + B[0])
x104 = x0 + x7
x105 = x103 + x104 * x5
x106 = x0 * (x1 + 2.0 * x102 + 4.0 * x6) + x105 * x31
x107 = x37 + R[1]
x108 = x107**2
x109 = x108 + x49
x110 = x109 * x67
x111 = x103 + x104 * x4
x112 = x62 + R[1]
x113 = x0 * x112
x114 = x107 * x38
x115 = 2.0 * x114
x116 = x0 + x115
x117 = x107 * x116
x118 = x113 + x117
x119 = x118 * x68
x120 = x4**2 + x49
x121 = x1 + 2.0 * x108
x122 = x0 * (4.0 * x114 + x121) + 2.0 * x118 * x38
x123 = x122 * x67
x124 = 0.333333333333333333 * x109
x125 = x107 * x89
x126 = x0 * (x61 + A[1] + R[1]) + x107 * (x0 + x125)
x127 = x126 * x68
x128 = x0 * (x1 + x115 + x125 + x64)
x129 = x116 * x55
x130 = x113 + x129
x131 = x107 * x130
x132 = x128 + 2.0 * x131
x133 = 0.25 * x132
x134 = x49 + x6
x135 = x134 * x50
x136 = 0.5 * x135
x137 = x0 * (x1 * x112 + x117 + x126 + 2.0 * x129)
x138 = x132 * x38 + x137
x139 = x138 * x56
x140 = x126 * x71
x141 = x109 * x87
x142 = 0.5 * x76
x143 = x0 * (4.0 * x107 * x55 + x121) + x126 * x89
x144 = x102 + x49
x145 = x144 * x67
x146 = x132 * x55 + x137
x147 = x5 * x56
x148 = 0.0833333333333333333 * x143
x149 = x144 * x50
x150 = x34 * x5
x151 = x44 + R[2]
x152 = x151**2
x153 = x152 + x49
x154 = x153 * x67
x155 = x38 * x87
x156 = x78 + R[2]
x157 = x0 * x156
x158 = x151 * x45
x159 = 2.0 * x158
x160 = x0 + x159
x161 = x151 * x160
x162 = x157 + x161
x163 = x162 * x68
x164 = 0.333333333333333333 * x153
x165 = x1 + 2.0 * x152
x166 = x0 * (4.0 * x158 + x165) + 2.0 * x162 * x45
x167 = x166 * x67
x168 = x153 * x87
x169 = 0.5 * x59
x170 = x100 * x151
x171 = x0 * (x77 + A[2] + R[2]) + x151 * (x0 + x170)
x172 = x171 * x68
x173 = x0 * (x1 + x159 + x170 + x80)
x174 = x160 * x73
x175 = x157 + x174
x176 = x151 * x175
x177 = x173 + 2.0 * x176
x178 = 0.25 * x177
x179 = x171 * x71
x180 = x0 * (x1 * x156 + x161 + x171 + 2.0 * x174)
x181 = x177 * x45 + x180
x182 = x181 * x56
x183 = x0 * (4.0 * x151 * x73 + x165) + x100 * x171
x184 = 0.0833333333333333333 * x183
x185 = x177 * x73 + x180
# 108 item(s)
result[0] += x35 * (x0 * (4.0 * x13 + x21 * x5 + x21 * x8 + x26) + x30 * x31)
result[1] += x39 * x42
result[2] += x42 * x46
result[3] += x47 * x51
result[4] += x45 * x47 * x52
result[5] += x47 * x54
result[6] += x55 * x57
result[7] += x59 * x60
result[8] += x46 * x55 * x60
result[9] += x66 * x69
result[10] += x45 * x59 * x70
result[11] += x54 * x55 * x72
result[12] += x57 * x73
result[13] += x39 * x60 * x73
result[14] += x60 * x76
result[15] += x51 * x72 * x73
result[16] += x38 * x70 * x76
result[17] += x69 * x82
result[18] += x83 * x84
result[19] += x85 * x86
result[20] += x25 * x83 * x88
result[21] += x90 * x92
result[22] += x85 * x88 * x91
result[23] += x54 * x83 * x93
result[24] += x26 * x55 * x94
result[25] += x59 * x73 * x95
result[26] += x55 * x76 * x95
result[27] += x66 * x73 * x96
result[28] += x59 * x75 * x91
result[29] += x55 * x82 * x96
result[30] += x84 * x97
result[31] += x25 * x38 * x98
result[32] += x86 * x99
result[33] += x51 * x93 * x97
result[34] += x38 * x96 * x99
result[35] += x101 * x92
result[36] += x106 * x110
result[37] += x111 * x119
result[38] += x109 * x111 * x88
result[39] += x120 * x123
result[40] += x118 * x120 * x88
result[41] += x120 * x124 * x54
result[42] += x105 * x127
result[43] += x133 * x135
result[44] += x126 * x136 * x45
result[45] += x139 * x4
result[46] += x133 * x4 * x46
result[47] += x140 * x4 * x54
result[48] += x105 * x141 * x73
result[49] += x118 * x136 * x73
result[50] += x109 * x134 * x76
result[51] += x122 * x4 * x94
result[52] += x118 * x142 * x4
result[53] += x141 * x4 * x82
result[54] += x143 * x145
result[55] += x146 * x147
result[56] += x148 * x40 * x46 * x5
result[57] += x35 * (
x0 * (x122 + 4.0 * x128 + 4.0 * x130 * x38 + 4.0 * x131) + x138 * x89
)
result[58] += x146 * x41 * x46
result[59] += x148 * x54
result[60] += x140 * x149 * x73
result[61] += x133 * x150 * x73
result[62] += x126 * x142 * x5
result[63] += x139 * x73
result[64] += x133 * x76
result[65] += x127 * x82
result[66] += x124 * x149 * x97
result[67] += x118 * x5 * x98
result[68] += x141 * x5 * x99
result[69] += x123 * x97
result[70] += x119 * x99
result[71] += x101 * x110
result[72] += x106 * x154
result[73] += x111 * x153 * x155
result[74] += x111 * x163
result[75] += x120 * x164 * x51
result[76] += x120 * x155 * x162
result[77] += x120 * x167
result[78] += x105 * x168 * x55
result[79] += x134 * x153 * x59
result[80] += x136 * x162 * x55
result[81] += x168 * x4 * x66
result[82] += x162 * x169 * x4
result[83] += x166 * x4 * x55 * x56
result[84] += x105 * x172
result[85] += x136 * x171 * x38
result[86] += x135 * x178
result[87] += x179 * x4 * x51
result[88] += x178 * x39 * x4
result[89] += x182 * x4
result[90] += x149 * x164 * x83
result[91] += x168 * x5 * x85
result[92] += x162 * x5 * x83 * x87
result[93] += x154 * x90
result[94] += x163 * x85
result[95] += x167 * x83
result[96] += x149 * x179 * x55
result[97] += x169 * x171 * x5
result[98] += x150 * x178 * x55
result[99] += x172 * x66
result[100] += x178 * x59
result[101] += x182 * x55
result[102] += x145 * x183
result[103] += x184 * x5 * x52
result[104] += x147 * x185
result[105] += x184 * x51
result[106] += x185 * x39 * x41
result[107] += x35 * (
x0 * (x166 + 4.0 * x173 + 4.0 * x175 * x45 + 4.0 * x176) + x100 * x181
)
[docs]
@numba.jit(
func_type.signature,
nopython=True,
nogil=True,
fastmath=True,
cache=True,
)
def diag_quadrupole3d_32(ax, da, A, bx, db, B, R, result):
"""Cartesian 3D (fd) quadrupole moment integrals
for operators x², y² and z². The origin is at R.
Generated code; DO NOT modify by hand!"""
x0 = (ax + bx) ** (-1.0)
x1 = x0 * (ax * A[0] + bx * B[0])
x2 = -x1
x3 = x2 + A[0]
x4 = x2 + B[0]
x5 = -2.0 * x1
x6 = x5 + R[0]
x7 = x6 + B[0]
x8 = x0 * x7
x9 = x2 + R[0]
x10 = x4 * x9
x11 = 2.0 * x10
x12 = x0 + x11
x13 = x12 * x3
x14 = x13 + x8
x15 = 4.0 * x14
x16 = x9**2
x17 = 3.0 * x0
x18 = 2.0 * x16 + x17
x19 = x12 * x9
x20 = x19 + x8
x21 = 2.0 * x4
x22 = x0 * (4.0 * x10 + x18) + x20 * x21
x23 = x3 * x4
x24 = 2.0 * x23
x25 = 2.0 * x9
x26 = x25 * x3
x27 = x0 * (x11 + x17 + x24 + x26)
x28 = x15 * x9 + 4.0 * x27
x29 = x0 * (x6 + A[0])
x30 = x0 + x26
x31 = x30 * x9
x32 = x29 + x31
x33 = 2.0 * x13 + x17 * x7
x34 = x0 * (x19 + x32 + x33)
x35 = x14 * x25 + x27
x36 = x35 * x4
x37 = x34 + x36
x38 = 2.0 * x3
x39 = x0 * (x15 * x4 + x22 + x28) + x37 * x38
x40 = x0 * (x5 + A[0] + B[0])
x41 = x0 + x24
x42 = x4 * x41
x43 = x40 + x42
x44 = x3 * x35
x45 = 2.0 * x0
x46 = 2.2360679774997897
x47 = ax * bx * x0
x48 = (
5.56832799683170785
* da
* db
* numpy.exp(-x47 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2))
)
x49 = x0**1.5 * x48
x50 = 0.00833333333333333333 * x49
x51 = x46 * x50
x52 = x0 * (ax * A[1] + bx * B[1])
x53 = -x52
x54 = x53 + B[1]
x55 = x0 * (x18 + 4.0 * x3 * x9) + x32 * x38
x56 = x34 + x44
x57 = 3.87298334620741689
x58 = x50 * x57
x59 = x58 * (x0 * (x15 * x3 + x28 + x55) + x38 * x56)
x60 = x0 * (ax * A[2] + bx * B[2])
x61 = -x60
x62 = x61 + B[2]
x63 = 0.0166666666666666667 * x3 * x55 + 0.0166666666666666667 * x45 * (
2.0 * x29 + x3 * x30 + x31
)
x64 = x54**2
x65 = 0.5 * x0
x66 = x64 + x65
x67 = x0**1.5 * x48
x68 = x66 * x67
x69 = x46 * x68
x70 = x49 * x62
x71 = x57 * x70
x72 = x62**2
x73 = x65 + x72
x74 = x67 * x73
x75 = x46 * x74
x76 = x53 + A[1]
x77 = 0.0416666666666666667 * x49
x78 = x39 * x77
x79 = x54 * x76
x80 = x65 + x79
x81 = 1.73205080756887729
x82 = 0.0833333333333333333 * x67
x83 = x81 * x82
x84 = x56 * x83
x85 = 0.0833333333333333333 * x81
x86 = x56 * x85
x87 = -2.0 * x52
x88 = x87 + B[1]
x89 = x0 * (x88 + A[1])
x90 = 2.0 * x79
x91 = x0 + x90
x92 = x54 * x91
x93 = x89 + x92
x94 = 0.0416666666666666667 * x67
x95 = x55 * x94
x96 = x55 * x83
x97 = x55 * x82
x98 = x61 + A[2]
x99 = x49 * x98
x100 = x62 * x98
x101 = x100 + x65
x102 = -2.0 * x60
x103 = x102 + B[2]
x104 = x0 * (x103 + A[2])
x105 = 2.0 * x100
x106 = x0 + x105
x107 = x106 * x62
x108 = x104 + x107
x109 = x76**2
x110 = x109 + x65
x111 = x37 * x82
x112 = x76 * x91
x113 = x112 + x89
x114 = x81 * x94
x115 = x114 * x35
x116 = x62 * x83
x117 = x17 + 4.0 * x79
x118 = 2.0 * x76
x119 = x0 * (x117 + 2.0 * x64) + x118 * x93
x120 = x32 * x94
x121 = 0.166666666666666667 * x32
x122 = x85 * x99
x123 = x67 * x80
x124 = 0.25 * x35
x125 = x101 * x67
x126 = x32 * x83
x127 = 0.5 * x123
x128 = x98**2
x129 = x128 + x65
x130 = x129 * x83
x131 = x106 * x98
x132 = x104 + x131
x133 = 4.0 * x100 + x17
x134 = 2.0 * x98
x135 = x0 * (x133 + 2.0 * x72) + x108 * x134
x136 = 0.0166666666666666667 * x46
x137 = x136 * x22
x138 = 1.5 * x0
x139 = x109 + x138
x140 = x67 * x76
x141 = x139 * x140
x142 = x0 * (2.0 * x109 + x117) + x113 * x118
x143 = x57 * x67
x144 = 0.00833333333333333333 * x143
x145 = x144 * x20
x146 = x139 * x76
x147 = 0.0333333333333333333 * x143
x148 = x147 * x20
x149 = x119 * x76 + x45 * (x112 + 2.0 * x89 + x92)
x150 = x16 + x65
x151 = x150 * x67
x152 = x136 * x151
x153 = 0.0166666666666666667 * x143
x154 = x150 * x153
x155 = 0.0666666666666666667 * x150
x156 = x82 * x98
x157 = x20 * x83
x158 = 0.166666666666666667 * x110
x159 = x125 * x81
x160 = 0.166666666666666667 * x150
x161 = 0.166666666666666667 * x151
x162 = x76 * x82
x163 = 0.166666666666666667 * x129
x164 = x123 * x81
x165 = x128 + x138
x166 = x67 * x98
x167 = x165 * x166
x168 = x165 * x98
x169 = x0 * (2.0 * x128 + x133) + x132 * x134
x170 = x135 * x98 + x45 * (2.0 * x104 + x107 + x131)
x171 = x4**2
x172 = x17 + 4.0 * x23
x173 = x0 * (2.0 * x171 + x172) + x38 * x43
x174 = x3 * x41
x175 = x173 * x3 + x45 * (x174 + 2.0 * x40 + x42)
x176 = x53 + R[1]
x177 = x176**2
x178 = x177 + x65
x179 = x178 * x67
x180 = x136 * x179
x181 = x3**2
x182 = x174 + x40
x183 = x0 * (x172 + 2.0 * x181) + x182 * x38
x184 = x88 + R[1]
x185 = x0 * x184
x186 = x176 * x54
x187 = 2.0 * x186
x188 = x0 + x187
x189 = x176 * x188
x190 = x185 + x189
x191 = x144 * x190
x192 = x153 * x178
x193 = x17 + 2.0 * x177
x194 = 2.0 * x54
x195 = x0 * (4.0 * x186 + x193) + x190 * x194
x196 = x136 * x195
x197 = x3 * (x138 + x181)
x198 = x197 * x67
x199 = x147 * x190
x200 = 0.0666666666666666667 * x197
x201 = x0 * (x87 + A[1] + R[1])
x202 = x118 * x176
x203 = x0 + x202
x204 = x176 * x203
x205 = x201 + x204
x206 = x205 * x94
x207 = x0 * (x17 + x187 + x202 + x90)
x208 = x188 * x76
x209 = x185 + x208
x210 = x176 * x209
x211 = x207 + 2.0 * x210
x212 = x114 * x211
x213 = x181 + x65
x214 = x17 * x184 + 2.0 * x208
x215 = x0 * (x189 + x205 + x214)
x216 = x211 * x54
x217 = x215 + x216
x218 = x217 * x82
x219 = 0.166666666666666667 * x213
x220 = x83 * x98
x221 = 0.166666666666666667 * x182
x222 = 4.0 * x76
x223 = x0 * (x176 * x222 + x193) + x118 * x205
x224 = x223 * x94
x225 = x23 + x65
x226 = x211 * x76
x227 = x215 + x226
x228 = x227 * x83
x229 = 4.0 * x207 + 4.0 * x210
x230 = x0 * (x195 + 4.0 * x209 * x54 + x229) + x118 * x217
x231 = x230 * x77
x232 = x3 * x85
x233 = x3 * x82
x234 = 0.25 * x211
x235 = x3 * x83
x236 = x225 * x81
x237 = x236 * x67
x238 = 0.166666666666666667 * x236
x239 = x223 * x76 + x45 * (2.0 * x201 + x203 * x76 + x204)
x240 = x171 + x65
x241 = x240 * x67
x242 = x136 * x241
x243 = x58 * (x0 * (x209 * x222 + x223 + x229) + x118 * x227)
x244 = 0.0166666666666666667 * x239
x245 = x4 * x83
x246 = 0.0666666666666666667 * x46
x247 = x61 + R[2]
x248 = x247**2
x249 = x248 + x65
x250 = x249 * x67
x251 = x136 * x250
x252 = x153 * x249
x253 = x103 + R[2]
x254 = x0 * x253
x255 = x247 * x62
x256 = 2.0 * x255
x257 = x0 + x256
x258 = x247 * x257
x259 = x254 + x258
x260 = x144 * x259
x261 = x17 + 2.0 * x248
x262 = 2.0 * x62
x263 = x0 * (4.0 * x255 + x261) + x259 * x262
x264 = x136 * x263
x265 = x182 * x83
x266 = x259 * x76
x267 = x0 * (x102 + A[2] + R[2])
x268 = x134 * x247
x269 = x0 + x268
x270 = x247 * x269
x271 = x267 + x270
x272 = x271 * x94
x273 = x0 * (x105 + x17 + x256 + x268)
x274 = x257 * x98
x275 = x254 + x274
x276 = x247 * x275
x277 = x273 + 2.0 * x276
x278 = x114 * x277
x279 = x54 * x83
x280 = x17 * x253 + 2.0 * x274
x281 = x0 * (x258 + x271 + x280)
x282 = x277 * x62
x283 = x281 + x282
x284 = x283 * x82
x285 = 0.25 * x277
x286 = x232 * x49
x287 = 4.0 * x98
x288 = x0 * (x247 * x287 + x261) + x134 * x271
x289 = x288 * x94
x290 = x277 * x98
x291 = x281 + x290
x292 = x291 * x83
x293 = 4.0 * x273 + 4.0 * x276
x294 = x0 * (x263 + 4.0 * x275 * x62 + x293) + x134 * x283
x295 = x294 * x77
x296 = x4 * x49
x297 = x288 * x98 + x45 * (2.0 * x267 + x269 * x98 + x270)
x298 = 0.0166666666666666667 * x297
x299 = x58 * (x0 * (x275 * x287 + x288 + x293) + x134 * x291)
# 180 item(s)
result[0] += -x51 * (
x3 * x39
+ x45
* (x0 * (x12 * x4 + x33 + x43) + x3 * (x14 * x21 + x27) + 2.0 * x34 + x36 + x44)
)
result[1] += -x54 * x59
result[2] += -x59 * x62
result[3] += -x63 * x69
result[4] += -x54 * x63 * x71
result[5] += -x63 * x75
result[6] += -x76 * x78
result[7] += -x80 * x84
result[8] += -x70 * x76 * x86
result[9] += -x93 * x95
result[10] += -x62 * x80 * x96
result[11] += -x73 * x76 * x97
result[12] += -x78 * x98
result[13] += -x54 * x86 * x99
result[14] += -x101 * x84
result[15] += -x66 * x97 * x98
result[16] += -x101 * x54 * x96
result[17] += -x108 * x95
result[18] += -x110 * x111
result[19] += -x113 * x115
result[20] += -x110 * x116 * x35
result[21] += -x119 * x120
result[22] += -x113 * x116 * x32
result[23] += -x110 * x121 * x74
result[24] += -x122 * x37 * x76
result[25] += -x123 * x124 * x98
result[26] += -x124 * x125 * x76
result[27] += -x126 * x93 * x98
result[28] += -x101 * x127 * x32
result[29] += -x108 * x126 * x76
result[30] += -x111 * x129
result[31] += -x130 * x35 * x54
result[32] += -x115 * x132
result[33] += -x121 * x129 * x68
result[34] += -x126 * x132 * x54
result[35] += -x120 * x135
result[36] += -x137 * x141
result[37] += -x142 * x145
result[38] += -x146 * x148 * x62
result[39] += -x149 * x152
result[40] += -x142 * x154 * x62
result[41] += -x146 * x155 * x75
result[42] += -x110 * x156 * x22
result[43] += -x113 * x157 * x98
result[44] += -x158 * x159 * x20
result[45] += -x119 * x150 * x156
result[46] += -x113 * x159 * x160
result[47] += -x108 * x110 * x161
result[48] += -x129 * x162 * x22
result[49] += -x163 * x164 * x20
result[50] += -x132 * x157 * x76
result[51] += -x129 * x161 * x93
result[52] += -x132 * x160 * x164
result[53] += -x135 * x150 * x162
result[54] += -x137 * x167
result[55] += -x148 * x168 * x54
result[56] += -x145 * x169
result[57] += -x155 * x168 * x69
result[58] += -x154 * x169 * x54
result[59] += -x152 * x170
result[60] += -x175 * x180
result[61] += -x183 * x191
result[62] += -x183 * x192 * x62
result[63] += -x196 * x198
result[64] += -x197 * x199 * x62
result[65] += -x178 * x200 * x75
result[66] += -x173 * x206
result[67] += -x182 * x212
result[68] += -x116 * x182 * x205
result[69] += -x213 * x218
result[70] += -x116 * x211 * x213
result[71] += -x205 * x219 * x74
result[72] += -x156 * x173 * x178
result[73] += -x182 * x190 * x220
result[74] += -x159 * x178 * x221
result[75] += -x156 * x195 * x213
result[76] += -x159 * x190 * x219
result[77] += -x108 * x179 * x219
result[78] += -x224 * x43
result[79] += -x225 * x228
result[80] += -x116 * x223 * x225
result[81] += -x231 * x3
result[82] += -x227 * x232 * x70
result[83] += -x223 * x233 * x73
result[84] += -x205 * x220 * x43
result[85] += -x166 * x225 * x234
result[86] += -0.5 * x125 * x205 * x225
result[87] += -x122 * x217 * x3
result[88] += -x125 * x234 * x3
result[89] += -x108 * x205 * x235
result[90] += -x163 * x179 * x43
result[91] += -x163 * x190 * x237
result[92] += -x132 * x179 * x238
result[93] += -x129 * x195 * x233
result[94] += -x132 * x190 * x235
result[95] += -x135 * x178 * x233
result[96] += -x239 * x242
result[97] += -x243 * x4
result[98] += -x244 * x4 * x71
result[99] += -x51 * (
x230 * x76
+ x45
* (
x0 * (x188 * x54 + x214 + x93)
+ 2.0 * x215
+ x216
+ x226
+ x76 * (x194 * x209 + x207)
)
)
result[100] += -x243 * x62
result[101] += -x244 * x75
result[102] += -x156 * x223 * x240
result[103] += -x122 * x227 * x4
result[104] += -x101 * x223 * x245
result[105] += -x231 * x98
result[106] += -x101 * x228
result[107] += -x108 * x224
result[108] += -x163 * x205 * x241
result[109] += -x130 * x211 * x4
result[110] += -x132 * x205 * x245
result[111] += -x129 * x218
result[112] += -x132 * x212
result[113] += -x135 * x206
result[114] += -x168 * x179 * x240 * x246
result[115] += -x168 * x199 * x4
result[116] += -x169 * x192 * x4
result[117] += -x167 * x196
result[118] += -x169 * x191
result[119] += -x170 * x180
result[120] += -x175 * x251
result[121] += -x183 * x252 * x54
result[122] += -x183 * x260
result[123] += -x200 * x249 * x69
result[124] += -x147 * x197 * x259 * x54
result[125] += -x198 * x264
result[126] += -x162 * x173 * x249
result[127] += -x164 * x221 * x249
result[128] += -x265 * x266
result[129] += -x219 * x250 * x93
result[130] += -x164 * x219 * x259
result[131] += -x162 * x213 * x263
result[132] += -x173 * x272
result[133] += -x265 * x271 * x54
result[134] += -x182 * x278
result[135] += -x219 * x271 * x68
result[136] += -x213 * x277 * x279
result[137] += -x213 * x284
result[138] += -x158 * x250 * x43
result[139] += -x113 * x238 * x250
result[140] += -x158 * x237 * x259
result[141] += -x119 * x233 * x249
result[142] += -x113 * x235 * x259
result[143] += -x110 * x233 * x263
result[144] += -x271 * x43 * x76 * x83
result[145] += -x127 * x225 * x271
result[146] += -x140 * x225 * x285
result[147] += -x235 * x271 * x93
result[148] += -x123 * x285 * x3
result[149] += -x283 * x286 * x76
result[150] += -x289 * x43
result[151] += -x225 * x279 * x288
result[152] += -x225 * x292
result[153] += -x233 * x288 * x66
result[154] += -x286 * x291 * x54
result[155] += -x295 * x3
result[156] += -x146 * x241 * x246 * x249
result[157] += -x142 * x252 * x4
result[158] += -x139 * x147 * x266 * x4
result[159] += -x149 * x251
result[160] += -x142 * x260
result[161] += -x141 * x264
result[162] += -x158 * x241 * x271
result[163] += -x113 * x245 * x271
result[164] += -x110 * x245 * x277
result[165] += -x119 * x272
result[166] += -x113 * x278
result[167] += -x110 * x284
result[168] += -x162 * x240 * x288
result[169] += -x245 * x288 * x80
result[170] += -x291 * x296 * x76 * x85
result[171] += -x289 * x93
result[172] += -x292 * x80
result[173] += -x295 * x76
result[174] += -x242 * x297
result[175] += -x296 * x298 * x54 * x57
result[176] += -x299 * x4
result[177] += -x298 * x69
result[178] += -x299 * x54
result[179] += -x51 * (
x294 * x98
+ x45
* (
x0 * (x108 + x257 * x62 + x280)
+ 2.0 * x281
+ x282
+ x290
+ x98 * (x262 * x275 + x273)
)
)
[docs]
@numba.jit(
func_type.signature,
nopython=True,
nogil=True,
fastmath=True,
cache=True,
)
def diag_quadrupole3d_23(ax, da, A, bx, db, B, R, result):
"""See docstring of diag_quadrupole3d_32."""
# Call equivalent function and write to result
tmp = numpy.zeros_like(result)
diag_quadrupole3d_32(bx, db, B, ax, da, A, R, tmp)
result[:] += numpy.transpose(tmp.reshape(3, 10, 6), axes=(0, 2, 1)).flatten()
[docs]
@numba.jit(
func_type.signature,
nopython=True,
nogil=True,
fastmath=True,
cache=True,
)
def diag_quadrupole3d_42(ax, da, A, bx, db, B, R, result):
"""Cartesian 3D (gd) quadrupole moment integrals
for operators x², y² and z². The origin is at R.
Generated code; DO NOT modify by hand!"""
x0 = 0.5 / (ax + bx)
x1 = (ax + bx) ** (-1.0)
x2 = -x1 * (ax * A[0] + bx * B[0])
x3 = -x2 - B[0]
x4 = ax * bx * x1
x5 = numpy.exp(-x4 * (A[0] - B[0]) ** 2)
x6 = 1.77245385090551603 * numpy.sqrt(x1)
x7 = x5 * x6
x8 = x3 * x7
x9 = -x2 - R[0]
x10 = x7 * x9
x11 = x0 * (x10 + x8)
x12 = -x2 - A[0]
x13 = x0 * x7
x14 = x8 * x9
x15 = x13 + x14
x16 = x12 * x15
x17 = x11 + x16
x18 = x17 * x3
x19 = 2.0 * x18
x20 = x3**2 * x7
x21 = 3.0 * x13
x22 = 2.0 * x12
x23 = x21 + x22 * x8
x24 = x0 * (x20 + x23)
x25 = x12 * x7
x26 = x0 * (x25 + x8)
x27 = x25 * x3
x28 = x13 + x27
x29 = x28 * x3
x30 = x26 + x29
x31 = x12 * x30
x32 = x24 + x31
x33 = x12 * x17
x34 = x25 * x9
x35 = x0 * (x14 + x21 + x27 + x34)
x36 = 4.0 * x35
x37 = 2.0 * x33 + x36
x38 = 2.0 * x0
x39 = x17 * x9
x40 = 2.0 * x39
x41 = x10 * x22
x42 = x7 * x9**2
x43 = x21 + x42
x44 = x0 * (x41 + x43)
x45 = x0 * (x10 + x25)
x46 = x13 + x34
x47 = x46 * x9
x48 = x45 + x47
x49 = x12 * x48
x50 = x44 + x49
x51 = x0 * (x37 + x40 + x50)
x52 = 2.0 * x16
x53 = 3.0 * x11 + x52
x54 = x0 * (x15 * x3 + x30 + x53)
x55 = x12 * (x18 + x35)
x56 = x15 * x9
x57 = x0 * (x48 + x53 + x56)
x58 = x35 + x39
x59 = x12 * x58
x60 = x57 + x59
x61 = x12 * x60
x62 = x11 + x56
x63 = x0 * (2.0 * x14 + x43) + x3 * x62
x64 = x0 * (x19 + x36 + x40 + x63)
x65 = x3 * x58
x66 = x57 + x65
x67 = x12 * x66
x68 = x64 + x67
x69 = 2.0 * x0 * (x54 + x55 + 2.0 * x57 + x59 + x65) + x12 * x68
x70 = da * db
x71 = 0.0563436169819011052
x72 = x70 * x71
x73 = numpy.exp(-x4 * (A[1] - B[1]) ** 2)
x74 = numpy.exp(-x4 * (A[2] - B[2]) ** 2)
x75 = 3.14159265358979324 * x1 * x74
x76 = x73 * x75
x77 = -x1 * (ax * A[1] + bx * B[1])
x78 = -x77 - B[1]
x79 = 0.0975900072948533179
x80 = x78 * x79
x81 = x12 * x46
x82 = x45 + x81
x83 = x12 * x28
x84 = x26 + x83
x85 = 2.0 * x0 * (2.0 * x45 + x47 + x81) + x12 * x50
x86 = x51 + x61
x87 = x70 * x76
x88 = x87 * (
x0
* (
x22 * (x33 + x35)
+ x38 * (2.0 * x11 + x52 + x82 + x84)
+ 3.0 * x57
+ 3.0 * x59
+ x85
)
+ x12 * x86
)
x89 = -x1 * (ax * A[2] + bx * B[2])
x90 = -x89 - B[2]
x91 = x79 * x90
x92 = x6 * x74
x93 = x6 * x73
x94 = x78**2 * x93
x95 = x0 * x93
x96 = x70 * (x94 + x95)
x97 = x12**2 * x7
x98 = x0 * (x22 * x82 + x38 * (x21 + x41 + x97) + 3.0 * x44 + 3.0 * x49) + x12 * x85
x99 = x71 * x98
x100 = x87 * x90
x101 = x90**2 * x92
x102 = x0 * x92
x103 = x70 * (x101 + x102)
x104 = -x77 - A[1]
x105 = 2.2360679774997897
x106 = 0.0666666666666666667 * x105
x107 = x104 * x106
x108 = x69 * x87
x109 = x104 * x93
x110 = x109 * x78
x111 = x110 + x95
x112 = 3.87298334620741689
x113 = x111 * x112
x114 = 0.0666666666666666667 * x113
x115 = x70 * x92
x116 = 0.0666666666666666667 * x104
x117 = x112 * x86
x118 = x78 * x93
x119 = x0 * (x109 + x118)
x120 = x111 * x78
x121 = x119 + x120
x122 = x105 * x121
x123 = 0.0666666666666666667 * x85
x124 = x90 * x92
x125 = x124 * x70
x126 = x105 * x123
x127 = -x89 - A[2]
x128 = x106 * x127
x129 = 0.0666666666666666667 * x78
x130 = x127 * x92
x131 = x130 * x90
x132 = x102 + x131
x133 = x112 * x132
x134 = x133 * x70
x135 = 0.0666666666666666667 * x93
x136 = x0 * (x124 + x130)
x137 = x132 * x90
x138 = x136 + x137
x139 = x105 * x138
x140 = x70 * x93
x141 = x104**2 * x93
x142 = x141 + x95
x143 = 1.73205080756887729
x144 = 0.111111111111111111 * x143
x145 = x142 * x144
x146 = x104 * x111
x147 = x119 + x146
x148 = 0.333333333333333333 * x70
x149 = x147 * x148
x150 = x142 * x148
x151 = 3.0 * x95
x152 = 2.0 * x104
x153 = x118 * x152 + x151
x154 = x0 * (x153 + x94)
x155 = x104 * x121
x156 = x154 + x155
x157 = x143 * x50
x158 = 0.111111111111111111 * x157
x159 = x127 * x148
x160 = x111 * x148
x161 = x130 * x143
x162 = x132 * x143
x163 = x148 * x162
x164 = x148 * x50
x165 = x127**2 * x92
x166 = x102 + x165
x167 = x143 * x166
x168 = 0.111111111111111111 * x167
x169 = x168 * x70
x170 = x148 * x166
x171 = x127 * x132
x172 = x136 + x171
x173 = x148 * x172
x174 = 3.0 * x102
x175 = 2.0 * x127
x176 = x124 * x175 + x174
x177 = x0 * (x101 + x176)
x178 = x127 * x138
x179 = x177 + x178
x180 = x104 * x142 + x109 * x38
x181 = 0.0666666666666666667 * x180
x182 = x181 * x70
x183 = x105 * x66
x184 = x0 * (x141 + x153)
x185 = x104 * x147
x186 = x184 + x185
x187 = 0.0666666666666666667 * x186
x188 = x112 * x58
x189 = 2.0 * x0 * (2.0 * x119 + x120 + x146) + x104 * x156
x190 = x105 * x48
x191 = 0.0666666666666666667 * x115
x192 = x112 * x48
x193 = x143 * x147
x194 = x148 * x193
x195 = x148 * x48
x196 = x143 * x173
x197 = x111 * x143
x198 = x127 * x166 + x130 * x38
x199 = 0.0666666666666666667 * x198
x200 = x199 * x70
x201 = x0 * (x165 + x176)
x202 = x127 * x172
x203 = x201 + x202
x204 = x135 * x70
x205 = x118 * x70
x206 = 0.0666666666666666667 * x203
x207 = 2.0 * x0 * (2.0 * x136 + x137 + x171) + x127 * x179
x208 = x0 * (3.0 * x141 + x151) + x104 * x180
x209 = x63 * x70
x210 = x209 * x71
x211 = x0 * (3.0 * x119 + 3.0 * x146 + x180) + x104 * x186
x212 = x62 * x79
x213 = x0 * (3.0 * x154 + 3.0 * x155 + 2.0 * x184 + 2.0 * x185) + x104 * x189
x214 = x13 + x42
x215 = x214 * x71
x216 = x214 * x70
x217 = x216 * x79
x218 = x105 * x130
x219 = x112 * x70
x220 = x219 * x62
x221 = 0.0666666666666666667 * x216
x222 = x148 * x62
x223 = x144 * x179
x224 = x105 * x109
x225 = x0 * (3.0 * x165 + x174) + x127 * x198
x226 = x0 * (3.0 * x136 + 3.0 * x171 + x198) + x127 * x203
x227 = x0 * (3.0 * x177 + 3.0 * x178 + 2.0 * x201 + 2.0 * x202) + x127 * x207
x228 = x0 * (x23 + x97)
x229 = x12 * x84
x230 = 2.0 * x0 * (2.0 * x26 + x29 + x83) + x12 * x32
x231 = x0 * (2.0 * x228 + 2.0 * x229 + 3.0 * x24 + 3.0 * x31) + x12 * x230
x232 = -x77 - R[1]
x233 = x232**2 * x93
x234 = x233 + x95
x235 = x234 * x71
x236 = x13 + x97
x237 = x12 * x236 + x25 * x38
x238 = x228 + x229
x239 = x0 * (x237 + 3.0 * x26 + 3.0 * x83) + x12 * x238
x240 = x232 * x93
x241 = x0 * (x118 + x240)
x242 = x118 * x232
x243 = x242 + x95
x244 = x232 * x243
x245 = x241 + x244
x246 = x245 * x79
x247 = x234 * x70
x248 = x247 * x79
x249 = x0 * (x21 + 3.0 * x97) + x12 * x237
x250 = x151 + x233
x251 = x0 * (2.0 * x242 + x250) + x245 * x78
x252 = x251 * x72
x253 = x0 * (x109 + x240)
x254 = x109 * x232
x255 = x254 + x95
x256 = x232 * x255
x257 = x253 + x256
x258 = x105 * x257
x259 = x0 * (x110 + x151 + x242 + x254)
x260 = x104 * x243
x261 = x241 + x260
x262 = x232 * x261
x263 = x259 + x262
x264 = x112 * x263
x265 = 0.0666666666666666667 * x238
x266 = x112 * x265
x267 = 0.0666666666666666667 * x237
x268 = x267 * x70
x269 = 2.0 * x260
x270 = 3.0 * x241 + x269
x271 = x0 * (x244 + x257 + x270)
x272 = x263 * x78
x273 = x271 + x272
x274 = x105 * x273
x275 = 0.0666666666666666667 * x234
x276 = x275 * x70
x277 = x219 * x245
x278 = x152 * x240
x279 = x0 * (x250 + x278)
x280 = x104 * x257
x281 = x279 + x280
x282 = x144 * x32
x283 = x104 * x263
x284 = x271 + x283
x285 = x148 * x84
x286 = x261 * x78
x287 = 2.0 * x286
x288 = 4.0 * x259
x289 = 2.0 * x262 + x288
x290 = x0 * (x251 + x287 + x289)
x291 = x104 * x273
x292 = x290 + x291
x293 = x144 * x236
x294 = x293 * x70
x295 = x148 * x236
x296 = x148 * x257
x297 = x104 * x255
x298 = 2.0 * x0 * (2.0 * x253 + x256 + x297) + x104 * x281
x299 = x105 * x30
x300 = x112 * x28
x301 = x300 * x70
x302 = x104 * x261
x303 = 2.0 * x302
x304 = x0 * (x281 + x289 + x303)
x305 = x104 * x284
x306 = x304 + x305
x307 = 0.0666666666666666667 * x306
x308 = 0.0666666666666666667 * x298
x309 = x12 * x5
x310 = x309 * x75
x311 = x0 * (x121 + x243 * x78 + x270)
x312 = x104 * (x259 + x286)
x313 = 2.0 * x0 * (2.0 * x271 + x272 + x283 + x311 + x312) + x104 * x292
x314 = x313 * x70
x315 = x219 * x307
x316 = x105 * x25
x317 = x148 * x281
x318 = x148 * x28
x319 = x143 * x28
x320 = x13 + x20
x321 = x320 * x70
x322 = x253 + x297
x323 = (
x0 * (x152 * x322 + 3.0 * x279 + 3.0 * x280 + x38 * (x141 + x151 + x278))
+ x104 * x298
)
x324 = x323 * x71
x325 = x5 * x75
x326 = x3 * x325
x327 = x70 * (
x0
* (
x152 * (x259 + x302)
+ 3.0 * x271
+ 3.0 * x283
+ x298
+ x38 * (x147 + 2.0 * x241 + x269 + x322)
)
+ x104 * x306
)
x328 = x5 * x72
x329 = x7 * x70
x330 = x219 * x8
x331 = 0.0666666666666666667 * x329
x332 = x70 * x8
x333 = -x89 - R[2]
x334 = x333**2 * x92
x335 = x102 + x334
x336 = x335 * x71
x337 = x335 * x70
x338 = x337 * x79
x339 = x333 * x92
x340 = x0 * (x124 + x339)
x341 = x124 * x333
x342 = x102 + x341
x343 = x333 * x342
x344 = x340 + x343
x345 = x344 * x79
x346 = x174 + x334
x347 = x0 * (2.0 * x341 + x346) + x344 * x90
x348 = x347 * x72
x349 = x106 * x337
x350 = x219 * x344
x351 = x0 * (x130 + x339)
x352 = x130 * x333
x353 = x102 + x352
x354 = x333 * x353
x355 = x351 + x354
x356 = x105 * x355
x357 = x0 * (x131 + x174 + x341 + x352)
x358 = x127 * x342
x359 = x340 + x358
x360 = x333 * x359
x361 = x357 + x360
x362 = x112 * x361
x363 = 2.0 * x358
x364 = 3.0 * x340 + x363
x365 = x0 * (x343 + x355 + x364)
x366 = x361 * x90
x367 = x365 + x366
x368 = x105 * x367
x369 = x148 * x355
x370 = x109 * x143
x371 = x175 * x339
x372 = x0 * (x346 + x371)
x373 = x127 * x355
x374 = x372 + x373
x375 = x127 * x361
x376 = x365 + x375
x377 = x359 * x90
x378 = 2.0 * x377
x379 = 4.0 * x357
x380 = 2.0 * x360 + x379
x381 = x0 * (x347 + x378 + x380)
x382 = x127 * x367
x383 = x381 + x382
x384 = x148 * x374
x385 = 3.14159265358979324 * x1 * x73
x386 = x309 * x385
x387 = x127 * x353
x388 = 2.0 * x0 * (2.0 * x351 + x354 + x387) + x127 * x374
x389 = x127 * x359
x390 = 2.0 * x389
x391 = x0 * (x374 + x380 + x390)
x392 = x127 * x376
x393 = x391 + x392
x394 = x106 * x388
x395 = x219 * x393
x396 = x0 * (x138 + x342 * x90 + x364)
x397 = x127 * (x357 + x377)
x398 = 2.0 * x0 * (2.0 * x365 + x366 + x375 + x396 + x397) + x127 * x383
x399 = x398 * x70
x400 = x385 * x5
x401 = x3 * x400
x402 = x351 + x387
x403 = (
x0 * (x175 * x402 + 3.0 * x372 + 3.0 * x373 + x38 * (x165 + x174 + x371))
+ x127 * x388
)
x404 = x403 * x71
x405 = x70 * (
x0
* (
x175 * (x357 + x389)
+ 3.0 * x365
+ 3.0 * x375
+ x38 * (x172 + 2.0 * x340 + x363 + x402)
+ x388
)
+ x127 * x393
)
# 270 item(s)
result[0] += (
x72
* x76
* (
x0
* (
x22 * (x54 + x55)
+ x38 * (x19 + x32 + x37)
+ 2.0 * x51
+ 2.0 * x61
+ 3.0 * x64
+ 3.0 * x67
)
+ x12 * x69
)
)
result[1] += x80 * x88
result[2] += x88 * x91
result[3] += x92 * x96 * x99
result[4] += x100 * x80 * x98
result[5] += x103 * x93 * x99
result[6] += x107 * x108
result[7] += x114 * x115 * x86
result[8] += x100 * x116 * x117
result[9] += x115 * x122 * x123
result[10] += x114 * x125 * x85
result[11] += x103 * x109 * x126
result[12] += x108 * x128
result[13] += x117 * x127 * x129 * x87
result[14] += x134 * x135 * x86
result[15] += x126 * x130 * x96
result[16] += x118 * x123 * x134
result[17] += x123 * x139 * x140
result[18] += x115 * x145 * x68
result[19] += x149 * x60 * x92
result[20] += x124 * x150 * x60
result[21] += x115 * x156 * x158
result[22] += x124 * x149 * x50
result[23] += x103 * x142 * x158
result[24] += x104 * x159 * x68 * x76
result[25] += x160 * x161 * x60
result[26] += x109 * x163 * x60
result[27] += x121 * x130 * x164
result[28] += x132 * x157 * x160
result[29] += x109 * x138 * x164
result[30] += x169 * x68 * x93
result[31] += x118 * x170 * x60
result[32] += x173 * x60 * x93
result[33] += x158 * x166 * x96
result[34] += x118 * x173 * x50
result[35] += x140 * x158 * x179
result[36] += x182 * x183 * x92
result[37] += x115 * x187 * x188
result[38] += x124 * x182 * x188
result[39] += x189 * x190 * x191
result[40] += x125 * x187 * x192
result[41] += x103 * x181 * x190
result[42] += x130 * x150 * x66
result[43] += x130 * x194 * x58
result[44] += x150 * x162 * x58
result[45] += x130 * x156 * x195
result[46] += x147 * x162 * x195
result[47] += x138 * x142 * x195
result[48] += x109 * x170 * x66
result[49] += x160 * x167 * x58
result[50] += x109 * x196 * x58
result[51] += x121 * x166 * x195
result[52] += x172 * x195 * x197
result[53] += x109 * x179 * x195
result[54] += x183 * x200 * x93
result[55] += x118 * x188 * x200
result[56] += x188 * x203 * x204
result[57] += x190 * x199 * x96
result[58] += x192 * x205 * x206
result[59] += x190 * x204 * x207
result[60] += x208 * x210 * x92
result[61] += x115 * x211 * x212
result[62] += x125 * x208 * x212
result[63] += x115 * x213 * x215
result[64] += x124 * x211 * x217
result[65] += x103 * x208 * x215
result[66] += x182 * x218 * x63
result[67] += x130 * x187 * x220
result[68] += x133 * x182 * x62
result[69] += x189 * x218 * x221
result[70] += x133 * x186 * x221
result[71] += x139 * x182 * x214
result[72] += x142 * x168 * x209
result[73] += x147 * x166 * x222
result[74] += x142 * x172 * x222
result[75] += x156 * x168 * x216
result[76] += x147 * x173 * x214
result[77] += x142 * x216 * x223
result[78] += x199 * x209 * x224
result[79] += x113 * x200 * x62
result[80] += x109 * x206 * x220
result[81] += x122 * x199 * x216
result[82] += x113 * x203 * x221
result[83] += x207 * x221 * x224
result[84] += x210 * x225 * x93
result[85] += x205 * x212 * x225
result[86] += x140 * x212 * x226
result[87] += x215 * x225 * x96
result[88] += x118 * x217 * x226
result[89] += x140 * x215 * x227
result[90] += x115 * x231 * x235
result[91] += x115 * x239 * x246
result[92] += x124 * x239 * x248
result[93] += x249 * x252 * x92
result[94] += x125 * x246 * x249
result[95] += x103 * x235 * x249
result[96] += x191 * x230 * x258
result[97] += x191 * x238 * x264
result[98] += x125 * x257 * x266
result[99] += x268 * x274 * x92
result[100] += x124 * x264 * x268
result[101] += x103 * x258 * x267
result[102] += x218 * x230 * x276
result[103] += x130 * x265 * x277
result[104] += x134 * x238 * x275
result[105] += x218 * x251 * x268
result[106] += x134 * x245 * x267
result[107] += x139 * x247 * x267
result[108] += x115 * x281 * x282
result[109] += x284 * x285 * x92
result[110] += x124 * x281 * x285
result[111] += x292 * x294 * x92
result[112] += x124 * x284 * x295
result[113] += x103 * x281 * x293
result[114] += x130 * x296 * x32
result[115] += x161 * x263 * x285
result[116] += x162 * x296 * x84
result[117] += x130 * x273 * x295
result[118] += x162 * x263 * x295
result[119] += x138 * x236 * x296
result[120] += x168 * x247 * x32
result[121] += x166 * x245 * x285
result[122] += x173 * x234 * x84
result[123] += x169 * x236 * x251
result[124] += x173 * x236 * x245
result[125] += x223 * x236 * x247
result[126] += x191 * x298 * x299
result[127] += x301 * x307 * x92
result[128] += x124 * x301 * x308
result[129] += x106 * x310 * x314
result[130] += x310 * x315 * x90
result[131] += x103 * x308 * x316
result[132] += x130 * x30 * x317
result[133] += x161 * x284 * x318
result[134] += x162 * x281 * x318
result[135] += x159 * x292 * x310
result[136] += x163 * x25 * x284
result[137] += x138 * x25 * x317
result[138] += x166 * x296 * x30
result[139] += x167 * x263 * x318
result[140] += x173 * x257 * x319
result[141] += x170 * x25 * x273
result[142] += x196 * x25 * x263
result[143] += x179 * x25 * x296
result[144] += x200 * x234 * x299
result[145] += x200 * x245 * x300
result[146] += x203 * x275 * x301
result[147] += x200 * x251 * x316
result[148] += x206 * x25 * x277
result[149] += x207 * x276 * x316
result[150] += x321 * x324 * x92
result[151] += x326 * x327 * x79
result[152] += x323 * x326 * x70 * x91
result[153] += (
x328
* x75
* (
x0
* (
x152 * (x311 + x312)
+ 3.0 * x290
+ 3.0 * x291
+ 2.0 * x304
+ 2.0 * x305
+ x38 * (x156 + x287 + x288 + x303)
)
+ x104 * x313
)
)
result[154] += x325 * x327 * x91
result[155] += x103 * x324 * x7
result[156] += x218 * x308 * x321
result[157] += x127 * x315 * x326
result[158] += x134 * x308 * x8
result[159] += x128 * x314 * x325
result[160] += x134 * x307 * x7
result[161] += x139 * x308 * x329
result[162] += x169 * x281 * x320
result[163] += x170 * x284 * x8
result[164] += x173 * x281 * x8
result[165] += x169 * x292 * x7
result[166] += x173 * x284 * x7
result[167] += x223 * x281 * x329
result[168] += x200 * x258 * x320
result[169] += x200 * x264 * x8
result[170] += x206 * x257 * x330
result[171] += x200 * x274 * x7
result[172] += x203 * x264 * x331
result[173] += x207 * x258 * x331
result[174] += x225 * x235 * x321
result[175] += x225 * x246 * x332
result[176] += x226 * x248 * x8
result[177] += x225 * x252 * x7
result[178] += x226 * x246 * x329
result[179] += x227 * x235 * x329
result[180] += x140 * x231 * x336
result[181] += x118 * x239 * x338
result[182] += x140 * x239 * x345
result[183] += x249 * x336 * x96
result[184] += x205 * x249 * x345
result[185] += x249 * x348 * x93
result[186] += x109 * x230 * x349
result[187] += x114 * x238 * x337
result[188] += x109 * x265 * x350
result[189] += x122 * x267 * x337
result[190] += x113 * x268 * x344
result[191] += x224 * x268 * x347
result[192] += x204 * x230 * x356
result[193] += x205 * x266 * x355
result[194] += x204 * x238 * x362
result[195] += x267 * x356 * x96
result[196] += x118 * x268 * x362
result[197] += x268 * x368 * x93
result[198] += x145 * x32 * x337
result[199] += x147 * x285 * x335
result[200] += x142 * x285 * x344
result[201] += x156 * x293 * x337
result[202] += x147 * x295 * x344
result[203] += x142 * x294 * x347
result[204] += x109 * x32 * x369
result[205] += x197 * x285 * x355
result[206] += x285 * x361 * x370
result[207] += x121 * x295 * x355
result[208] += x197 * x295 * x361
result[209] += x109 * x295 * x367
result[210] += x140 * x282 * x374
result[211] += x118 * x285 * x374
result[212] += x285 * x376 * x93
result[213] += x293 * x374 * x96
result[214] += x118 * x295 * x376
result[215] += x294 * x383 * x93
result[216] += x182 * x299 * x335
result[217] += x187 * x301 * x335
result[218] += x182 * x300 * x344
result[219] += x189 * x25 * x349
result[220] += x187 * x25 * x350
result[221] += x182 * x316 * x347
result[222] += x150 * x30 * x355
result[223] += x193 * x318 * x355
result[224] += x150 * x319 * x361
result[225] += x156 * x25 * x369
result[226] += x194 * x25 * x361
result[227] += x150 * x25 * x367
result[228] += x109 * x30 * x384
result[229] += x160 * x319 * x374
result[230] += x318 * x370 * x376
result[231] += x121 * x25 * x384
result[232] += x143 * x160 * x25 * x376
result[233] += x104 * x148 * x383 * x386
result[234] += x204 * x299 * x388
result[235] += 0.0666666666666666667 * x118 * x301 * x388
result[236] += x135 * x301 * x393
result[237] += x25 * x394 * x96
result[238] += x129 * x386 * x395
result[239] += x106 * x386 * x399
result[240] += x208 * x321 * x336
result[241] += x211 * x338 * x8
result[242] += x208 * x332 * x345
result[243] += x213 * x329 * x336
result[244] += x211 * x329 * x345
result[245] += x208 * x348 * x7
result[246] += x182 * x320 * x356
result[247] += x187 * x330 * x355
result[248] += x182 * x362 * x8
result[249] += x189 * x331 * x356
result[250] += x187 * x329 * x362
result[251] += x182 * x368 * x7
result[252] += x145 * x321 * x374
result[253] += x149 * x374 * x8
result[254] += x150 * x376 * x8
result[255] += x144 * x156 * x329 * x374
result[256] += x149 * x376 * x7
result[257] += x145 * x329 * x383
result[258] += x109 * x321 * x394
result[259] += x114 * x332 * x388
result[260] += x116 * x395 * x401
result[261] += x122 * x331 * x388
result[262] += x114 * x329 * x393
result[263] += x107 * x399 * x400
result[264] += x321 * x404 * x93
result[265] += x401 * x403 * x70 * x80
result[266] += x401 * x405 * x79
result[267] += x404 * x7 * x96
result[268] += x400 * x405 * x80
result[269] += (
x328
* x385
* (
x0
* (
x175 * (x396 + x397)
+ x38 * (x179 + x378 + x379 + x390)
+ 3.0 * x381
+ 3.0 * x382
+ 2.0 * x391
+ 2.0 * x392
)
+ x127 * x398
)
)
[docs]
@numba.jit(
func_type.signature,
nopython=True,
nogil=True,
fastmath=True,
cache=True,
)
def diag_quadrupole3d_24(ax, da, A, bx, db, B, R, result):
"""See docstring of diag_quadrupole3d_42."""
# Call equivalent function and write to result
tmp = numpy.zeros_like(result)
diag_quadrupole3d_42(bx, db, B, ax, da, A, R, tmp)
result[:] += numpy.transpose(tmp.reshape(3, 15, 6), axes=(0, 2, 1)).flatten()
[docs]
@numba.jit(
func_type.signature,
nopython=True,
nogil=True,
fastmath=True,
cache=True,
)
def diag_quadrupole3d_33(ax, da, A, bx, db, B, R, result):
"""Cartesian 3D (ff) quadrupole moment integrals
for operators x², y² and z². The origin is at R.
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 = -2.0 * x1
x5 = x4 + B[0]
x6 = x5 + R[0]
x7 = x0 * x6
x8 = x2 + R[0]
x9 = x2 + B[0]
x10 = 2.0 * x9
x11 = x10 * x8
x12 = x0 + x11
x13 = x12 * x3
x14 = x13 + x7
x15 = 4.0 * x14
x16 = x15 * x3
x17 = x9**2
x18 = 3.0 * x0
x19 = x3 * x9
x20 = x18 + 4.0 * x19
x21 = x0 * (2.0 * x17 + x20)
x22 = x0 * (x5 + A[0])
x23 = 2.0 * x19
x24 = x0 + x23
x25 = x24 * x9
x26 = x22 + x25
x27 = 2.0 * x3
x28 = x21 + x26 * x27
x29 = x27 * x8
x30 = x0 * (x11 + x18 + x23 + x29)
x31 = 4.0 * x30
x32 = x15 * x9 + x31
x33 = 2.0 * x0
x34 = x12 * x9
x35 = 2.0 * x13 + x18 * x6
x36 = x0 * (x26 + x34 + x35) + x3 * (x10 * x14 + x30)
x37 = 4.0 * x9
x38 = x12 * x8
x39 = x0 * (x4 + A[0] + R[0])
x40 = x0 + x29
x41 = x40 * x8
x42 = x39 + x41
x43 = x0 * (x35 + x38 + x42)
x44 = 2.0 * x14 * x8 + x30
x45 = x44 * x9
x46 = x43 + x45
x47 = x15 * x8
x48 = x8**2
x49 = x18 + 2.0 * x48
x50 = x38 + x7
x51 = x0 * (x37 * x8 + x49) + x10 * x50
x52 = x0 * (x32 + x47 + x51)
x53 = 6.0 * x3
x54 = x27 * x46 + x52
x55 = x3 * x44
x56 = x33 * (x36 + 2.0 * x43 + x45 + x55)
x57 = x54 * x9 + x56
x58 = ax * bx * x0
x59 = (
5.56832799683170785
* da
* db
* numpy.exp(-x58 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2))
)
x60 = 0.00416666666666666667 * x59
x61 = x0**1.5
x62 = x60 * x61
x63 = x0 * (ax * A[1] + bx * B[1])
x64 = -x63
x65 = x64 + B[1]
x66 = x59 * x61
x67 = x65 * x66
x68 = 2.2360679774997897
x69 = 0.00833333333333333333 * x68
x70 = x69 * (x3 * x54 + x56)
x71 = x0 * (ax * A[2] + bx * B[2])
x72 = -x71
x73 = x72 + B[2]
x74 = x66 * x73
x75 = x65**2
x76 = 0.5 * x0
x77 = x75 + x76
x78 = x0 * (4.0 * x3 * x8 + x49) + x27 * x42
x79 = x43 + x55
x80 = x0 * (x16 + x31 + x47 + x78) + x27 * x79
x81 = x0**1.5
x82 = x59 * x81
x83 = 0.00833333333333333333 * x82
x84 = x68 * x83
x85 = x80 * x84
x86 = 3.87298334620741689
x87 = 0.00833333333333333333 * x86
x88 = x67 * x87
x89 = x73**2
x90 = x76 + x89
x91 = 0.0166666666666666667 * x3 * x78 + 0.0166666666666666667 * x33 * (
x3 * x40 + 2.0 * x39 + x41
)
x92 = 1.5 * x0
x93 = x65 * x82
x94 = x93 * (x75 + x92)
x95 = x73 * x82
x96 = x68 * x91
x97 = x95 * (x89 + x92)
x98 = x64 + A[1]
x99 = x66 * x69
x100 = x57 * x99
x101 = x65 * x98
x102 = x101 + x76
x103 = 0.0416666666666666667 * x82
x104 = x103 * x54
x105 = 0.0416666666666666667 * x54
x106 = -2.0 * x63
x107 = x106 + B[1]
x108 = x0 * (x107 + A[1])
x109 = 2.0 * x101
x110 = x0 + x109
x111 = x110 * x65
x112 = x108 + x111
x113 = x103 * x79
x114 = 1.73205080756887729
x115 = x102 * x114
x116 = 0.0833333333333333333 * x79
x117 = 0.0833333333333333333 * x82
x118 = x117 * x90
x119 = 4.0 * x101 + x18
x120 = x0 * (x119 + 2.0 * x75)
x121 = 2.0 * x112
x122 = x120 + x121 * x65
x123 = x122 * x68
x124 = x60 * x81
x125 = x124 * x78
x126 = x103 * x78
x127 = x68 * x97
x128 = 0.0166666666666666667 * x78
x129 = x72 + A[2]
x130 = x129 * x73
x131 = x130 + x76
x132 = x117 * x77
x133 = x114 * x131
x134 = -2.0 * x71
x135 = x134 + B[2]
x136 = x0 * (x135 + A[2])
x137 = 2.0 * x130
x138 = x0 + x137
x139 = x138 * x73
x140 = x136 + x139
x141 = x68 * x94
x142 = 4.0 * x130 + x18
x143 = x0 * (x142 + 2.0 * x89)
x144 = 2.0 * x140
x145 = x143 + x144 * x73
x146 = x145 * x68
x147 = x98**2
x148 = x147 + x76
x149 = x10 * x46 + x52
x150 = x149 * x84
x151 = x110 * x98
x152 = x108 + x151
x153 = x103 * x46
x154 = 0.0833333333333333333 * x46
x155 = x120 + x121 * x98
x156 = 0.0208333333333333333 * x82
x157 = x156 * x44
x158 = x103 * x73
x159 = x114 * x44
x160 = x33 * (2.0 * x108 + x111 + x151)
x161 = x155 * x65 + x160
x162 = x42 * x84
x163 = x103 * x42
x164 = 0.0333333333333333333 * x42
x165 = x129 * x66 * x87
x166 = x117 * x46
x167 = x103 * x129
x168 = 0.25 * x131 * x82
x169 = x103 * x98
x170 = x83 * x86
x171 = x170 * x42
x172 = x117 * x42
x173 = x129**2
x174 = x173 + x76
x175 = x129 * x138
x176 = x136 + x175
x177 = x103 * x65
x178 = x129 * x144 + x143
x179 = x33 * (2.0 * x136 + x139 + x175)
x180 = x178 * x73 + x179
x181 = x98 * (x147 + x92)
x182 = 0.0166666666666666667 * x82
x183 = x182 * (x33 * (x34 + x38 + 2.0 * x7) + x51 * x9)
x184 = 2.0 * x98
x185 = x0 * (x119 + 2.0 * x147) + x152 * x184
x186 = x124 * x68
x187 = x186 * x51
x188 = x181 * x68
x189 = 0.0166666666666666667 * x51
x190 = x155 * x98 + x160
x191 = x50 * x84
x192 = x170 * x50
x193 = 0.0333333333333333333 * x82
x194 = x193 * x50
x195 = 4.0 * x65
x196 = 6.0 * x98
x197 = x0 * (x112 * x195 + x112 * x196 + 5.0 * x120) + x161 * x184
x198 = x48 + x76
x199 = x198 * x83
x200 = x198 * x68
x201 = 0.0166666666666666667 * x200
x202 = x182 * x200
x203 = 0.0666666666666666667 * x198
x204 = x183 * x68
x205 = x117 * x148
x206 = x117 * x50
x207 = x117 * x198
x208 = x182 * x198
x209 = x117 * x174
x210 = x129 * (x173 + x92)
x211 = x210 * x68
x212 = 2.0 * x129
x213 = x0 * (x142 + 2.0 * x173) + x176 * x212
x214 = x129 * x178 + x179
x215 = 4.0 * x73
x216 = 6.0 * x129
x217 = x0 * (x140 * x215 + x140 * x216 + 5.0 * x143) + x180 * x212
x218 = x24 * x3
x219 = x33 * (x218 + 2.0 * x22 + x25)
x220 = x219 + x28 * x9
x221 = x0 * (5.0 * x21 + x26 * x37 + x26 * x53) + x220 * x27
x222 = x64 + R[1]
x223 = x222**2
x224 = x223 + x76
x225 = x224 * x83
x226 = x219 + x28 * x3
x227 = x107 + R[1]
x228 = x0 * x227
x229 = 2.0 * x65
x230 = x222 * x229
x231 = x0 + x230
x232 = x222 * x231
x233 = x228 + x232
x234 = x233 * x84
x235 = x224 * x68
x236 = 0.0166666666666666667 * x226
x237 = x3**2
x238 = x218 + x22
x239 = x0 * (x20 + 2.0 * x237) + x238 * x27
x240 = x18 + 2.0 * x223
x241 = x0 * (x195 * x222 + x240) + x229 * x233
x242 = x186 * x241
x243 = x170 * x233
x244 = x182 * x235
x245 = x231 * x65
x246 = x182 * (x241 * x65 + x33 * (2.0 * x228 + x232 + x245))
x247 = x3 * (x237 + x92)
x248 = x247 * x68
x249 = 0.0166666666666666667 * x248
x250 = x193 * x233
x251 = 0.0666666666666666667 * x224
x252 = x0 * (x106 + A[1] + R[1])
x253 = x184 * x222
x254 = x0 + x253
x255 = x222 * x254
x256 = x252 + x255
x257 = x256 * x84
x258 = x0 * (x109 + x18 + x230 + x253)
x259 = x231 * x98
x260 = x228 + x259
x261 = x222 * x260
x262 = x258 + 2.0 * x261
x263 = x156 * x262
x264 = x18 * x227 + 2.0 * x259
x265 = x0 * (x232 + x256 + x264)
x266 = x262 * x65
x267 = x265 + x266
x268 = x103 * x267
x269 = x114 * x262
x270 = x237 + x76
x271 = x195 * x260
x272 = 4.0 * x258
x273 = 4.0 * x261 + x272
x274 = x0 * (x241 + x271 + x273)
x275 = x229 * x267 + x274
x276 = x275 * x84
x277 = 0.0833333333333333333 * x270
x278 = 0.0333333333333333333 * x270
x279 = x117 * x224
x280 = x117 * x133
x281 = x246 * x68
x282 = x117 * x270
x283 = x182 * x270
x284 = 4.0 * x98
x285 = x0 * (x222 * x284 + x240) + x184 * x256
x286 = x10 * x26 + x21
x287 = x186 * x286
x288 = x262 * x98
x289 = x265 + x288
x290 = x103 * x289
x291 = x19 + x76
x292 = x184 * x267 + x274
x293 = x103 * x292
x294 = x114 * x291
x295 = 0.0833333333333333333 * x294
x296 = x0 * (x112 + x245 + x264) + x98 * (x229 * x260 + x258)
x297 = x33 * (2.0 * x265 + x266 + x288 + x296)
x298 = x292 * x65 + x297
x299 = x298 * x99
x300 = 0.0416666666666666667 * x292
x301 = 0.0166666666666666667 * x3
x302 = x170 * x256
x303 = x117 * x294
x304 = x103 * x3
x305 = x285 * x98 + x33 * (2.0 * x252 + x254 * x98 + x255)
x306 = x17 + x92
x307 = x182 * x9
x308 = x306 * x307
x309 = x17 + x76
x310 = x260 * x284
x311 = x0 * (x273 + x285 + x310) + x184 * x289
x312 = x311 * x84
x313 = 0.0166666666666666667 * x305
x314 = x309 * x68
x315 = x292 * x98 + x297
x316 = x9 * x99
x317 = x307 * x68
x318 = x308 * x68
x319 = x117 * x309
x320 = x66 * x9
x321 = x103 * x9
x322 = x306 * x9
x323 = x193 * x322 * x68
x324 = x322 * x82
x325 = x72 + R[2]
x326 = x325**2
x327 = x326 + x76
x328 = x327 * x83
x329 = x327 * x68
x330 = x135 + R[2]
x331 = x0 * x330
x332 = 2.0 * x73
x333 = x325 * x332
x334 = x0 + x333
x335 = x325 * x334
x336 = x331 + x335
x337 = x336 * x84
x338 = x182 * x329
x339 = x170 * x336
x340 = x18 + 2.0 * x326
x341 = x0 * (x215 * x325 + x340) + x332 * x336
x342 = x186 * x341
x343 = 0.0666666666666666667 * x327
x344 = x193 * x336
x345 = x334 * x73
x346 = x182 * (x33 * (2.0 * x331 + x335 + x345) + x341 * x73)
x347 = x117 * x327
x348 = x115 * x117
x349 = x346 * x68
x350 = x0 * (x134 + A[2] + R[2])
x351 = x212 * x325
x352 = x0 + x351
x353 = x325 * x352
x354 = x350 + x353
x355 = x354 * x84
x356 = x0 * (x137 + x18 + x333 + x351)
x357 = x129 * x334
x358 = x331 + x357
x359 = x325 * x358
x360 = x356 + 2.0 * x359
x361 = x156 * x360
x362 = x114 * x360
x363 = x18 * x330 + 2.0 * x357
x364 = x0 * (x335 + x354 + x363)
x365 = x360 * x73
x366 = x364 + x365
x367 = x103 * x366
x368 = x215 * x358
x369 = 4.0 * x356
x370 = 4.0 * x359 + x369
x371 = x0 * (x341 + x368 + x370)
x372 = x332 * x366 + x371
x373 = x372 * x84
x374 = x170 * x354
x375 = 4.0 * x129
x376 = x0 * (x325 * x375 + x340) + x212 * x354
x377 = x129 * x360
x378 = x364 + x377
x379 = x103 * x378
x380 = x212 * x366 + x371
x381 = x103 * x380
x382 = 0.0416666666666666667 * x380
x383 = x0 * (x140 + x345 + x363) + x129 * (x332 * x358 + x356)
x384 = x33 * (2.0 * x364 + x365 + x377 + x383)
x385 = x380 * x73 + x384
x386 = x385 * x99
x387 = x129 * x376 + x33 * (x129 * x352 + 2.0 * x350 + x353)
x388 = 0.0166666666666666667 * x387
x389 = x358 * x375
x390 = x0 * (x370 + x376 + x389) + x212 * x378
x391 = x390 * x84
x392 = x129 * x380 + x384
# 300 item(s)
result[0] += x62 * (
x0 * (x33 * (x16 + x28 + x32) + x36 * x37 + x37 * x46 + x46 * x53 + 5.0 * x52)
+ x27 * x57
)
result[1] += x67 * x70
result[2] += x70 * x74
result[3] += x77 * x85
result[4] += x73 * x80 * x88
result[5] += x85 * x90
result[6] += x91 * x94
result[7] += x77 * x95 * x96
result[8] += x90 * x93 * x96
result[9] += x91 * x97
result[10] += x100 * x98
result[11] += x102 * x104
result[12] += x105 * x74 * x98
result[13] += x112 * x113
result[14] += x115 * x116 * x95
result[15] += x118 * x79 * x98
result[16] += x123 * x125
result[17] += x112 * x126 * x73
result[18] += x102 * x118 * x78
result[19] += x127 * x128 * x98
result[20] += x100 * x129
result[21] += x105 * x129 * x67
result[22] += x104 * x131
result[23] += x129 * x132 * x79
result[24] += x116 * x133 * x93
result[25] += x113 * x140
result[26] += x128 * x129 * x141
result[27] += x131 * x132 * x78
result[28] += x126 * x140 * x65
result[29] += x125 * x146
result[30] += x148 * x150
result[31] += x152 * x153
result[32] += x148 * x154 * x95
result[33] += x155 * x157
result[34] += x152 * x158 * x159
result[35] += x118 * x148 * x44
result[36] += x161 * x162
result[37] += x155 * x163 * x73
result[38] += x118 * x152 * x42
result[39] += x127 * x148 * x164
result[40] += x149 * x165 * x98
result[41] += x115 * x129 * x166
result[42] += x133 * x166 * x98
result[43] += x112 * x159 * x167
result[44] += x102 * x168 * x44
result[45] += x140 * x159 * x169
result[46] += x122 * x129 * x171
result[47] += x112 * x133 * x172
result[48] += x115 * x140 * x172
result[49] += x145 * x171 * x98
result[50] += x150 * x174
result[51] += x154 * x174 * x93
result[52] += x153 * x176
result[53] += x132 * x174 * x44
result[54] += x159 * x176 * x177
result[55] += x157 * x178
result[56] += x141 * x164 * x174
result[57] += x132 * x176 * x42
result[58] += x163 * x178 * x65
result[59] += x162 * x180
result[60] += x181 * x183
result[61] += x185 * x187
result[62] += x188 * x189 * x95
result[63] += x190 * x191
result[64] += x185 * x192 * x73
result[65] += x188 * x194 * x90
result[66] += x197 * x199
result[67] += x190 * x201 * x95
result[68] += x185 * x202 * x90
result[69] += x181 * x203 * x97
result[70] += x129 * x148 * x204
result[71] += x152 * x167 * x51
result[72] += x131 * x205 * x51
result[73] += x155 * x167 * x50
result[74] += x133 * x152 * x206
result[75] += x140 * x205 * x50
result[76] += x129 * x161 * x202
result[77] += x131 * x155 * x207
result[78] += x140 * x152 * x207
result[79] += x146 * x148 * x208
result[80] += x174 * x204 * x98
result[81] += x102 * x209 * x51
result[82] += x169 * x176 * x51
result[83] += x112 * x209 * x50
result[84] += x115 * x176 * x206
result[85] += x169 * x178 * x50
result[86] += x123 * x174 * x208
result[87] += x112 * x176 * x207
result[88] += x102 * x178 * x207
result[89] += x180 * x202 * x98
result[90] += x183 * x210
result[91] += x189 * x211 * x93
result[92] += x187 * x213
result[93] += x194 * x211 * x77
result[94] += x192 * x213 * x65
result[95] += x191 * x214
result[96] += x203 * x210 * x94
result[97] += x202 * x213 * x77
result[98] += x201 * x214 * x93
result[99] += x199 * x217
result[100] += x221 * x225
result[101] += x226 * x234
result[102] += x235 * x236 * x95
result[103] += x239 * x242
result[104] += x239 * x243 * x73
result[105] += x239 * x244 * x90
result[106] += x246 * x247
result[107] += x241 * x249 * x95
result[108] += x248 * x250 * x90
result[109] += x247 * x251 * x97
result[110] += x220 * x257
result[111] += x263 * x28
result[112] += x158 * x256 * x28
result[113] += x238 * x268
result[114] += x158 * x238 * x269
result[115] += x118 * x238 * x256
result[116] += x270 * x276
result[117] += x267 * x277 * x95
result[118] += x118 * x262 * x270
result[119] += x127 * x256 * x278
result[120] += x129 * x220 * x244
result[121] += x167 * x233 * x28
result[122] += x131 * x279 * x28
result[123] += x167 * x238 * x241
result[124] += x233 * x238 * x280
result[125] += x140 * x238 * x279
result[126] += x129 * x270 * x281
result[127] += x131 * x241 * x282
result[128] += x140 * x233 * x282
result[129] += x146 * x224 * x283
result[130] += x285 * x287
result[131] += x26 * x290
result[132] += x158 * x26 * x285
result[133] += x291 * x293
result[134] += x289 * x295 * x95
result[135] += x118 * x285 * x291
result[136] += x299 * x3
result[137] += x3 * x300 * x74
result[138] += x118 * x289 * x3
result[139] += x127 * x285 * x301
result[140] += x129 * x286 * x302
result[141] += x167 * x26 * x269
result[142] += x256 * x26 * x280
result[143] += x129 * x267 * x303
result[144] += x168 * x262 * x291
result[145] += x140 * x256 * x303
result[146] += x165 * x275 * x3
result[147] += x267 * x280 * x3
result[148] += x140 * x269 * x304
result[149] += x145 * x3 * x302
result[150] += x174 * x244 * x286
result[151] += x209 * x233 * x26
result[152] += x176 * x26 * x279
result[153] += x209 * x241 * x291
result[154] += x176 * x233 * x303
result[155] += x178 * x279 * x291
result[156] += x174 * x281 * x3
result[157] += x176 * x241 * x304
result[158] += x178 * x233 * x304
result[159] += x180 * x244 * x3
result[160] += x305 * x308
result[161] += x309 * x312
result[162] += x313 * x314 * x95
result[163] += x315 * x316
result[164] += x311 * x74 * x87 * x9
result[165] += x305 * x317 * x90
result[166] += x62 * (
x0
* (
x195 * x267
+ x195 * x296
+ x196 * x267
+ 5.0 * x274
+ x33 * (x155 + x271 + x272 + x310)
)
+ x184 * x298
)
result[167] += x315 * x69 * x74
result[168] += x312 * x90
result[169] += x313 * x97
result[170] += x129 * x285 * x318
result[171] += x129 * x289 * x319
result[172] += x131 * x285 * x319
result[173] += x129 * x300 * x320
result[174] += x280 * x289 * x9
result[175] += x140 * x285 * x321
result[176] += x129 * x299
result[177] += x131 * x293
result[178] += x140 * x290
result[179] += x124 * x146 * x285
result[180] += x174 * x256 * x323
result[181] += x209 * x262 * x309
result[182] += x176 * x256 * x319
result[183] += x209 * x267 * x9
result[184] += x176 * x269 * x321
result[185] += x178 * x256 * x321
result[186] += x174 * x276
result[187] += x176 * x268
result[188] += x178 * x263
result[189] += x180 * x257
result[190] += x210 * x251 * x324
result[191] += x210 * x250 * x314
result[192] += x213 * x244 * x309
result[193] += x210 * x241 * x317
result[194] += x213 * x243 * x9
result[195] += x214 * x235 * x307
result[196] += x210 * x246
result[197] += x213 * x242
result[198] += x214 * x234
result[199] += x217 * x225
result[200] += x221 * x328
result[201] += x236 * x329 * x93
result[202] += x226 * x337
result[203] += x239 * x338 * x77
result[204] += x239 * x339 * x65
result[205] += x239 * x342
result[206] += x247 * x343 * x94
result[207] += x248 * x344 * x77
result[208] += x249 * x341 * x93
result[209] += x247 * x346
result[210] += x220 * x338 * x98
result[211] += x102 * x28 * x347
result[212] += x169 * x28 * x336
result[213] += x112 * x238 * x347
result[214] += x238 * x336 * x348
result[215] += x169 * x238 * x341
result[216] += x123 * x283 * x327
result[217] += x112 * x282 * x336
result[218] += x102 * x282 * x341
result[219] += x270 * x349 * x98
result[220] += x220 * x355
result[221] += x177 * x28 * x354
result[222] += x28 * x361
result[223] += x132 * x238 * x354
result[224] += x177 * x238 * x362
result[225] += x238 * x367
result[226] += x141 * x278 * x354
result[227] += x132 * x270 * x360
result[228] += x277 * x366 * x93
result[229] += x270 * x373
result[230] += x148 * x286 * x338
result[231] += x152 * x26 * x347
result[232] += x205 * x26 * x336
result[233] += x155 * x291 * x347
result[234] += x152 * x303 * x336
result[235] += x205 * x291 * x341
result[236] += x161 * x3 * x338
result[237] += x155 * x304 * x336
result[238] += x152 * x304 * x341
result[239] += x148 * x3 * x349
result[240] += x286 * x374 * x98
result[241] += x26 * x348 * x354
result[242] += x169 * x26 * x362
result[243] += x112 * x303 * x354
result[244] += 0.25 * x102 * x291 * x360 * x82
result[245] += x303 * x366 * x98
result[246] += x122 * x3 * x374
result[247] += x112 * x304 * x362
result[248] += x3 * x348 * x366
result[249] += x3 * x372 * x66 * x87 * x98
result[250] += x287 * x376
result[251] += x177 * x26 * x376
result[252] += x26 * x379
result[253] += x132 * x291 * x376
result[254] += x295 * x378 * x93
result[255] += x291 * x381
result[256] += x141 * x301 * x376
result[257] += x132 * x3 * x378
result[258] += x3 * x382 * x67
result[259] += x3 * x386
result[260] += x181 * x324 * x343
result[261] += x182 * x185 * x314 * x327
result[262] += x181 * x314 * x344
result[263] += x190 * x317 * x327
result[264] += x185 * x339 * x9
result[265] += x181 * x317 * x341
result[266] += x197 * x328
result[267] += x190 * x337
result[268] += x185 * x342
result[269] += x181 * x346
result[270] += x148 * x323 * x354
result[271] += x152 * x319 * x354
result[272] += x205 * x309 * x360
result[273] += x155 * x321 * x354
result[274] += x152 * x321 * x362
result[275] += x205 * x366 * x9
result[276] += x161 * x355
result[277] += x155 * x361
result[278] += x152 * x367
result[279] += x148 * x373
result[280] += x318 * x376 * x98
result[281] += x102 * x319 * x376
result[282] += x319 * x378 * x98
result[283] += x112 * x321 * x376
result[284] += x348 * x378 * x9
result[285] += x320 * x382 * x98
result[286] += x123 * x124 * x376
result[287] += x112 * x379
result[288] += x102 * x381
result[289] += x386 * x98
result[290] += x308 * x387
result[291] += x314 * x388 * x93
result[292] += x309 * x391
result[293] += x317 * x387 * x77
result[294] += x390 * x88 * x9
result[295] += x316 * x392
result[296] += x388 * x94
result[297] += x391 * x77
result[298] += x392 * x67 * x69
result[299] += x62 * (
x0
* (
x215 * x366
+ x215 * x383
+ x216 * x366
+ x33 * (x178 + x368 + x369 + x389)
+ 5.0 * x371
)
+ x212 * x385
)
[docs]
@numba.jit(
func_type.signature,
nopython=True,
nogil=True,
fastmath=True,
cache=True,
)
def diag_quadrupole3d_43(ax, da, A, bx, db, B, R, result):
"""Cartesian 3D (gf) quadrupole moment integrals
for operators x², y² and z². The origin is at R.
Generated code; DO NOT modify by hand!"""
x0 = 0.5 / (ax + bx)
x1 = (ax + bx) ** (-1.0)
x2 = ax * bx * x1
x3 = numpy.exp(-x2 * (A[0] - B[0]) ** 2)
x4 = 1.77245385090551603 * numpy.sqrt(x1)
x5 = x3 * x4
x6 = x0 * x5
x7 = 3.0 * x6
x8 = -x1 * (ax * A[0] + bx * B[0])
x9 = -x8 - B[0]
x10 = -x8 - A[0]
x11 = x10 * x5
x12 = x11 * x9
x13 = -x8 - R[0]
x14 = x11 * x13
x15 = x5 * x9
x16 = x13 * x15
x17 = x0 * (x12 + x14 + x16 + x7)
x18 = x13 * x5
x19 = x0 * (x15 + x18)
x20 = x16 + x6
x21 = x10 * x20
x22 = x19 + x21
x23 = x22 * x9
x24 = x17 + x23
x25 = 2.0 * x9
x26 = x10 * x24
x27 = x20 * x9
x28 = x0 * (x11 + x15)
x29 = x12 + x6
x30 = x29 * x9
x31 = x28 + x30
x32 = 2.0 * x21
x33 = 3.0 * x19 + x32
x34 = x0 * (x27 + x31 + x33)
x35 = x10 * x29
x36 = 2.0 * x0 * (2.0 * x28 + x30 + x35)
x37 = x5 * x9**2
x38 = x11 * x25 + x7
x39 = x0 * (x37 + x38)
x40 = x10 * x31
x41 = x39 + x40
x42 = x41 * x9
x43 = x36 + x42
x44 = 2.0 * x0
x45 = x10 * x22
x46 = 2.0 * x45
x47 = 4.0 * x17
x48 = 2.0 * x23 + x47
x49 = x0 * (x41 + x46 + x48)
x50 = x26 + x34
x51 = x50 * x9
x52 = 2.0 * x10
x53 = x13 * x22
x54 = 2.0 * x53
x55 = x13**2 * x5
x56 = x55 + x7
x57 = x13 * x20
x58 = x19 + x57
x59 = x0 * (x18 * x25 + x56) + x58 * x9
x60 = x0 * (x48 + x54 + x59)
x61 = x0 * (x11 + x18)
x62 = x14 + x6
x63 = x13 * x62
x64 = x61 + x63
x65 = x0 * (x33 + x57 + x64)
x66 = x17 + x53
x67 = x66 * x9
x68 = x65 + x67
x69 = x10 * x68
x70 = x60 + x69
x71 = x10 * x70
x72 = x70 * x9
x73 = x10 * x66
x74 = 2.0 * x0 * (x26 + x34 + 2.0 * x65 + x67 + x73)
x75 = x68 * x9
x76 = 2.0 * x49 + 3.0 * x69
x77 = x72 + x74
x78 = x0 * (2.0 * x51 + 5.0 * x60 + 2.0 * x75 + x76) + x10 * x77
x79 = 2.64575131106459059
x80 = da * db
x81 = 0.00952380952380952381 * x80
x82 = x79 * x81
x83 = numpy.exp(-x2 * (A[1] - B[1]) ** 2)
x84 = numpy.exp(-x2 * (A[2] - B[2]) ** 2)
x85 = 3.14159265358979324 * x1 * x84
x86 = x83 * x85
x87 = -x1 * (ax * A[1] + bx * B[1])
x88 = -x87 - B[1]
x89 = 5.91607978309961604
x90 = x81 * x89
x91 = x88 * x90
x92 = x18 * x52
x93 = x0 * (x56 + x92)
x94 = x10 * x64
x95 = x93 + x94
x96 = x0 * (x46 + x47 + x54 + x95)
x97 = x65 + x73
x98 = x10 * x97
x99 = x71 + x74
x100 = x86 * (x0 * (x50 * x52 + 3.0 * x60 + x76 + 2.0 * x96 + 2.0 * x98) + x10 * x99)
x101 = -x1 * (ax * A[2] + bx * B[2])
x102 = -x101 - B[2]
x103 = x102 * x90
x104 = x10 * x62
x105 = x104 + x61
x106 = x28 + x35
x107 = 2.0 * x0 * (x104 + 2.0 * x61 + x63) + x10 * x95
x108 = x96 + x98
x109 = (
x0
* (
x107
+ x44 * (x105 + x106 + 2.0 * x19 + x32)
+ x52 * (x17 + x45)
+ 3.0 * x65
+ 3.0 * x73
)
+ x10 * x108
)
x110 = x4 * x84
x111 = x4 * x83
x112 = x111 * x88**2
x113 = x0 * x111
x114 = x112 + x113
x115 = x114 * x89
x116 = x115 * x81
x117 = x102 * x86
x118 = 10.2469507659595984
x119 = x118 * x81
x120 = x119 * x88
x121 = x102**2 * x110
x122 = x0 * x110
x123 = x121 + x122
x124 = x123 * x89
x125 = x124 * x81
x126 = x111 * x88
x127 = x114 * x88 + x126 * x44
x128 = x127 * x79
x129 = x10**2 * x5
x130 = (
x0 * (x105 * x52 + x44 * (x129 + x7 + x92) + 3.0 * x93 + 3.0 * x94) + x10 * x107
)
x131 = x130 * x81
x132 = x102 * x110
x133 = x102 * x123 + x132 * x44
x134 = x133 * x79
x135 = -x87 - A[1]
x136 = 0.0666666666666666667 * x80
x137 = x135 * x136
x138 = x78 * x86
x139 = x111 * x135
x140 = x139 * x88
x141 = x113 + x140
x142 = x136 * x141
x143 = 2.2360679774997897
x144 = x143 * x99
x145 = x136 * x143
x146 = x145 * x99
x147 = x0 * (x126 + x139)
x148 = x141 * x88
x149 = x147 + x148
x150 = x108 * x145
x151 = 3.87298334620741689
x152 = x108 * x151
x153 = x123 * x143
x154 = x108 * x136
x155 = 3.0 * x113
x156 = 2.0 * x135
x157 = x126 * x156 + x155
x158 = x0 * (x112 + x157)
x159 = x149 * x88
x160 = x158 + x159
x161 = x107 * x136
x162 = x107 * x145
x163 = -x101 - A[2]
x164 = x136 * x163
x165 = x163 * x86
x166 = x110 * x163
x167 = x102 * x166
x168 = x122 + x167
x169 = x136 * x168
x170 = x114 * x143
x171 = x0 * (x132 + x166)
x172 = x102 * x168
x173 = x171 + x172
x174 = 3.0 * x122
x175 = 2.0 * x163
x176 = x132 * x175 + x174
x177 = x0 * (x121 + x176)
x178 = x102 * x173
x179 = x177 + x178
x180 = x111 * x135**2
x181 = x113 + x180
x182 = x181 * x80
x183 = 0.0222222222222222222 * x151
x184 = x182 * x183
x185 = x135 * x141
x186 = x147 + x185
x187 = 1.73205080756887729
x188 = x186 * x187
x189 = x110 * x80
x190 = 0.111111111111111111 * x70
x191 = x132 * x187
x192 = x187 * x97
x193 = x135 * x149
x194 = x158 + x193
x195 = 0.111111111111111111 * x194
x196 = 0.333333333333333333 * x80
x197 = x196 * x97
x198 = 0.111111111111111111 * x123
x199 = 2.0 * x0 * (2.0 * x147 + x148 + x185)
x200 = x194 * x88
x201 = x199 + x200
x202 = x80 * x95
x203 = x183 * x202
x204 = x135 * x145
x205 = x166 * x196
x206 = x168 * x196
x207 = x145 * x95
x208 = x196 * x95
x209 = x110 * x163**2
x210 = x122 + x209
x211 = x210 * x80
x212 = x183 * x211
x213 = x126 * x187
x214 = x163 * x168
x215 = x171 + x214
x216 = x187 * x215
x217 = x111 * x80
x218 = 0.111111111111111111 * x114
x219 = x196 * x215
x220 = x163 * x173
x221 = x177 + x220
x222 = 0.111111111111111111 * x221
x223 = x127 * x183
x224 = 2.0 * x0 * (2.0 * x171 + x172 + x214)
x225 = x102 * x221
x226 = x224 + x225
x227 = x60 + x75
x228 = x135 * x181 + x139 * x44
x229 = x136 * x228
x230 = x0 * (x157 + x180)
x231 = x135 * x186
x232 = x230 + x231
x233 = x110 * x145
x234 = x143 * x229
x235 = x135 * x194
x236 = x199 + x235
x237 = x151 * x66
x238 = x136 * x232
x239 = 3.0 * x193
x240 = x0 * (5.0 * x158 + 2.0 * x159 + x239) + x135 * x201
x241 = x136 * x64
x242 = x143 * x241
x243 = x145 * x227
x244 = x181 * x196
x245 = x196 * x64
x246 = x196 * x210
x247 = x187 * x219
x248 = x196 * x221
x249 = x163 * x210 + x166 * x44
x250 = x136 * x249
x251 = x143 * x250
x252 = x0 * (x176 + x209)
x253 = x163 * x215
x254 = x252 + x253
x255 = x111 * x145
x256 = x136 * x254
x257 = x163 * x221
x258 = x224 + x257
x259 = 3.0 * x220
x260 = x0 * (5.0 * x177 + 2.0 * x178 + x259) + x163 * x226
x261 = 2.0 * x0 * (2.0 * x19 + x27 + x57) + x59 * x9
x262 = x81 * (x0 * (x155 + 3.0 * x180) + x135 * x228)
x263 = x110 * x79
x264 = x0 * (3.0 * x147 + 3.0 * x185 + x228) + x135 * x232
x265 = x110 * x90
x266 = x132 * x89
x267 = x0 * (3.0 * x158 + 2.0 * x230 + 2.0 * x231 + x239) + x135 * x236
x268 = x132 * x81
x269 = x118 * x58
x270 = 3.0 * x0 * (2.0 * x199 + x200 + x235) + x135 * x240
x271 = x55 + x6
x272 = x271 * x81
x273 = x145 * x166
x274 = x151 * x58
x275 = x136 * x271
x276 = x143 * x275
x277 = 0.111111111111111111 * x59
x278 = x187 * x58
x279 = x271 * x80
x280 = x139 * x145
x281 = x0 * (x174 + 3.0 * x209) + x163 * x249
x282 = x281 * x81
x283 = x111 * x79
x284 = x126 * x89
x285 = x0 * (3.0 * x171 + 3.0 * x214 + x249) + x163 * x254
x286 = x111 * x90
x287 = x285 * x81
x288 = x0 * (3.0 * x177 + 2.0 * x252 + 2.0 * x253 + x259) + x163 * x258
x289 = 3.0 * x0 * (2.0 * x224 + x225 + x257) + x163 * x260
x290 = x10 * x41
x291 = x31 * x9
x292 = 3.0 * x40
x293 = x0 * (2.0 * x291 + x292 + 5.0 * x39) + x10 * x43
x294 = 3.0 * x0 * (x290 + 2.0 * x36 + x42) + x10 * x293
x295 = -x87 - R[1]
x296 = x111 * x295**2
x297 = x113 + x296
x298 = x297 * x81
x299 = x111 * x295
x300 = x0 * (x126 + x299)
x301 = x126 * x295
x302 = x113 + x301
x303 = x295 * x302
x304 = x300 + x303
x305 = x0 * (x129 + x38)
x306 = x10 * x106
x307 = x290 + x36
x308 = x0 * (x292 + 2.0 * x305 + 2.0 * x306 + 3.0 * x39) + x10 * x307
x309 = 2.0 * x88
x310 = x155 + x296
x311 = x0 * (x299 * x309 + x310) + x304 * x88
x312 = x129 + x6
x313 = x10 * x312 + x11 * x44
x314 = x305 + x306
x315 = x0 * (3.0 * x28 + x313 + 3.0 * x35) + x10 * x314
x316 = x118 * x304
x317 = x302 * x88
x318 = 2.0 * x0 * (2.0 * x300 + x303 + x317) + x311 * x88
x319 = x0 * (3.0 * x129 + x7) + x10 * x313
x320 = x319 * x82
x321 = x319 * x90
x322 = x0 * (x139 + x299)
x323 = x139 * x295
x324 = x113 + x323
x325 = x295 * x324
x326 = x322 + x325
x327 = x110 * x136
x328 = x0 * (x140 + x155 + x301 + x323)
x329 = x135 * x302
x330 = x300 + x329
x331 = x295 * x330
x332 = x328 + x331
x333 = x145 * x326
x334 = 2.0 * x329
x335 = 3.0 * x300 + x334
x336 = x0 * (x303 + x326 + x335)
x337 = x332 * x88
x338 = x336 + x337
x339 = x136 * x314
x340 = x143 * x339
x341 = x132 * x151
x342 = x330 * x88
x343 = 2.0 * x342
x344 = 4.0 * x328
x345 = 2.0 * x331 + x344
x346 = x0 * (x311 + x343 + x345)
x347 = x338 * x88
x348 = x346 + x347
x349 = x136 * x313
x350 = x143 * x349
x351 = x136 * x297
x352 = x143 * x297
x353 = x151 * x304
x354 = x156 * x299
x355 = x0 * (x310 + x354)
x356 = x135 * x326
x357 = x355 + x356
x358 = x357 * x80
x359 = x183 * x358
x360 = x135 * x332
x361 = x336 + x360
x362 = x187 * x361
x363 = 0.111111111111111111 * x41
x364 = x106 * x187
x365 = x135 * x338
x366 = x346 + x365
x367 = 0.111111111111111111 * x366
x368 = x106 * x196
x369 = x0 * (x149 + x317 + x335)
x370 = x328 + x342
x371 = x135 * x370
x372 = 2.0 * x0 * (2.0 * x336 + x337 + x360 + x369 + x371)
x373 = x366 * x88
x374 = x372 + x373
x375 = x312 * x80
x376 = x183 * x375
x377 = x196 * x326
x378 = x187 * x368
x379 = x196 * x312
x380 = x187 * x304
x381 = x297 * x80
x382 = 0.111111111111111111 * x311
x383 = x135 * x324
x384 = 2.0 * x0 * (2.0 * x322 + x325 + x383) + x135 * x357
x385 = x291 + x39
x386 = x135 * x330
x387 = 2.0 * x386
x388 = x0 * (x345 + x357 + x387)
x389 = x135 * x361
x390 = x388 + x389
x391 = x145 * x384
x392 = x135 * x366
x393 = x372 + x392
x394 = x136 * x29
x395 = x369 + x371
x396 = x395 * x88
x397 = x0 * (x194 + x343 + x344 + x387)
x398 = 3.0 * x365 + 2.0 * x397
x399 = x0 * (5.0 * x346 + 2.0 * x347 + 2.0 * x396 + x398) + x135 * x374
x400 = x3 * x85
x401 = x399 * x400
x402 = x10 * x136
x403 = x102 * x400
x404 = x10 * x145
x405 = x11 * x136
x406 = x136 * x384
x407 = x196 * x357
x408 = x196 * x29
x409 = x163 * x400
x410 = x11 * x196
x411 = x11 * x145
x412 = x322 + x383
x413 = (
x0 * (x156 * x412 + 3.0 * x355 + 3.0 * x356 + x44 * (x155 + x180 + x354))
+ x135 * x384
)
x414 = x37 + x6
x415 = x25 * x6 + x414 * x9
x416 = x415 * x79
x417 = x110 * x81
x418 = (
x0
* (
x156 * (x328 + x386)
+ 3.0 * x336
+ 3.0 * x360
+ x384
+ x44 * (x186 + 2.0 * x300 + x334 + x412)
)
+ x135 * x390
)
x419 = x414 * x89
x420 = x400 * (
x0 * (x156 * x395 + 3.0 * x346 + 2.0 * x388 + 2.0 * x389 + x398) + x135 * x393
)
x421 = x9 * x90
x422 = x5 * x81
x423 = x143 * x414
x424 = x15 * x151
x425 = x143 * x5
x426 = x145 * x5
x427 = x136 * x5
x428 = 0.111111111111111111 * x414
x429 = x15 * x187
x430 = x5 * x80
x431 = x15 * x89
x432 = x5 * x79
x433 = x5 * x90
x434 = -x101 - R[2]
x435 = x110 * x434**2
x436 = x122 + x435
x437 = x436 * x81
x438 = x110 * x434
x439 = x0 * (x132 + x438)
x440 = x132 * x434
x441 = x122 + x440
x442 = x434 * x441
x443 = x439 + x442
x444 = x126 * x81
x445 = x118 * x443
x446 = 2.0 * x102
x447 = x174 + x435
x448 = x0 * (x438 * x446 + x447) + x102 * x443
x449 = x102 * x441
x450 = 2.0 * x0 * (2.0 * x439 + x442 + x449) + x102 * x448
x451 = x136 * x436
x452 = x143 * x436
x453 = x151 * x443
x454 = x0 * (x166 + x438)
x455 = x166 * x434
x456 = x122 + x455
x457 = x434 * x456
x458 = x454 + x457
x459 = x111 * x136
x460 = x145 * x458
x461 = x0 * (x167 + x174 + x440 + x455)
x462 = x163 * x441
x463 = x439 + x462
x464 = x434 * x463
x465 = x461 + x464
x466 = x126 * x151
x467 = 2.0 * x462
x468 = 3.0 * x439 + x467
x469 = x0 * (x442 + x458 + x468)
x470 = x102 * x465
x471 = x469 + x470
x472 = x102 * x463
x473 = 2.0 * x472
x474 = 4.0 * x461
x475 = 2.0 * x464 + x474
x476 = x0 * (x448 + x473 + x475)
x477 = x102 * x471
x478 = x476 + x477
x479 = x436 * x80
x480 = x187 * x443
x481 = 0.111111111111111111 * x448
x482 = x196 * x458
x483 = x139 * x196
x484 = x175 * x438
x485 = x0 * (x447 + x484)
x486 = x163 * x458
x487 = x485 + x486
x488 = x487 * x80
x489 = x183 * x488
x490 = x163 * x465
x491 = x469 + x490
x492 = x187 * x491
x493 = x163 * x471
x494 = x476 + x493
x495 = 0.111111111111111111 * x494
x496 = x0 * (x173 + x449 + x468)
x497 = x461 + x472
x498 = x163 * x497
x499 = 2.0 * x0 * (2.0 * x469 + x470 + x490 + x496 + x498)
x500 = x102 * x494
x501 = x499 + x500
x502 = x145 * x436
x503 = x196 * x487
x504 = 3.14159265358979324 * x1 * x3 * x83
x505 = x204 * x504
x506 = x163 * x456
x507 = 2.0 * x0 * (2.0 * x454 + x457 + x506) + x163 * x487
x508 = x145 * x507
x509 = x163 * x463
x510 = 2.0 * x509
x511 = x0 * (x475 + x487 + x510)
x512 = x163 * x491
x513 = x511 + x512
x514 = x163 * x494
x515 = x499 + x514
x516 = x136 * x507
x517 = x496 + x498
x518 = x102 * x517
x519 = x0 * (x221 + x473 + x474 + x510)
x520 = 3.0 * x493 + 2.0 * x519
x521 = x0 * (5.0 * x476 + 2.0 * x477 + 2.0 * x518 + x520) + x163 * x501
x522 = x504 * x521
x523 = x454 + x506
x524 = (
x0 * (x175 * x523 + x44 * (x174 + x209 + x484) + 3.0 * x485 + 3.0 * x486)
+ x163 * x507
)
x525 = x111 * x81
x526 = (
x0
* (
x175 * (x461 + x509)
+ x44 * (x215 + 2.0 * x439 + x467 + x523)
+ 3.0 * x469
+ 3.0 * x490
+ x507
)
+ x163 * x513
)
x527 = x504 * (
x0 * (x175 * x517 + 3.0 * x476 + 2.0 * x511 + 2.0 * x512 + x520) + x163 * x515
)
# 450 item(s)
result[0] += (
x82
* x86
* (
x0
* (
x44 * (x24 * x25 + 3.0 * x26 + 5.0 * x34 + x43)
+ x52 * (x49 + x51)
+ 3.0 * x71
+ 3.0 * x72
+ 6.0 * x74
)
+ x10 * x78
)
)
result[1] += x100 * x91
result[2] += x100 * x103
result[3] += x109 * x110 * x116
result[4] += x109 * x117 * x120
result[5] += x109 * x111 * x125
result[6] += x110 * x128 * x131
result[7] += x116 * x130 * x132
result[8] += x125 * x126 * x130
result[9] += x111 * x131 * x134
result[10] += x137 * x138
result[11] += x110 * x142 * x144
result[12] += x117 * x135 * x146
result[13] += x110 * x149 * x150
result[14] += x132 * x142 * x152
result[15] += x139 * x153 * x154
result[16] += x110 * x160 * x161
result[17] += x132 * x149 * x162
result[18] += x107 * x142 * x153
result[19] += x133 * x139 * x161
result[20] += x138 * x164
result[21] += x146 * x165 * x88
result[22] += x111 * x144 * x169
result[23] += x154 * x166 * x170
result[24] += x126 * x152 * x169
result[25] += x111 * x150 * x173
result[26] += x127 * x161 * x166
result[27] += x107 * x169 * x170
result[28] += x126 * x162 * x173
result[29] += x111 * x161 * x179
result[30] += x110 * x184 * x77
result[31] += x188 * x189 * x190
result[32] += x182 * x190 * x191
result[33] += x189 * x192 * x195
result[34] += x132 * x186 * x197
result[35] += x182 * x192 * x198
result[36] += x110 * x201 * x203
result[37] += x191 * x195 * x202
result[38] += x188 * x198 * x202
result[39] += x133 * x184 * x95
result[40] += x165 * x204 * x77
result[41] += x141 * x205 * x70
result[42] += x139 * x206 * x70
result[43] += x149 * x166 * x197
result[44] += x141 * x192 * x206
result[45] += x139 * x173 * x197
result[46] += x160 * x166 * x207
result[47] += x149 * x168 * x208
result[48] += x141 * x173 * x208
result[49] += x139 * x179 * x207
result[50] += x111 * x212 * x77
result[51] += x190 * x211 * x213
result[52] += x190 * x216 * x217
result[53] += x192 * x211 * x218
result[54] += x126 * x219 * x97
result[55] += x192 * x217 * x222
result[56] += x202 * x210 * x223
result[57] += x202 * x216 * x218
result[58] += x202 * x213 * x222
result[59] += x111 * x203 * x226
result[60] += x110 * x227 * x229
result[61] += x232 * x233 * x68
result[62] += x132 * x234 * x68
result[63] += x233 * x236 * x66
result[64] += x132 * x237 * x238
result[65] += x153 * x229 * x66
result[66] += x110 * x240 * x241
result[67] += x132 * x236 * x242
result[68] += x153 * x232 * x241
result[69] += x133 * x228 * x241
result[70] += x166 * x181 * x243
result[71] += x186 * x205 * x68
result[72] += x168 * x244 * x68
result[73] += x194 * x205 * x66
result[74] += x188 * x206 * x66
result[75] += x173 * x244 * x66
result[76] += x166 * x201 * x242
result[77] += x168 * x194 * x245
result[78] += x173 * x186 * x245
result[79] += x179 * x181 * x242
result[80] += x139 * x210 * x243
result[81] += x141 * x246 * x68
result[82] += x139 * x219 * x68
result[83] += x149 * x246 * x66
result[84] += x141 * x247 * x66
result[85] += x139 * x248 * x66
result[86] += x160 * x210 * x242
result[87] += x149 * x215 * x245
result[88] += x141 * x221 * x245
result[89] += x139 * x226 * x242
result[90] += x111 * x227 * x250
result[91] += x126 * x251 * x68
result[92] += x254 * x255 * x68
result[93] += x170 * x250 * x66
result[94] += x126 * x237 * x256
result[95] += x255 * x258 * x66
result[96] += x127 * x241 * x249
result[97] += x170 * x241 * x254
result[98] += x126 * x242 * x258
result[99] += x111 * x241 * x260
result[100] += x261 * x262 * x263
result[101] += x264 * x265 * x59
result[102] += x262 * x266 * x59
result[103] += x265 * x267 * x58
result[104] += x264 * x268 * x269
result[105] += x124 * x262 * x58
result[106] += x263 * x270 * x272
result[107] += x266 * x267 * x272
result[108] += x124 * x264 * x272
result[109] += x134 * x262 * x271
result[110] += x166 * x229 * x261
result[111] += x232 * x273 * x59
result[112] += x168 * x234 * x59
result[113] += x236 * x273 * x58
result[114] += x169 * x232 * x274
result[115] += x173 * x234 * x58
result[116] += x166 * x240 * x275
result[117] += x168 * x236 * x276
result[118] += x173 * x232 * x276
result[119] += x179 * x228 * x275
result[120] += x184 * x210 * x261
result[121] += x188 * x211 * x277
result[122] += x182 * x216 * x277
result[123] += x195 * x211 * x278
result[124] += x186 * x219 * x58
result[125] += x182 * x222 * x278
result[126] += x201 * x212 * x271
result[127] += x195 * x216 * x279
result[128] += x188 * x222 * x279
result[129] += x184 * x226 * x271
result[130] += x139 * x250 * x261
result[131] += x141 * x251 * x59
result[132] += x254 * x280 * x59
result[133] += x149 * x251 * x58
result[134] += x142 * x254 * x274
result[135] += x258 * x280 * x58
result[136] += x160 * x249 * x275
result[137] += x149 * x254 * x276
result[138] += x141 * x258 * x276
result[139] += x139 * x260 * x275
result[140] += x261 * x282 * x283
result[141] += x282 * x284 * x59
result[142] += x285 * x286 * x59
result[143] += x115 * x282 * x58
result[144] += x126 * x269 * x287
result[145] += x286 * x288 * x58
result[146] += x128 * x272 * x281
result[147] += x115 * x272 * x285
result[148] += x272 * x284 * x288
result[149] += x272 * x283 * x289
result[150] += x263 * x294 * x298
result[151] += x265 * x304 * x308
result[152] += x266 * x298 * x308
result[153] += x265 * x311 * x315
result[154] += x268 * x315 * x316
result[155] += x125 * x297 * x315
result[156] += x110 * x318 * x320
result[157] += x132 * x311 * x321
result[158] += x125 * x304 * x319
result[159] += x134 * x298 * x319
result[160] += x293 * x326 * x327
result[161] += x233 * x307 * x332
result[162] += x132 * x307 * x333
result[163] += x110 * x338 * x340
result[164] += x332 * x339 * x341
result[165] += x153 * x326 * x339
result[166] += x110 * x348 * x349
result[167] += x132 * x338 * x350
result[168] += x153 * x332 * x349
result[169] += x133 * x326 * x349
result[170] += x166 * x293 * x351
result[171] += x273 * x304 * x307
result[172] += x169 * x307 * x352
result[173] += x166 * x311 * x340
result[174] += x169 * x314 * x353
result[175] += x173 * x339 * x352
result[176] += x166 * x318 * x349
result[177] += x168 * x311 * x350
result[178] += x173 * x304 * x350
result[179] += x179 * x297 * x349
result[180] += x110 * x359 * x43
result[181] += x189 * x362 * x363
result[182] += x191 * x358 * x363
result[183] += x189 * x364 * x367
result[184] += x132 * x361 * x368
result[185] += x198 * x358 * x364
result[186] += x110 * x374 * x376
result[187] += x191 * x367 * x375
result[188] += x198 * x362 * x375
result[189] += x133 * x312 * x359
result[190] += x166 * x333 * x43
result[191] += x205 * x332 * x41
result[192] += x168 * x377 * x41
result[193] += x166 * x338 * x368
result[194] += x168 * x332 * x378
result[195] += x106 * x173 * x377
result[196] += x273 * x312 * x348
result[197] += x168 * x338 * x379
result[198] += x173 * x332 * x379
result[199] += x179 * x312 * x333
result[200] += x212 * x297 * x43
result[201] += x211 * x363 * x380
result[202] += x216 * x363 * x381
result[203] += x211 * x364 * x382
result[204] += x106 * x219 * x304
result[205] += x222 * x364 * x381
result[206] += x212 * x312 * x318
result[207] += x216 * x375 * x382
result[208] += x222 * x375 * x380
result[209] += x226 * x297 * x376
result[210] += x327 * x384 * x385
result[211] += x233 * x31 * x390
result[212] += x132 * x31 * x391
result[213] += x233 * x29 * x393
result[214] += x341 * x390 * x394
result[215] += x153 * x384 * x394
result[216] += x401 * x402
result[217] += x393 * x403 * x404
result[218] += x153 * x390 * x405
result[219] += x11 * x133 * x406
result[220] += x273 * x357 * x385
result[221] += x205 * x31 * x361
result[222] += x168 * x31 * x407
result[223] += x166 * x366 * x408
result[224] += x206 * x29 * x362
result[225] += x173 * x29 * x407
result[226] += x374 * x404 * x409
result[227] += x11 * x206 * x366
result[228] += x173 * x361 * x410
result[229] += x179 * x357 * x411
result[230] += x210 * x333 * x385
result[231] += x246 * x31 * x332
result[232] += x219 * x31 * x326
result[233] += x246 * x29 * x338
result[234] += x247 * x29 * x332
result[235] += x221 * x29 * x377
result[236] += x210 * x348 * x411
result[237] += x11 * x219 * x338
result[238] += x11 * x248 * x332
result[239] += x11 * x226 * x333
result[240] += x250 * x297 * x385
result[241] += x251 * x304 * x31
result[242] += x256 * x31 * x352
result[243] += x251 * x29 * x311
result[244] += x254 * x353 * x394
result[245] += x258 * x352 * x394
result[246] += x11 * x250 * x318
result[247] += x254 * x311 * x411
result[248] += x258 * x304 * x411
result[249] += x11 * x260 * x351
result[250] += x413 * x416 * x417
result[251] += x417 * x418 * x419
result[252] += x268 * x413 * x419
result[253] += x420 * x421
result[254] += x119 * x403 * x418 * x9
result[255] += x125 * x15 * x413
result[256] += (
x400
* x82
* (
x0
* (
x156 * (x396 + x397)
+ 6.0 * x372
+ 3.0 * x373
+ 3.0 * x392
+ x44 * (x201 + x309 * x370 + 5.0 * x369 + 3.0 * x371)
)
+ x135 * x399
)
)
result[257] += x103 * x420
result[258] += x125 * x418 * x5
result[259] += x134 * x413 * x422
result[260] += x166 * x406 * x415
result[261] += x273 * x390 * x414
result[262] += x169 * x384 * x423
result[263] += x145 * x393 * x409 * x9
result[264] += x169 * x390 * x424
result[265] += x15 * x173 * x391
result[266] += x164 * x401
result[267] += x169 * x393 * x425
result[268] += x173 * x390 * x426
result[269] += x179 * x384 * x427
result[270] += x212 * x357 * x415
result[271] += x211 * x362 * x428
result[272] += x216 * x358 * x428
result[273] += x211 * x367 * x429
result[274] += x15 * x219 * x361
result[275] += x222 * x358 * x429
result[276] += x212 * x374 * x5
result[277] += x216 * x367 * x430
result[278] += x222 * x362 * x430
result[279] += x226 * x359 * x5
result[280] += x250 * x326 * x415
result[281] += x251 * x332 * x414
result[282] += x254 * x333 * x414
result[283] += x15 * x251 * x338
result[284] += x256 * x332 * x424
result[285] += x15 * x258 * x333
result[286] += x250 * x348 * x5
result[287] += x254 * x338 * x426
result[288] += x258 * x332 * x426
result[289] += x260 * x326 * x427
result[290] += x282 * x297 * x416
result[291] += x282 * x304 * x419
result[292] += x285 * x298 * x419
result[293] += x282 * x311 * x431
result[294] += x15 * x287 * x316
result[295] += x288 * x298 * x431
result[296] += x282 * x318 * x432
result[297] += x285 * x311 * x433
result[298] += x288 * x304 * x433
result[299] += x289 * x298 * x432
result[300] += x283 * x294 * x437
result[301] += x284 * x308 * x437
result[302] += x286 * x308 * x443
result[303] += x115 * x315 * x437
result[304] += x315 * x444 * x445
result[305] += x286 * x315 * x448
result[306] += x128 * x319 * x437
result[307] += x116 * x319 * x443
result[308] += x126 * x321 * x448
result[309] += x111 * x320 * x450
result[310] += x139 * x293 * x451
result[311] += x142 * x307 * x452
result[312] += x280 * x307 * x443
result[313] += x149 * x339 * x452
result[314] += x142 * x314 * x453
result[315] += x139 * x340 * x448
result[316] += x160 * x349 * x436
result[317] += x149 * x350 * x443
result[318] += x141 * x350 * x448
result[319] += x139 * x349 * x450
result[320] += x293 * x458 * x459
result[321] += x126 * x307 * x460
result[322] += x255 * x307 * x465
result[323] += x170 * x339 * x458
result[324] += x339 * x465 * x466
result[325] += x111 * x340 * x471
result[326] += x127 * x349 * x458
result[327] += x170 * x349 * x465
result[328] += x126 * x350 * x471
result[329] += x111 * x349 * x478
result[330] += x184 * x43 * x436
result[331] += x188 * x363 * x479
result[332] += x182 * x363 * x480
result[333] += x195 * x364 * x479
result[334] += x186 * x368 * x443
result[335] += x182 * x364 * x481
result[336] += x201 * x376 * x436
result[337] += x195 * x375 * x480
result[338] += x188 * x375 * x481
result[339] += x184 * x312 * x450
result[340] += x139 * x43 * x460
result[341] += x141 * x41 * x482
result[342] += x41 * x465 * x483
result[343] += x149 * x368 * x458
result[344] += x141 * x378 * x465
result[345] += x139 * x368 * x471
result[346] += x160 * x312 * x460
result[347] += x149 * x379 * x465
result[348] += x141 * x379 * x471
result[349] += x280 * x312 * x478
result[350] += x111 * x43 * x489
result[351] += x213 * x363 * x488
result[352] += x217 * x363 * x492
result[353] += x218 * x364 * x488
result[354] += x126 * x368 * x491
result[355] += x217 * x364 * x495
result[356] += x223 * x375 * x487
result[357] += x218 * x375 * x492
result[358] += x213 * x375 * x495
result[359] += x111 * x376 * x501
result[360] += x229 * x385 * x436
result[361] += x232 * x31 * x502
result[362] += x234 * x31 * x443
result[363] += x236 * x29 * x502
result[364] += x232 * x394 * x453
result[365] += x234 * x29 * x448
result[366] += x11 * x240 * x451
result[367] += x236 * x411 * x443
result[368] += x232 * x411 * x448
result[369] += x11 * x229 * x450
result[370] += x181 * x385 * x460
result[371] += x186 * x31 * x482
result[372] += x244 * x31 * x465
result[373] += x194 * x29 * x482
result[374] += x188 * x408 * x465
result[375] += x244 * x29 * x471
result[376] += x11 * x201 * x460
result[377] += x194 * x410 * x465
result[378] += x186 * x410 * x471
result[379] += x181 * x411 * x478
result[380] += x280 * x385 * x487
result[381] += x141 * x31 * x503
result[382] += x31 * x483 * x491
result[383] += x149 * x29 * x503
result[384] += x141 * x408 * x492
result[385] += x139 * x408 * x494
result[386] += x160 * x411 * x487
result[387] += x149 * x410 * x491
result[388] += x141 * x410 * x494
result[389] += x10 * x501 * x505
result[390] += x385 * x459 * x507
result[391] += x126 * x31 * x508
result[392] += x255 * x31 * x513
result[393] += x170 * x394 * x507
result[394] += x394 * x466 * x513
result[395] += x255 * x29 * x515
result[396] += x11 * x127 * x516
result[397] += x170 * x405 * x513
result[398] += x404 * x504 * x515 * x88
result[399] += x402 * x522
result[400] += x262 * x416 * x436
result[401] += x264 * x419 * x437
result[402] += x262 * x419 * x443
result[403] += x267 * x431 * x437
result[404] += x15 * x264 * x445 * x81
result[405] += x262 * x431 * x448
result[406] += x270 * x432 * x437
result[407] += x267 * x433 * x443
result[408] += x264 * x433 * x448
result[409] += x262 * x432 * x450
result[410] += x229 * x415 * x458
result[411] += x232 * x414 * x460
result[412] += x234 * x414 * x465
result[413] += x15 * x236 * x460
result[414] += x238 * x424 * x465
result[415] += x15 * x234 * x471
result[416] += x240 * x427 * x458
result[417] += x236 * x426 * x465
result[418] += x232 * x426 * x471
result[419] += x229 * x478 * x5
result[420] += x184 * x415 * x487
result[421] += x188 * x428 * x488
result[422] += x182 * x428 * x492
result[423] += x195 * x429 * x488
result[424] += x15 * x186 * x196 * x491
result[425] += x182 * x429 * x495
result[426] += x201 * x489 * x5
result[427] += x195 * x430 * x492
result[428] += x188 * x430 * x495
result[429] += x184 * x5 * x501
result[430] += x139 * x415 * x516
result[431] += x142 * x423 * x507
result[432] += x280 * x414 * x513
result[433] += x149 * x15 * x508
result[434] += x142 * x424 * x513
result[435] += x505 * x515 * x9
result[436] += x160 * x427 * x507
result[437] += x149 * x426 * x513
result[438] += x142 * x425 * x515
result[439] += x137 * x522
result[440] += x416 * x524 * x525
result[441] += x419 * x444 * x524
result[442] += x419 * x525 * x526
result[443] += x116 * x15 * x524
result[444] += x120 * x504 * x526 * x9
result[445] += x421 * x527
result[446] += x128 * x422 * x524
result[447] += x116 * x5 * x526
result[448] += x527 * x91
result[449] += (
x504
* x82
* (
x0
* (
x175 * (x518 + x519)
+ x44 * (x226 + x446 * x497 + 5.0 * x496 + 3.0 * x498)
+ 6.0 * x499
+ 3.0 * x500
+ 3.0 * x514
)
+ x163 * x521
)
)
[docs]
@numba.jit(
func_type.signature,
nopython=True,
nogil=True,
fastmath=True,
cache=True,
)
def diag_quadrupole3d_34(ax, da, A, bx, db, B, R, result):
"""See docstring of diag_quadrupole3d_43."""
# Call equivalent function and write to result
tmp = numpy.zeros_like(result)
diag_quadrupole3d_43(bx, db, B, ax, da, A, R, tmp)
result[:] += numpy.transpose(tmp.reshape(3, 15, 10), axes=(0, 2, 1)).flatten()
[docs]
@numba.jit(
func_type.signature,
nopython=True,
nogil=True,
fastmath=True,
cache=True,
)
def diag_quadrupole3d_44(ax, da, A, bx, db, B, R, result):
"""Cartesian 3D (gg) quadrupole moment integrals
for operators x², y² and z². The origin is at R.
Generated code; DO NOT modify by hand!"""
x0 = 0.5 / (ax + bx)
x1 = (ax + bx) ** (-1.0)
x2 = -x1 * (ax * A[0] + bx * B[0])
x3 = -x2 - A[0]
x4 = -x2 - B[0]
x5 = ax * bx * x1
x6 = numpy.exp(-x5 * (A[0] - B[0]) ** 2)
x7 = 1.77245385090551603 * numpy.sqrt(x1)
x8 = x6 * x7
x9 = x0 * x8
x10 = -x2 - R[0]
x11 = x4 * x8
x12 = x10 * x11
x13 = x12 + x9
x14 = x13 * x4
x15 = x3 * x6
x16 = x15 * x7
x17 = x0 * (x11 + x16)
x18 = x16 * x4
x19 = x18 + x9
x20 = x19 * x4
x21 = x17 + x20
x22 = x13 * x3
x23 = 2.0 * x22
x24 = x10 * x8
x25 = x0 * (x11 + x24)
x26 = x23 + 3.0 * x25
x27 = x0 * (x14 + x21 + x26)
x28 = 3.0 * x9
x29 = x10 * x16
x30 = x0 * (x12 + x18 + x28 + x29)
x31 = x22 + x25
x32 = x31 * x4
x33 = x30 + x32
x34 = x3 * x33
x35 = x27 + x34
x36 = x3 * x35
x37 = x35 * x4
x38 = x3 * x31
x39 = 2.0 * x38
x40 = 2.0 * x4
x41 = x16 * x40
x42 = x4**2 * x8
x43 = x28 + x42
x44 = x0 * (x41 + x43)
x45 = x21 * x3
x46 = x44 + x45
x47 = 4.0 * x30
x48 = 2.0 * x32 + x47
x49 = x0 * (x39 + x46 + x48)
x50 = x21 * x4
x51 = 3.0 * x45
x52 = x0 * (5.0 * x44 + 2.0 * x50 + x51)
x53 = x19 * x3
x54 = 2.0 * x0 * (2.0 * x17 + x20 + x53)
x55 = x4 * x46
x56 = x54 + x55
x57 = x3 * x56
x58 = x52 + x57
x59 = 2.0 * x0
x60 = x33 * x40
x61 = x0 * (5.0 * x27 + 3.0 * x34 + x56 + x60)
x62 = x3 * (x37 + x49)
x63 = 2.0 * x27
x64 = x10 * x31
x65 = x30 + x64
x66 = x3 * x65
x67 = x4 * x65
x68 = x10 * x13
x69 = x0 * (x16 + x24)
x70 = x29 + x9
x71 = x10 * x70
x72 = x69 + x71
x73 = x0 * (x26 + x68 + x72)
x74 = x0 * (2.0 * x34 + x63 + 2.0 * x66 + 2.0 * x67 + 4.0 * x73)
x75 = 2.0 * x64
x76 = x24 * x40
x77 = x10**2 * x8
x78 = x28 + x77
x79 = x0 * (x76 + x78)
x80 = x25 + x68
x81 = x4 * x80
x82 = x79 + x81
x83 = x0 * (x48 + x75 + x82)
x84 = x67 + x73
x85 = x3 * x84
x86 = x83 + x85
x87 = x4 * x86
x88 = x74 + x87
x89 = x4 * x88
x90 = x3 * x88
x91 = x4 * x84
x92 = 2.0 * x49 + 3.0 * x85
x93 = x0 * (2.0 * x37 + 5.0 * x83 + 2.0 * x91 + x92)
x94 = x3 * x86
x95 = x0 * (2.0 * x61 + 2.0 * x62 + 6.0 * x74 + 3.0 * x87 + 3.0 * x94)
x96 = x90 + x93
x97 = x4 * x96 + x95
x98 = numpy.exp(-x5 * (A[1] - B[1]) ** 2)
x99 = da * db
x100 = 0.00952380952380952381 * x99
x101 = numpy.exp(-x5 * (A[2] - B[2]) ** 2)
x102 = 3.14159265358979324 * x1 * x101
x103 = x100 * x102
x104 = x103 * x98
x105 = -x1 * (ax * A[1] + bx * B[1])
x106 = -x105 - B[1]
x107 = 2.64575131106459059
x108 = x104 * x107
x109 = x108 * (x3 * x96 + x95)
x110 = -x1 * (ax * A[2] + bx * B[2])
x111 = -x110 - B[2]
x112 = 2.0 * x3
x113 = x112 * x24
x114 = x0 * (x113 + x78)
x115 = x3 * x72
x116 = x114 + x115
x117 = x0 * (x116 + x39 + x47 + x75)
x118 = x66 + x73
x119 = x118 * x3
x120 = x74 + x94
x121 = x0 * (2.0 * x117 + 2.0 * x119 + 2.0 * x36 + 3.0 * x83 + x92) + x120 * x3
x122 = x101 * x7
x123 = 0.0325300024316177726
x124 = x7 * x98
x125 = x106**2 * x124
x126 = x0 * x124
x127 = x125 + x126
x128 = x127 * x99
x129 = x123 * x128
x130 = 5.91607978309961604
x131 = x104 * x130
x132 = x111**2 * x122
x133 = x0 * x122
x134 = x132 + x133
x135 = x134 * x99
x136 = x123 * x135
x137 = x3 * x70
x138 = x137 + x69
x139 = x17 + x53
x140 = 3.0 * x73
x141 = 2.0 * x0 * (x137 + 2.0 * x69 + x71) + x116 * x3
x142 = x117 + x119
x143 = (
x0
* (
x112 * (x30 + x38)
+ x140
+ x141
+ x59 * (x138 + x139 + x23 + 2.0 * x25)
+ 3.0 * x66
)
+ x142 * x3
)
x144 = x106 * x124
x145 = x106 * x127 + x144 * x59
x146 = x107 * x145
x147 = x100 * x122
x148 = x111 * x122
x149 = x100 * x130
x150 = x143 * x149
x151 = x111 * x134 + x148 * x59
x152 = x107 * x151
x153 = x100 * x124
x154 = 3.0 * x126
x155 = x0 * (3.0 * x125 + x154) + x106 * x145
x156 = x3**2 * x8
x157 = x156 + x28
x158 = x0 * (x112 * x138 + 3.0 * x114 + 3.0 * x115 + x59 * (x113 + x157)) + x141 * x3
x159 = x100 * x158
x160 = 3.0 * x133
x161 = x0 * (3.0 * x132 + x160) + x111 * x151
x162 = -x105 - A[1]
x163 = x108 * x97
x164 = x124 * x162
x165 = x106 * x164
x166 = x126 + x165
x167 = x166 * x99
x168 = 0.0666666666666666667 * x167
x169 = 0.0666666666666666667 * x99
x170 = x102 * x169
x171 = x111 * x170
x172 = x96 * x98
x173 = x0 * (x144 + x164)
x174 = x106 * x166
x175 = x173 + x174
x176 = 0.0860662965823870419
x177 = x176 * x99
x178 = x175 * x177
x179 = 2.2360679774997897
x180 = x168 * x179
x181 = x135 * x176
x182 = 2.0 * x106
x183 = x154 + x164 * x182
x184 = x0 * (x125 + x183)
x185 = x106 * x175
x186 = x184 + x185
x187 = x169 * x186
x188 = x142 * x179
x189 = x151 * x169
x190 = 3.0 * x173
x191 = x0 * (x145 + 3.0 * x174 + x190) + x106 * x186
x192 = x107 * x141
x193 = 0.0666666666666666667 * x141
x194 = x193 * x99
x195 = x141 * x176
x196 = x100 * x192
x197 = -x110 - A[2]
x198 = x170 * x197
x199 = x122 * x197
x200 = x111 * x199
x201 = x133 + x200
x202 = x201 * x99
x203 = 0.0666666666666666667 * x202
x204 = x128 * x176
x205 = x179 * x203
x206 = x0 * (x148 + x199)
x207 = x111 * x201
x208 = x206 + x207
x209 = x177 * x208
x210 = x145 * x169
x211 = x144 * x169
x212 = 2.0 * x111
x213 = x160 + x199 * x212
x214 = x0 * (x132 + x213)
x215 = x111 * x208
x216 = x214 + x215
x217 = x169 * x216
x218 = 3.0 * x206
x219 = x0 * (x151 + 3.0 * x207 + x218) + x111 * x216
x220 = x89 + x93
x221 = x124 * x162**2
x222 = x126 + x221
x223 = x222 * x99
x224 = x123 * x223
x225 = x162 * x166
x226 = x173 + x225
x227 = x122 * x177
x228 = x176 * x223
x229 = x162 * x175
x230 = x184 + x229
x231 = 0.111111111111111111 * x99
x232 = x230 * x231
x233 = 1.73205080756887729
x234 = x226 * x233
x235 = x231 * x234
x236 = x134 * x231
x237 = 2.0 * x0 * (2.0 * x173 + x174 + x225)
x238 = x106 * x230
x239 = x237 + x238
x240 = x118 * x233
x241 = x151 * x176
x242 = 3.0 * x229
x243 = x0 * (5.0 * x184 + 2.0 * x185 + x242)
x244 = x106 * x239
x245 = x243 + x244
x246 = x116 * x99
x247 = x123 * x246
x248 = x176 * x246
x249 = x175 * x233
x250 = x231 * x249
x251 = 0.333333333333333333 * x167
x252 = x208 * x233
x253 = x231 * x252
x254 = x179 * x187
x255 = 0.333333333333333333 * x202
x256 = x179 * x217
x257 = x116 * x149
x258 = x116 * x179
x259 = x122 * x197**2
x260 = x133 + x259
x261 = x260 * x99
x262 = x123 * x261
x263 = x176 * x261
x264 = x197 * x201
x265 = x206 + x264
x266 = x124 * x177
x267 = x127 * x231
x268 = x233 * x265
x269 = x231 * x268
x270 = x197 * x208
x271 = x214 + x270
x272 = x231 * x271
x273 = x145 * x176
x274 = 2.0 * x0 * (2.0 * x206 + x207 + x264)
x275 = x111 * x271
x276 = x274 + x275
x277 = x123 * x155
x278 = 3.0 * x270
x279 = x0 * (5.0 * x214 + 2.0 * x215 + x278)
x280 = x111 * x276
x281 = x279 + x280
x282 = 2.0 * x0 * (x14 + 2.0 * x25 + x68) + x4 * x82
x283 = x83 + x91
x284 = x0 * (x140 + x282 + x60 + x63 + 3.0 * x67) + x283 * x4
x285 = x162 * x222 + x164 * x59
x286 = x107 * x285
x287 = x0 * (x183 + x221)
x288 = x162 * x226
x289 = x287 + x288
x290 = x169 * x283
x291 = 0.0666666666666666667 * x285
x292 = x291 * x99
x293 = x162 * x230
x294 = x237 + x293
x295 = x179 * x289
x296 = x169 * x295
x297 = x162 * x239
x298 = x243 + x297
x299 = x65 * x99
x300 = 0.0666666666666666667 * x299
x301 = x179 * x300
x302 = 3.0 * x0 * (2.0 * x237 + x238 + x293)
x303 = x106 * x298 + x302
x304 = x100 * x72
x305 = x107 * x304
x306 = x169 * x72
x307 = x149 * x284
x308 = x169 * x179
x309 = x283 * x308
x310 = x179 * x222
x311 = x199 * x233
x312 = x222 * x231
x313 = 0.333333333333333333 * x299
x314 = x130 * x304
x315 = x179 * x72
x316 = x179 * x306
x317 = x179 * x260
x318 = x231 * x260
x319 = x233 * x272
x320 = x197 * x260 + x199 * x59
x321 = x107 * x320
x322 = x169 * x320
x323 = x0 * (x213 + x259)
x324 = x197 * x265
x325 = x323 + x324
x326 = x179 * x325
x327 = x197 * x271
x328 = x274 + x327
x329 = 0.0666666666666666667 * x320
x330 = x197 * x276
x331 = x279 + x330
x332 = 3.0 * x0 * (2.0 * x274 + x275 + x327)
x333 = x111 * x331 + x332
x334 = x0 * (x154 + 3.0 * x221) + x162 * x285
x335 = (
x0 * (x40 * (x14 + x25) + x59 * (x43 + x76) + 3.0 * x79 + 3.0 * x81) + x282 * x4
)
x336 = x100 * x335
x337 = x0 * (x190 + 3.0 * x225 + x285) + x162 * x289
x338 = x107 * x282
x339 = x100 * x338
x340 = x0 * (3.0 * x184 + x242 + 2.0 * x287 + 2.0 * x288) + x162 * x294
x341 = x123 * x99
x342 = x341 * x82
x343 = x149 * x82
x344 = x162 * x298 + x302
x345 = x100 * x80
x346 = x107 * x345
x347 = x130 * x345
x348 = x0 * (7.0 * x243 + 3.0 * x244 + 4.0 * x297) + x162 * x303
x349 = x77 + x9
x350 = x100 * x349
x351 = x107 * x350
x352 = x169 * x282
x353 = x177 * x82
x354 = x169 * x80
x355 = x179 * x80
x356 = 0.0666666666666666667 * x349
x357 = x169 * x349
x358 = x176 * x282
x359 = x231 * x82
x360 = x176 * x80
x361 = x123 * x349
x362 = x177 * x349
x363 = x177 * x320
x364 = x0 * (x160 + 3.0 * x259) + x197 * x320
x365 = x0 * (x218 + 3.0 * x264 + x320) + x197 * x325
x366 = x123 * x364
x367 = x0 * (3.0 * x214 + x278 + 2.0 * x323 + 2.0 * x324) + x197 * x328
x368 = x197 * x331 + x332
x369 = x0 * (7.0 * x279 + 3.0 * x280 + 4.0 * x330) + x197 * x333
x370 = x4 * x56
x371 = x3 * x46
x372 = 3.0 * x0 * (x371 + 2.0 * x54 + x55)
x373 = x372 + x4 * x58
x374 = x0 * (3.0 * x370 + 7.0 * x52 + 4.0 * x57) + x3 * x373
x375 = -x105 - R[1]
x376 = x124 * x375**2
x377 = x126 + x376
x378 = x100 * x377
x379 = x3 * x58 + x372
x380 = x124 * x375
x381 = x0 * (x144 + x380)
x382 = x144 * x375
x383 = x126 + x382
x384 = x375 * x383
x385 = x381 + x384
x386 = x100 * x385
x387 = x107 * x122
x388 = x107 * x148
x389 = x154 + x182 * x380
x390 = x0 * (x376 + x389)
x391 = x106 * x385
x392 = x390 + x391
x393 = x0 * (x157 + x41)
x394 = x139 * x3
x395 = x371 + x54
x396 = x0 * (2.0 * x393 + 2.0 * x394 + 3.0 * x44 + x51) + x3 * x395
x397 = x122 * x341
x398 = x130 * x386
x399 = x106 * x383
x400 = 2.0 * x0 * (2.0 * x381 + x384 + x399) + x106 * x392
x401 = 3.0 * x17
x402 = x156 + x9
x403 = x16 * x59 + x3 * x402
x404 = x393 + x394
x405 = x0 * (x401 + x403 + 3.0 * x53) + x3 * x404
x406 = x107 * x147
x407 = x148 * x149
x408 = x0 * (3.0 * x156 + x28) + x3 * x403
x409 = (
x0 * (x182 * (x381 + x399) + 3.0 * x390 + 3.0 * x391 + x59 * (x125 + x389))
+ x106 * x400
)
x410 = x100 * x400
x411 = x0 * (x164 + x380)
x412 = x164 * x375
x413 = x126 + x412
x414 = x375 * x413
x415 = x411 + x414
x416 = x100 * x415
x417 = x0 * (x154 + x165 + x382 + x412)
x418 = x162 * x383
x419 = x381 + x418
x420 = x375 * x419
x421 = x417 + x420
x422 = x169 * x421
x423 = x169 * x415
x424 = 2.0 * x418
x425 = 3.0 * x381 + x424
x426 = x0 * (x384 + x415 + x425)
x427 = x106 * x421
x428 = x426 + x427
x429 = x179 * x422
x430 = 2.0 * x420
x431 = x106 * x419
x432 = 4.0 * x417
x433 = 2.0 * x431 + x432
x434 = x0 * (x392 + x430 + x433)
x435 = x106 * x428
x436 = x434 + x435
x437 = x169 * x436
x438 = x179 * x404
x439 = x169 * x438
x440 = x0 * (x175 + x399 + x425)
x441 = 2.0 * x440
x442 = x417 + x431
x443 = x182 * x442
x444 = 3.0 * x426
x445 = x0 * (x400 + 3.0 * x427 + x441 + x443 + x444) + x106 * x436
x446 = x107 * x403
x447 = x107 * x378
x448 = x169 * x385
x449 = x177 * x392
x450 = x169 * x400
x451 = x100 * x409
x452 = 2.0 * x162
x453 = x154 + x380 * x452
x454 = x0 * (x376 + x453)
x455 = x162 * x415
x456 = x454 + x455
x457 = x370 + x52
x458 = x162 * x421
x459 = x426 + x458
x460 = x177 * x456
x461 = x162 * x428
x462 = x434 + x461
x463 = x231 * x46
x464 = x233 * x463
x465 = x162 * x442
x466 = x0 * (4.0 * x426 + 2.0 * x427 + x441 + 2.0 * x458 + 2.0 * x465)
x467 = x106 * x462
x468 = x466 + x467
x469 = x139 * x233
x470 = x231 * x469
x471 = x241 * x99
x472 = x440 + x465
x473 = x106 * x472
x474 = x162 * x419
x475 = 2.0 * x474
x476 = x0 * (x230 + x433 + x475)
x477 = 3.0 * x461 + 2.0 * x476
x478 = x0 * (5.0 * x434 + 2.0 * x435 + 2.0 * x473 + x477)
x479 = x106 * x468
x480 = x478 + x479
x481 = x123 * x402
x482 = x481 * x99
x483 = x177 * x402
x484 = x130 * x416
x485 = x308 * x436
x486 = 0.333333333333333333 * x99
x487 = x208 * x486
x488 = x149 * x199
x489 = x177 * x377
x490 = x162 * x413
x491 = 2.0 * x0 * (2.0 * x411 + x414 + x490) + x162 * x456
x492 = x42 + x9
x493 = x11 * x59 + x4 * x492
x494 = x44 + x50
x495 = x0 * (3.0 * x20 + x401 + x493) + x4 * x494
x496 = x0 * (x430 + x432 + x456 + x475)
x497 = x162 * x459
x498 = x496 + x497
x499 = x169 * x494
x500 = x162 * x462
x501 = x466 + x500
x502 = x177 * x21
x503 = x308 * x498
x504 = x162 * x468
x505 = x478 + x504
x506 = x169 * x19
x507 = x19 * x308
x508 = x0 * (x239 + 5.0 * x440 + x443 + 3.0 * x465)
x509 = x162 * (x473 + x476)
x510 = x0 * (6.0 * x466 + 3.0 * x467 + 3.0 * x500 + 2.0 * x508 + 2.0 * x509)
x511 = x106 * x505 + x510
x512 = x107 * x511
x513 = x103 * x15
x514 = x100 * x107
x515 = x491 * x514
x516 = x308 * x494
x517 = x21 * x233
x518 = x231 * x517
x519 = x149 * x16
x520 = x265 * x486
x521 = x19 * x486
x522 = x169 * x377
x523 = x179 * x19
x524 = x0 * (x28 + 3.0 * x42) + x4 * x493
x525 = x411 + x490
x526 = (
x0 * (x452 * x525 + 3.0 * x454 + 3.0 * x455 + x59 * (x221 + x453)) + x162 * x491
)
x527 = (
x0
* (
x444
+ x452 * (x417 + x474)
+ 3.0 * x458
+ x491
+ x59 * (x226 + 2.0 * x381 + x424 + x525)
)
+ x162 * x498
)
x528 = x107 * x493
x529 = x100 * x526
x530 = x0 * (3.0 * x434 + x452 * x472 + x477 + 2.0 * x496 + 2.0 * x497) + x162 * x501
x531 = x492 * x99
x532 = x123 * x531
x533 = x107 * x4
x534 = x103 * x6
x535 = x534 * (x162 * x505 + x510)
x536 = x130 * x4
x537 = x11 * x149
x538 = x100 * x8
x539 = x169 * x493
x540 = x177 * x492
x541 = x4 * x6
x542 = x107 * x538
x543 = x177 * x493
x544 = x177 * x8
x545 = x341 * x8
x546 = x11 * x169
x547 = x107 * x8
x548 = x107 * x11
x549 = -x110 - R[2]
x550 = x122 * x549**2
x551 = x133 + x550
x552 = x100 * x551
x553 = x107 * x552
x554 = x122 * x549
x555 = x0 * (x148 + x554)
x556 = x148 * x549
x557 = x133 + x556
x558 = x549 * x557
x559 = x555 + x558
x560 = x100 * x559
x561 = x107 * x124
x562 = x130 * x560
x563 = x160 + x212 * x554
x564 = x0 * (x550 + x563)
x565 = x111 * x559
x566 = x564 + x565
x567 = x144 * x149
x568 = x111 * x557
x569 = 2.0 * x0 * (2.0 * x555 + x558 + x568) + x111 * x566
x570 = x107 * x153
x571 = x514 * x569
x572 = (
x0 * (x212 * (x555 + x568) + 3.0 * x564 + 3.0 * x565 + x59 * (x132 + x563))
+ x111 * x569
)
x573 = x164 * x169
x574 = x177 * x566
x575 = x100 * x572
x576 = x0 * (x199 + x554)
x577 = x199 * x549
x578 = x133 + x577
x579 = x549 * x578
x580 = x576 + x579
x581 = x100 * x580
x582 = x0 * (x160 + x200 + x556 + x577)
x583 = x197 * x557
x584 = x555 + x583
x585 = x549 * x584
x586 = x582 + x585
x587 = x124 * x169
x588 = x308 * x586
x589 = 2.0 * x583
x590 = 3.0 * x555 + x589
x591 = x0 * (x558 + x580 + x590)
x592 = x111 * x586
x593 = x591 + x592
x594 = 2.0 * x585
x595 = x111 * x584
x596 = 4.0 * x582
x597 = 2.0 * x595 + x596
x598 = x0 * (x566 + x594 + x597)
x599 = x111 * x593
x600 = x598 + x599
x601 = x0 * (x208 + x568 + x590)
x602 = 2.0 * x601
x603 = x582 + x595
x604 = x212 * x603
x605 = 3.0 * x591
x606 = x0 * (x569 + 3.0 * x592 + x602 + x604 + x605) + x111 * x600
x607 = x177 * x551
x608 = x130 * x581
x609 = x486 * x586
x610 = x308 * x600
x611 = x149 * x164
x612 = 2.0 * x197
x613 = x160 + x554 * x612
x614 = x0 * (x550 + x613)
x615 = x197 * x580
x616 = x614 + x615
x617 = x616 * x99
x618 = x123 * x617
x619 = x177 * x616
x620 = x197 * x586
x621 = x591 + x620
x622 = x197 * x593
x623 = x598 + x622
x624 = x197 * x603
x625 = x0 * (4.0 * x591 + 2.0 * x592 + x602 + 2.0 * x620 + 2.0 * x624)
x626 = x111 * x623
x627 = x625 + x626
x628 = x601 + x624
x629 = x111 * x628
x630 = x197 * x584
x631 = 2.0 * x630
x632 = x0 * (x271 + x597 + x631)
x633 = 3.0 * x622 + 2.0 * x632
x634 = x0 * (5.0 * x598 + 2.0 * x599 + 2.0 * x629 + x633)
x635 = x111 * x627
x636 = x634 + x635
x637 = x169 * x551
x638 = x16 * x169
x639 = x232 * x233
x640 = 3.14159265358979324 * x1 * x98
x641 = x100 * x640
x642 = x15 * x641
x643 = x197 * x578
x644 = 2.0 * x0 * (2.0 * x576 + x579 + x643) + x197 * x616
x645 = x0 * (x594 + x596 + x616 + x631)
x646 = x197 * x621
x647 = x645 + x646
x648 = x308 * x647
x649 = x197 * x623
x650 = x625 + x649
x651 = x197 * x627
x652 = x634 + x651
x653 = x514 * x644
x654 = x169 * x640 * x652
x655 = x0 * (x276 + 5.0 * x601 + x604 + 3.0 * x624)
x656 = x197 * (x629 + x632)
x657 = x0 * (6.0 * x625 + 3.0 * x626 + 3.0 * x649 + 2.0 * x655 + 2.0 * x656)
x658 = x111 * x652 + x657
x659 = x107 * x658
x660 = x169 * x8
x661 = x6 * x641
x662 = x576 + x643
x663 = (
x0 * (x59 * (x259 + x613) + x612 * x662 + 3.0 * x614 + 3.0 * x615) + x197 * x644
)
x664 = x100 * x663
x665 = (
x0
* (
x59 * (x265 + 2.0 * x555 + x589 + x662)
+ x605
+ x612 * (x582 + x630)
+ 3.0 * x620
+ x644
)
+ x197 * x647
)
x666 = x0 * (3.0 * x598 + x612 * x628 + x633 + 2.0 * x645 + 2.0 * x646) + x197 * x650
x667 = x661 * (x197 * x652 + x657)
# 675 item(s)
result[0] += x104 * (
x0
* (
x40 * (x61 + x62)
+ x59 * (3.0 * x36 + 3.0 * x37 + 6.0 * x49 + x58)
+ 3.0 * x89
+ 4.0 * x90
+ 7.0 * x93
)
+ x3 * x97
)
result[1] += x106 * x109
result[2] += x109 * x111
result[3] += x121 * x122 * x129
result[4] += x106 * x111 * x121 * x131
result[5] += x121 * x124 * x136
result[6] += x143 * x146 * x147
result[7] += x127 * x148 * x150
result[8] += x134 * x144 * x150
result[9] += x143 * x152 * x153
result[10] += x122 * x155 * x159
result[11] += x146 * x148 * x159
result[12] += x127 * x136 * x158
result[13] += x144 * x152 * x159
result[14] += x124 * x159 * x161
result[15] += x162 * x163
result[16] += x122 * x168 * x96
result[17] += x162 * x171 * x172
result[18] += x120 * x122 * x178
result[19] += x120 * x148 * x180
result[20] += x120 * x164 * x181
result[21] += x122 * x142 * x187
result[22] += x148 * x169 * x175 * x188
result[23] += x134 * x168 * x188
result[24] += x142 * x164 * x189
result[25] += x147 * x191 * x192
result[26] += x148 * x186 * x194
result[27] += x135 * x175 * x195
result[28] += x151 * x167 * x193
result[29] += x161 * x164 * x196
result[30] += x163 * x197
result[31] += x106 * x172 * x198
result[32] += x124 * x203 * x96
result[33] += x120 * x199 * x204
result[34] += x120 * x144 * x205
result[35] += x120 * x124 * x209
result[36] += x142 * x199 * x210
result[37] += x127 * x188 * x203
result[38] += x188 * x208 * x211
result[39] += x124 * x142 * x217
result[40] += x155 * x196 * x199
result[41] += x145 * x193 * x202
result[42] += x128 * x195 * x208
result[43] += x144 * x194 * x216
result[44] += x153 * x192 * x219
result[45] += x122 * x220 * x224
result[46] += x226 * x227 * x88
result[47] += x148 * x228 * x88
result[48] += x122 * x232 * x86
result[49] += x148 * x235 * x86
result[50] += x222 * x236 * x86
result[51] += x118 * x227 * x239
result[52] += x148 * x232 * x240
result[53] += x226 * x236 * x240
result[54] += x118 * x223 * x241
result[55] += x122 * x245 * x247
result[56] += x148 * x239 * x248
result[57] += x116 * x230 * x236
result[58] += x226 * x241 * x246
result[59] += x116 * x161 * x224
result[60] += x131 * x162 * x197 * x220
result[61] += x180 * x199 * x88
result[62] += x164 * x205 * x88
result[63] += x199 * x250 * x86
result[64] += x201 * x251 * x86
result[65] += x164 * x253 * x86
result[66] += x118 * x199 * x254
result[67] += x118 * x175 * x255
result[68] += x118 * x208 * x251
result[69] += x118 * x164 * x256
result[70] += x191 * x199 * x257
result[71] += x186 * x203 * x258
result[72] += x116 * x175 * x253
result[73] += x168 * x216 * x258
result[74] += x164 * x219 * x257
result[75] += x124 * x220 * x262
result[76] += x144 * x263 * x88
result[77] += x265 * x266 * x88
result[78] += x260 * x267 * x86
result[79] += x144 * x269 * x86
result[80] += x124 * x272 * x86
result[81] += x118 * x261 * x273
result[82] += x240 * x265 * x267
result[83] += x144 * x240 * x272
result[84] += x118 * x266 * x276
result[85] += x246 * x260 * x277
result[86] += x246 * x265 * x273
result[87] += x116 * x267 * x271
result[88] += x144 * x248 * x276
result[89] += x124 * x247 * x281
result[90] += x147 * x284 * x286
result[91] += x122 * x289 * x290
result[92] += x148 * x283 * x292
result[93] += x227 * x294 * x84
result[94] += x148 * x296 * x84
result[95] += x181 * x285 * x84
result[96] += x122 * x298 * x300
result[97] += x148 * x294 * x301
result[98] += x134 * x295 * x300
result[99] += x151 * x291 * x299
result[100] += x122 * x303 * x305
result[101] += x148 * x298 * x306
result[102] += x181 * x294 * x72
result[103] += x151 * x289 * x306
result[104] += x161 * x286 * x304
result[105] += x199 * x222 * x307
result[106] += x199 * x226 * x309
result[107] += x203 * x283 * x310
result[108] += x232 * x311 * x84
result[109] += x226 * x255 * x84
result[110] += x252 * x312 * x84
result[111] += x199 * x239 * x301
result[112] += x230 * x255 * x65
result[113] += x208 * x226 * x313
result[114] += x216 * x300 * x310
result[115] += x199 * x245 * x314
result[116] += x203 * x239 * x315
result[117] += x232 * x252 * x72
result[118] += x216 * x226 * x316
result[119] += x219 * x222 * x314
result[120] += x164 * x260 * x307
result[121] += x168 * x283 * x317
result[122] += x164 * x265 * x309
result[123] += x249 * x318 * x84
result[124] += x251 * x265 * x84
result[125] += x164 * x319 * x84
result[126] += x186 * x300 * x317
result[127] += x175 * x265 * x313
result[128] += x251 * x271 * x65
result[129] += x164 * x276 * x301
result[130] += x191 * x260 * x314
result[131] += x186 * x265 * x316
result[132] += x249 * x272 * x72
result[133] += x168 * x276 * x315
result[134] += x164 * x281 * x314
result[135] += x153 * x284 * x321
result[136] += x144 * x283 * x322
result[137] += x124 * x290 * x325
result[138] += x204 * x320 * x84
result[139] += x211 * x326 * x84
result[140] += x266 * x328 * x84
result[141] += x145 * x299 * x329
result[142] += x127 * x300 * x326
result[143] += x144 * x301 * x328
result[144] += x124 * x300 * x331
result[145] += x155 * x304 * x321
result[146] += x145 * x306 * x325
result[147] += x204 * x328 * x72
result[148] += x144 * x306 * x331
result[149] += x124 * x305 * x333
result[150] += x122 * x334 * x336
result[151] += x147 * x337 * x338
result[152] += x148 * x334 * x339
result[153] += x122 * x340 * x342
result[154] += x148 * x337 * x343
result[155] += x136 * x334 * x82
result[156] += x122 * x344 * x346
result[157] += x148 * x340 * x347
result[158] += x134 * x337 * x347
result[159] += x152 * x334 * x345
result[160] += x122 * x348 * x350
result[161] += x148 * x344 * x351
result[162] += x136 * x340 * x349
result[163] += x152 * x337 * x350
result[164] += x161 * x334 * x350
result[165] += x199 * x286 * x336
result[166] += x199 * x289 * x352
result[167] += x202 * x282 * x291
result[168] += x199 * x294 * x353
result[169] += x203 * x295 * x82
result[170] += x209 * x285 * x82
result[171] += x199 * x298 * x354
result[172] += x203 * x294 * x355
result[173] += x208 * x295 * x354
result[174] += x216 * x292 * x80
result[175] += x199 * x303 * x351
result[176] += x202 * x298 * x356
result[177] += x209 * x294 * x349
result[178] += x216 * x289 * x357
result[179] += x219 * x286 * x350
result[180] += x224 * x260 * x335
result[181] += x226 * x261 * x358
result[182] += x223 * x265 * x358
result[183] += x230 * x260 * x359
result[184] += x226 * x268 * x359
result[185] += x222 * x271 * x359
result[186] += x239 * x261 * x360
result[187] += x232 * x268 * x80
result[188] += x226 * x319 * x80
result[189] += x223 * x276 * x360
result[190] += x245 * x261 * x361
result[191] += x239 * x265 * x362
result[192] += x230 * x272 * x349
result[193] += x226 * x276 * x362
result[194] += x224 * x281 * x349
result[195] += x164 * x321 * x336
result[196] += x167 * x282 * x329
result[197] += x164 * x325 * x352
result[198] += x175 * x363 * x82
result[199] += x168 * x326 * x82
result[200] += x164 * x328 * x353
result[201] += x186 * x322 * x80
result[202] += x175 * x326 * x354
result[203] += x168 * x328 * x355
result[204] += x164 * x331 * x354
result[205] += x191 * x321 * x350
result[206] += x186 * x325 * x357
result[207] += x175 * x328 * x362
result[208] += x167 * x331 * x356
result[209] += x164 * x333 * x351
result[210] += x124 * x336 * x364
result[211] += x144 * x339 * x364
result[212] += x153 * x338 * x365
result[213] += x128 * x366 * x82
result[214] += x144 * x343 * x365
result[215] += x124 * x342 * x367
result[216] += x146 * x345 * x364
result[217] += x127 * x347 * x365
result[218] += x144 * x347 * x367
result[219] += x124 * x346 * x368
result[220] += x155 * x350 * x364
result[221] += x146 * x350 * x365
result[222] += x128 * x361 * x367
result[223] += x144 * x351 * x368
result[224] += x124 * x350 * x369
result[225] += x122 * x374 * x378
result[226] += x379 * x386 * x387
result[227] += x378 * x379 * x388
result[228] += x392 * x396 * x397
result[229] += x148 * x396 * x398
result[230] += x136 * x377 * x396
result[231] += x400 * x405 * x406
result[232] += x392 * x405 * x407
result[233] += x134 * x398 * x405
result[234] += x152 * x378 * x405
result[235] += x147 * x408 * x409
result[236] += x388 * x408 * x410
result[237] += x136 * x392 * x408
result[238] += x152 * x386 * x408
result[239] += x161 * x378 * x408
result[240] += x373 * x387 * x416
result[241] += x122 * x422 * x58
result[242] += x148 * x423 * x58
result[243] += x227 * x395 * x428
result[244] += x148 * x395 * x429
result[245] += x181 * x395 * x415
result[246] += x122 * x404 * x437
result[247] += x148 * x428 * x439
result[248] += x134 * x422 * x438
result[249] += x189 * x404 * x415
result[250] += x147 * x445 * x446
result[251] += x148 * x403 * x437
result[252] += x181 * x403 * x428
result[253] += x189 * x403 * x421
result[254] += x161 * x416 * x446
result[255] += x199 * x373 * x447
result[256] += x199 * x448 * x58
result[257] += x203 * x377 * x58
result[258] += x199 * x395 * x449
result[259] += x205 * x385 * x395
result[260] += x209 * x377 * x395
result[261] += x199 * x404 * x450
result[262] += x203 * x392 * x438
result[263] += x208 * x438 * x448
result[264] += x217 * x377 * x404
result[265] += x199 * x446 * x451
result[266] += x203 * x400 * x403
result[267] += x209 * x392 * x403
result[268] += x217 * x385 * x403
result[269] += x219 * x378 * x446
result[270] += x397 * x456 * x457
result[271] += x227 * x459 * x56
result[272] += x148 * x460 * x56
result[273] += x122 * x462 * x463
result[274] += x148 * x459 * x464
result[275] += x236 * x456 * x46
result[276] += x139 * x227 * x468
result[277] += x148 * x462 * x470
result[278] += x236 * x459 * x469
result[279] += x139 * x456 * x471
result[280] += x122 * x480 * x482
result[281] += x148 * x468 * x483
result[282] += x236 * x402 * x462
result[283] += x402 * x459 * x471
result[284] += x161 * x456 * x482
result[285] += x199 * x457 * x484
result[286] += x199 * x429 * x56
result[287] += x205 * x415 * x56
result[288] += x311 * x428 * x463
result[289] += x255 * x421 * x46
result[290] += x252 * x415 * x463
result[291] += x139 * x199 * x485
result[292] += x139 * x255 * x428
result[293] += x139 * x421 * x487
result[294] += x139 * x256 * x415
result[295] += x402 * x445 * x488
result[296] += x205 * x402 * x436
result[297] += x253 * x402 * x428
result[298] += x256 * x402 * x421
result[299] += x219 * x402 * x484
result[300] += x262 * x377 * x457
result[301] += x263 * x385 * x56
result[302] += x265 * x489 * x56
result[303] += x318 * x392 * x46
result[304] += x268 * x385 * x463
result[305] += x272 * x377 * x46
result[306] += x139 * x263 * x400
result[307] += x139 * x269 * x392
result[308] += x139 * x319 * x385
result[309] += x139 * x276 * x489
result[310] += x261 * x409 * x481
result[311] += x265 * x400 * x483
result[312] += x272 * x392 * x402
result[313] += x276 * x385 * x483
result[314] += x281 * x377 * x482
result[315] += x406 * x491 * x495
result[316] += x122 * x498 * x499
result[317] += x148 * x491 * x499
result[318] += x122 * x501 * x502
result[319] += x148 * x21 * x503
result[320] += x181 * x21 * x491
result[321] += x122 * x505 * x506
result[322] += x148 * x501 * x507
result[323] += x134 * x498 * x507
result[324] += x189 * x19 * x491
result[325] += x512 * x513
result[326] += x15 * x171 * x505
result[327] += x16 * x181 * x501
result[328] += x16 * x189 * x498
result[329] += x16 * x161 * x515
result[330] += x456 * x488 * x495
result[331] += x199 * x459 * x516
result[332] += x205 * x456 * x494
result[333] += x199 * x462 * x518
result[334] += x21 * x255 * x459
result[335] += x21 * x253 * x456
result[336] += x199 * x468 * x507
result[337] += x19 * x255 * x462
result[338] += x19 * x459 * x487
result[339] += x19 * x256 * x456
result[340] += x130 * x197 * x480 * x513
result[341] += x16 * x205 * x468
result[342] += x16 * x253 * x462
result[343] += x16 * x256 * x459
result[344] += x219 * x456 * x519
result[345] += x260 * x484 * x495
result[346] += x317 * x422 * x494
result[347] += x265 * x415 * x516
result[348] += x318 * x428 * x517
result[349] += x21 * x421 * x520
result[350] += x21 * x319 * x415
result[351] += x317 * x436 * x506
result[352] += x19 * x428 * x520
result[353] += x271 * x421 * x521
result[354] += x276 * x415 * x507
result[355] += x260 * x445 * x519
result[356] += x16 * x265 * x485
result[357] += x16 * x319 * x428
result[358] += x16 * x276 * x429
result[359] += x16 * x281 * x484
result[360] += x321 * x378 * x495
result[361] += x322 * x385 * x494
result[362] += x325 * x494 * x522
result[363] += x21 * x363 * x392
result[364] += x21 * x326 * x448
result[365] += x21 * x328 * x489
result[366] += x19 * x322 * x400
result[367] += x326 * x392 * x506
result[368] += x328 * x448 * x523
result[369] += x19 * x331 * x522
result[370] += x16 * x321 * x451
result[371] += x16 * x325 * x450
result[372] += x16 * x328 * x449
result[373] += x16 * x331 * x448
result[374] += x16 * x333 * x447
result[375] += x147 * x524 * x526
result[376] += x147 * x527 * x528
result[377] += x148 * x528 * x529
result[378] += x122 * x530 * x532
result[379] += x407 * x492 * x527
result[380] += x136 * x492 * x526
result[381] += x533 * x535
result[382] += x111 * x530 * x534 * x536
result[383] += x134 * x527 * x537
result[384] += x11 * x152 * x529
result[385] += x534 * (
x0
* (
x182 * (x508 + x509)
+ 7.0 * x478
+ 3.0 * x479
+ 4.0 * x504
+ x59 * (3.0 * x162 * x472 + x298 + 3.0 * x473 + 6.0 * x476)
)
+ x162 * x511
)
result[386] += x107 * x111 * x535
result[387] += x136 * x530 * x8
result[388] += x152 * x527 * x538
result[389] += x161 * x526 * x538
result[390] += x199 * x515 * x524
result[391] += x199 * x498 * x539
result[392] += x203 * x491 * x493
result[393] += x199 * x501 * x540
result[394] += x205 * x492 * x498
result[395] += x209 * x491 * x492
result[396] += x198 * x505 * x541
result[397] += x11 * x205 * x501
result[398] += x11 * x208 * x503
result[399] += x11 * x217 * x491
result[400] += x197 * x512 * x534
result[401] += x203 * x505 * x8
result[402] += x209 * x501 * x8
result[403] += x217 * x498 * x8
result[404] += x219 * x491 * x542
result[405] += x262 * x456 * x524
result[406] += x263 * x459 * x493
result[407] += x265 * x456 * x543
result[408] += x318 * x462 * x492
result[409] += x269 * x459 * x492
result[410] += x272 * x456 * x492
result[411] += x11 * x263 * x468
result[412] += x11 * x269 * x462
result[413] += x11 * x319 * x459
result[414] += x11 * x276 * x460
result[415] += x262 * x480 * x8
result[416] += x265 * x468 * x544
result[417] += x272 * x462 * x8
result[418] += x276 * x459 * x544
result[419] += x281 * x456 * x545
result[420] += x321 * x416 * x524
result[421] += x322 * x421 * x493
result[422] += x325 * x415 * x539
result[423] += x363 * x428 * x492
result[424] += x326 * x422 * x492
result[425] += x328 * x415 * x540
result[426] += x11 * x322 * x436
result[427] += x326 * x428 * x546
result[428] += x11 * x328 * x429
result[429] += x11 * x331 * x423
result[430] += x321 * x445 * x538
result[431] += x325 * x437 * x8
result[432] += x328 * x428 * x544
result[433] += x331 * x422 * x8
result[434] += x333 * x416 * x547
result[435] += x364 * x378 * x524
result[436] += x364 * x386 * x528
result[437] += x365 * x378 * x528
result[438] += x366 * x392 * x531
result[439] += x365 * x398 * x492
result[440] += x367 * x377 * x532
result[441] += x364 * x410 * x548
result[442] += x365 * x392 * x537
result[443] += x11 * x367 * x398
result[444] += x11 * x368 * x447
result[445] += x364 * x409 * x538
result[446] += x365 * x400 * x542
result[447] += x367 * x392 * x545
result[448] += x368 * x386 * x547
result[449] += x369 * x378 * x8
result[450] += x124 * x374 * x552
result[451] += x144 * x379 * x553
result[452] += x379 * x560 * x561
result[453] += x129 * x396 * x551
result[454] += x144 * x396 * x562
result[455] += x124 * x341 * x396 * x566
result[456] += x146 * x405 * x552
result[457] += x127 * x405 * x562
result[458] += x405 * x566 * x567
result[459] += x405 * x569 * x570
result[460] += x155 * x408 * x552
result[461] += x146 * x408 * x560
result[462] += x129 * x408 * x566
result[463] += x144 * x408 * x571
result[464] += x153 * x408 * x572
result[465] += x164 * x373 * x553
result[466] += x168 * x551 * x58
result[467] += x559 * x573 * x58
result[468] += x178 * x395 * x551
result[469] += x180 * x395 * x559
result[470] += x164 * x395 * x574
result[471] += x187 * x404 * x551
result[472] += x175 * x439 * x559
result[473] += x168 * x438 * x566
result[474] += x404 * x569 * x573
result[475] += x191 * x446 * x552
result[476] += x187 * x403 * x559
result[477] += x178 * x403 * x566
result[478] += x168 * x403 * x569
result[479] += x164 * x446 * x575
result[480] += x373 * x561 * x581
result[481] += x211 * x58 * x580
result[482] += x58 * x586 * x587
result[483] += x204 * x395 * x580
result[484] += x144 * x395 * x588
result[485] += x266 * x395 * x593
result[486] += x210 * x404 * x580
result[487] += x127 * x439 * x586
result[488] += x144 * x439 * x593
result[489] += x404 * x587 * x600
result[490] += x155 * x446 * x581
result[491] += x210 * x403 * x586
result[492] += x204 * x403 * x593
result[493] += x211 * x403 * x600
result[494] += x153 * x446 * x606
result[495] += x224 * x457 * x551
result[496] += x226 * x56 * x607
result[497] += x228 * x559 * x56
result[498] += x230 * x463 * x551
result[499] += x234 * x463 * x559
result[500] += x222 * x463 * x566
result[501] += x139 * x239 * x607
result[502] += x232 * x469 * x559
result[503] += x226 * x470 * x566
result[504] += x139 * x228 * x569
result[505] += x245 * x482 * x551
result[506] += x239 * x483 * x559
result[507] += x232 * x402 * x566
result[508] += x226 * x483 * x569
result[509] += x224 * x402 * x572
result[510] += x164 * x457 * x608
result[511] += x180 * x56 * x580
result[512] += x164 * x56 * x588
result[513] += x249 * x463 * x580
result[514] += x251 * x46 * x586
result[515] += x164 * x464 * x593
result[516] += x139 * x254 * x580
result[517] += x139 * x175 * x609
result[518] += x139 * x251 * x593
result[519] += x139 * x164 * x610
result[520] += x191 * x402 * x608
result[521] += x254 * x402 * x586
result[522] += x250 * x402 * x593
result[523] += x180 * x402 * x600
result[524] += x402 * x606 * x611
result[525] += x124 * x457 * x618
result[526] += x144 * x56 * x619
result[527] += x266 * x56 * x621
result[528] += x267 * x46 * x616
result[529] += x144 * x464 * x621
result[530] += x124 * x463 * x623
result[531] += x139 * x273 * x617
result[532] += x267 * x469 * x621
result[533] += x144 * x470 * x623
result[534] += x139 * x266 * x627
result[535] += x277 * x402 * x617
result[536] += x273 * x402 * x621 * x99
result[537] += x267 * x402 * x623
result[538] += x144 * x483 * x627
result[539] += x124 * x482 * x636
result[540] += x286 * x495 * x552
result[541] += x289 * x494 * x637
result[542] += x292 * x494 * x559
result[543] += x21 * x294 * x607
result[544] += x21 * x296 * x559
result[545] += x285 * x502 * x566
result[546] += x19 * x298 * x637
result[547] += x294 * x507 * x559
result[548] += x295 * x506 * x566
result[549] += x19 * x292 * x569
result[550] += x16 * x303 * x553
result[551] += x298 * x559 * x638
result[552] += x16 * x294 * x574
result[553] += x289 * x569 * x638
result[554] += x16 * x286 * x575
result[555] += x222 * x495 * x608
result[556] += x226 * x516 * x580
result[557] += x310 * x499 * x586
result[558] += x232 * x517 * x580
result[559] += x21 * x226 * x609
result[560] += x312 * x517 * x593
result[561] += x239 * x507 * x580
result[562] += x230 * x521 * x586
result[563] += x226 * x521 * x593
result[564] += x310 * x506 * x600
result[565] += x16 * x245 * x608
result[566] += x16 * x239 * x588
result[567] += x16 * x593 * x639
result[568] += x16 * x226 * x610
result[569] += x222 * x519 * x606
result[570] += x495 * x611 * x616
result[571] += x180 * x494 * x616
result[572] += x164 * x516 * x621
result[573] += x21 * x250 * x616
result[574] += x21 * x251 * x621
result[575] += x164 * x518 * x623
result[576] += x187 * x523 * x616
result[577] += x175 * x521 * x621
result[578] += x19 * x251 * x623
result[579] += x164 * x507 * x627
result[580] += x191 * x519 * x616
result[581] += x16 * x254 * x621
result[582] += x16 * x250 * x623
result[583] += x16 * x180 * x627
result[584] += x130 * x162 * x636 * x642
result[585] += x495 * x570 * x644
result[586] += x144 * x499 * x644
result[587] += x124 * x499 * x647
result[588] += x204 * x21 * x644
result[589] += x144 * x21 * x648
result[590] += x124 * x502 * x650
result[591] += x19 * x210 * x644
result[592] += x127 * x507 * x647
result[593] += x144 * x507 * x650
result[594] += x124 * x506 * x652
result[595] += x155 * x16 * x653
result[596] += x16 * x210 * x647
result[597] += x16 * x204 * x650
result[598] += x106 * x15 * x654
result[599] += x642 * x659
result[600] += x334 * x524 * x552
result[601] += x337 * x528 * x552
result[602] += x334 * x528 * x560
result[603] += x340 * x532 * x551
result[604] += x337 * x492 * x562
result[605] += x334 * x532 * x566
result[606] += x344 * x548 * x552
result[607] += x11 * x340 * x562
result[608] += x337 * x537 * x566
result[609] += x11 * x334 * x571
result[610] += x348 * x552 * x8
result[611] += x344 * x547 * x560
result[612] += x340 * x545 * x566
result[613] += x337 * x542 * x569
result[614] += x334 * x538 * x572
result[615] += x286 * x524 * x581
result[616] += x289 * x539 * x580
result[617] += x292 * x493 * x586
result[618] += x294 * x540 * x580
result[619] += x296 * x492 * x586
result[620] += x285 * x540 * x593
result[621] += x298 * x546 * x580
result[622] += x11 * x294 * x588
result[623] += x11 * x296 * x593
result[624] += x11 * x292 * x600
result[625] += x303 * x547 * x581
result[626] += x298 * x586 * x660
result[627] += x294 * x544 * x593
result[628] += x289 * x600 * x660
result[629] += x286 * x538 * x606
result[630] += x224 * x524 * x616
result[631] += x226 * x543 * x616
result[632] += x228 * x493 * x621
result[633] += x232 * x492 * x616
result[634] += x235 * x492 * x621
result[635] += x312 * x492 * x623
result[636] += x11 * x239 * x619
result[637] += x11 * x621 * x639
result[638] += x11 * x235 * x623
result[639] += x11 * x228 * x627
result[640] += x245 * x618 * x8
result[641] += x239 * x544 * x621
result[642] += x232 * x623 * x8
result[643] += x226 * x544 * x627
result[644] += x224 * x636 * x8
result[645] += x164 * x524 * x653
result[646] += x168 * x493 * x644
result[647] += x164 * x539 * x647
result[648] += x175 * x540 * x644
result[649] += x180 * x492 * x647
result[650] += x164 * x540 * x650
result[651] += x11 * x187 * x644
result[652] += x11 * x175 * x648
result[653] += x11 * x180 * x650
result[654] += x162 * x541 * x654
result[655] += x191 * x542 * x644
result[656] += x187 * x647 * x8
result[657] += x178 * x650 * x8
result[658] += x168 * x652 * x8
result[659] += x162 * x659 * x661
result[660] += x153 * x524 * x663
result[661] += x144 * x528 * x664
result[662] += x153 * x528 * x665
result[663] += x129 * x492 * x663
result[664] += x492 * x567 * x665
result[665] += x124 * x532 * x666
result[666] += x11 * x146 * x664
result[667] += x127 * x537 * x665
result[668] += x106 * x536 * x661 * x666
result[669] += x533 * x667
result[670] += x155 * x538 * x663
result[671] += x146 * x538 * x665
result[672] += x129 * x666 * x8
result[673] += x106 * x107 * x667
result[674] += x661 * (
x0
* (
x212 * (x655 + x656)
+ x59 * (3.0 * x197 * x628 + x331 + 3.0 * x629 + 6.0 * x632)
+ 7.0 * x634
+ 3.0 * x635
+ 4.0 * x651
)
+ x197 * x658
)
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)] = diag_quadrupole3d_00
func_dict[(1, 0)] = diag_quadrupole3d_10
func_dict[(0, 1)] = diag_quadrupole3d_01
func_dict[(2, 0)] = diag_quadrupole3d_20
func_dict[(0, 2)] = diag_quadrupole3d_02
func_dict[(3, 0)] = diag_quadrupole3d_30
func_dict[(0, 3)] = diag_quadrupole3d_03
func_dict[(4, 0)] = diag_quadrupole3d_40
func_dict[(0, 4)] = diag_quadrupole3d_04
func_dict[(1, 1)] = diag_quadrupole3d_11
func_dict[(2, 1)] = diag_quadrupole3d_21
func_dict[(1, 2)] = diag_quadrupole3d_12
func_dict[(3, 1)] = diag_quadrupole3d_31
func_dict[(1, 3)] = diag_quadrupole3d_13
func_dict[(4, 1)] = diag_quadrupole3d_41
func_dict[(1, 4)] = diag_quadrupole3d_14
func_dict[(2, 2)] = diag_quadrupole3d_22
func_dict[(3, 2)] = diag_quadrupole3d_32
func_dict[(2, 3)] = diag_quadrupole3d_23
func_dict[(4, 2)] = diag_quadrupole3d_42
func_dict[(2, 4)] = diag_quadrupole3d_24
func_dict[(3, 3)] = diag_quadrupole3d_33
func_dict[(4, 3)] = diag_quadrupole3d_43
func_dict[(3, 4)] = diag_quadrupole3d_34
func_dict[(4, 4)] = diag_quadrupole3d_44
return func_dict