"""
Molecular integrals over Gaussian basis functions generated by sympleints.
See https://github.com/eljost/sympleints for more information.
sympleints version: 0.1.dev79+g63f1ef8.d20230515
symppy version: 1.10.1
sympleints was executed with the following arguments:
lmax = 4
lauxmax = 6
write = False
out_dir = devel_ints
keys = ['~2c2e', '~3c2e_sph']
sph = False
opt_basic = True
normalize = cgto
"""
import numpy
[docs]
def kinetic3d_00(ax, da, A, bx, db, B):
"""Cartesian 3D (ss) kinetic energy integral.
Generated code; DO NOT modify by hand!"""
result = numpy.zeros((1, 1), dtype=float)
x0 = (ax + bx) ** (-1.0)
x1 = ax * x0
x2 = bx * x1
# 1 item(s)
result[0, 0] = numpy.sum(
-5.568327996831708
* da
* db
* numpy.sqrt(x0)
* x1
* (
ax * (x0 + 2.0 * (-x0 * (ax * A[0] + bx * B[0]) + A[0]) ** 2)
+ ax * (x0 + 2.0 * (-x0 * (ax * A[1] + bx * B[1]) + A[1]) ** 2)
+ ax * (x0 + 2.0 * (-x0 * (ax * A[2] + bx * B[2]) + A[2]) ** 2)
- 3.0
)
* numpy.exp(-x2 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2))
)
return result
[docs]
def kinetic3d_01(ax, da, A, bx, db, B):
"""Cartesian 3D (sp) kinetic energy integral.
Generated code; DO NOT modify by hand!"""
result = numpy.zeros((1, 3), dtype=float)
x0 = (ax + bx) ** (-1.0)
x1 = -x0 * (ax * A[0] + bx * B[0])
x2 = -x0 * (ax * A[1] + bx * B[1])
x3 = x2 + A[1]
x4 = ax * (x0 + 2.0 * x3**2)
x5 = x1 + A[0]
x6 = -x0 * (ax * A[2] + bx * B[2])
x7 = x6 + A[2]
x8 = bx * x0
x9 = -2.0 * x8
x10 = ax * (x0 + 2.0 * x7**2) + x9 - 3.0
x11 = ax * x8
x12 = (
5.568327996831708
* ax
* da
* db
* x0**1.5
* numpy.exp(-x11 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2))
)
x13 = ax * (x0 + 2.0 * x5**2)
# 3 item(s)
result[0, 0] = numpy.sum(x12 * (x1 + B[0]) * (ax * (x0 + 2.0 * x5**2) + x10 + x4))
result[0, 1] = numpy.sum(x12 * (x2 + B[1]) * (ax * (x0 + 2.0 * x3**2) + x10 + x13))
result[0, 2] = numpy.sum(
x12 * (x6 + B[2]) * (ax * (x0 + 2.0 * x7**2) + x13 + x4 + x9 - 3.0)
)
return result
[docs]
def kinetic3d_02(ax, da, A, bx, db, B):
"""Cartesian 3D (sd) kinetic energy integral.
Generated code; DO NOT modify by hand!"""
result = numpy.zeros((1, 6), dtype=float)
x0 = (ax + bx) ** (-1.0)
x1 = -x0 * (ax * A[0] + bx * B[0])
x2 = x1 + B[0]
x3 = x2**2
x4 = x0 + 2.0 * (x1 + A[0]) ** 2
x5 = bx * x0
x6 = 2.0 * x5 + 1.0
x7 = ax * x4
x8 = x7 - 1.0
x9 = 0.5 * x0
x10 = -x0 * (ax * A[1] + bx * B[1])
x11 = x0 + 2.0 * (x10 + A[1]) ** 2
x12 = ax * x11
x13 = x12 - 1.0
x14 = x0 + 2.0 * x3
x15 = 0.5 * x14
x16 = -x0 * (ax * A[2] + bx * B[2])
x17 = x0 + 2.0 * (x16 + A[2]) ** 2
x18 = ax * x17
x19 = x18 - 1.0
x20 = ax * x5
x21 = (
5.568327996831708
* ax
* da
* db
* x0**1.5
* numpy.exp(-x20 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2))
)
x22 = 0.5773502691896258 * x21
x23 = x10 + B[1]
x24 = x12 + x18 - 4.0 * x5 + x7 - 3.0
x25 = x2 * x21 * x24
x26 = x16 + B[2]
x27 = x23**2
x28 = x0 + 2.0 * x27
x29 = 0.5 * x28
x30 = x26**2
x31 = x0 + 2.0 * x30
x32 = 0.5 * x31
# 6 item(s)
result[0, 0] = numpy.sum(
-x22
* (-x0 * (bx * x14 - 1.0) + x13 * x15 + x15 * x19 + x3 * (ax * x4 - x6) + x8 * x9)
)
result[0, 1] = numpy.sum(-x23 * x25)
result[0, 2] = numpy.sum(-x25 * x26)
result[0, 3] = numpy.sum(
-x22
* (
-x0 * (bx * x28 - 1.0)
+ x13 * x9
+ x19 * x29
+ x27 * (ax * x11 - x6)
+ x29 * x8
)
)
result[0, 4] = numpy.sum(-x21 * x23 * x24 * x26)
result[0, 5] = numpy.sum(
-x22
* (
-x0 * (bx * x31 - 1.0)
+ x13 * x32
+ x19 * x9
+ x30 * (ax * x17 - x6)
+ x32 * x8
)
)
return result
[docs]
def kinetic3d_03(ax, da, A, bx, db, B):
"""Cartesian 3D (sf) kinetic energy integral.
Generated code; DO NOT modify by hand!"""
result = numpy.zeros((1, 10), dtype=float)
x0 = (ax + bx) ** (-1.0)
x1 = -x0 * (ax * A[0] + bx * B[0])
x2 = x1 + B[0]
x3 = x2**2
x4 = x1 + A[0]
x5 = ax * (x0 + 2.0 * x4**2)
x6 = bx * x0
x7 = 2.0 * x6 + 1.0
x8 = -x5 + x7
x9 = -x8
x10 = x3 * x9
x11 = 2.0 * x3
x12 = 3.0 * x0
x13 = x11 + x12
x14 = x5 - 1.0
x15 = x0 * x14
x16 = -x0 * (ax * A[1] + bx * B[1])
x17 = x16 + A[1]
x18 = ax * (x0 + 2.0 * x17**2)
x19 = x18 - 1.0
x20 = 0.5 * x13
x21 = -x0 * (ax * A[2] + bx * B[2])
x22 = x21 + A[2]
x23 = ax * (x0 + 2.0 * x22**2)
x24 = x23 - 1.0
x25 = x0 + x11
x26 = x0 * (bx * x25 - 1.0)
x27 = x0 * x2
x28 = ax * x6
x29 = (
5.568327996831708
* ax
* da
* db
* numpy.sqrt(x0)
* numpy.exp(-x28 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2))
)
x30 = 0.2581988897471611
x31 = x29 * x30
x32 = x0 * (2.0 * x10 + x15 - 2.0 * x26)
x33 = ax * (x0 + 2.0 * x22**2) - 1.0
x34 = x0 * x25
x35 = -x18 + x7
x36 = x16 + B[1]
x37 = x29 * x36
x38 = 0.2886751345948129
x39 = x37 * x38
x40 = ax * (x0 + 2.0 * x17**2) - 1.0
x41 = -x23 + x7
x42 = x21 + B[2]
x43 = x29 * x38
x44 = x42 * x43
x45 = x0 * x19
x46 = x36**2
x47 = 2.0 * x46
x48 = x0 + x47
x49 = x0 * (bx * x48 - 1.0)
x50 = -x35
x51 = x0 * (x45 + x47 * x50 - 2.0 * x49)
x52 = x0 * x48
x53 = x2 * x43
x54 = x0 * x24
x55 = x42**2
x56 = 2.0 * x55
x57 = x0 + x56
x58 = x0 * (bx * x57 - 1.0)
x59 = -x41
x60 = x0 * (x54 + x56 * x59 - 2.0 * x58)
x61 = x0 * x57
x62 = x12 + x47
x63 = 0.5 * x62
x64 = ax * (x0 + 2.0 * x4**2) - 1.0
x65 = x12 + x56
x66 = 0.5 * x65
# 10 item(s)
result[0, 0] = numpy.sum(
0.5
* x27
* x31
* (
2.0 * x0 * x9
- 2.0 * x0 * (bx * x13 - 2.0)
+ 2.0 * x10
+ x15
+ 2.0 * x19 * x20
+ 2.0 * x20 * x24
- 2.0 * x26
)
)
result[0, 1] = numpy.sum(x39 * (x32 + x33 * x34 - x34 * x35))
result[0, 2] = numpy.sum(x44 * (x32 + x34 * x40 - x34 * x41))
result[0, 3] = numpy.sum(x53 * (x33 * x52 + x51 - x52 * x8))
result[0, 4] = numpy.sum(x27 * x37 * x42 * (-6.0 * bx * x0 + x18 + x23 + x5 - 3.0))
result[0, 5] = numpy.sum(x53 * (x40 * x61 + x60 - x61 * x8))
result[0, 6] = numpy.sum(
0.5
* x0
* x30
* x37
* (
2.0 * x0 * x50
- 2.0 * x0 * (bx * x62 - 2.0)
+ 2.0 * x14 * x63
+ 2.0 * x24 * x63
+ x45
+ 2.0 * x46 * x50
- 2.0 * x49
)
)
result[0, 7] = numpy.sum(x44 * (-x41 * x52 + x51 + x52 * x64))
result[0, 8] = numpy.sum(x39 * (-x35 * x61 + x60 + x61 * x64))
result[0, 9] = numpy.sum(
0.5
* x0
* x31
* x42
* (
2.0 * x0 * x59
- 2.0 * x0 * (bx * x65 - 2.0)
+ 2.0 * x14 * x66
+ 2.0 * x19 * x66
+ x54
+ 2.0 * x55 * x59
- 2.0 * x58
)
)
return result
[docs]
def kinetic3d_04(ax, da, A, bx, db, B):
"""Cartesian 3D (sg) kinetic energy integral.
Generated code; DO NOT modify by hand!"""
result = numpy.zeros((1, 15), dtype=float)
x0 = 2.0 * ax
x1 = 2.0 * bx
x2 = (x0 + x1) ** (-1.0)
x3 = (ax + bx) ** (-1.0)
x4 = -x3 * (ax * A[0] + bx * B[0])
x5 = -x4 - B[0]
x6 = -ax
x7 = 2.0 * ax**2
x8 = -x6 - x7 * (x2 + (x4 + A[0]) ** 2)
x9 = ax * x3
x10 = bx * x9
x11 = numpy.exp(-x10 * (A[0] - B[0]) ** 2)
x12 = 1.772453850905516 * numpy.sqrt(x3)
x13 = x11 * x12
x14 = x13 * x5
x15 = x14 * x8
x16 = bx * x0 * x3
x17 = x14 * x16 + x15
x18 = x17 * x5
x19 = x13 * x5**2
x20 = x13 * x2
x21 = x19 + x20
x22 = x9 * (x1 * x21 - x13)
x23 = x20 * x8
x24 = 4.0 * x10
x25 = x18 + x22 + x23
x26 = x5 * (2.0 * x20 + x21)
x27 = x2 * (x14 * x24 + 2.0 * x15) + x25 * x5 + x9 * (x1 * x26 - 2.0 * x14)
x28 = 3.0 * x19 + 3.0 * x20
x29 = x2 * x28 + x26 * x5
x30 = numpy.exp(-x10 * (A[1] - B[1]) ** 2)
x31 = numpy.exp(-x10 * (A[2] - B[2]) ** 2)
x32 = 3.141592653589793 * x3 * x31
x33 = x30 * x32
x34 = -x3 * (ax * A[1] + bx * B[1])
x35 = -x6 - x7 * (x2 + (x34 + A[1]) ** 2)
x36 = x29 * x33
x37 = -x3 * (ax * A[2] + bx * B[2])
x38 = -x6 - x7 * (x2 + (x37 + A[2]) ** 2)
x39 = da * db
x40 = 0.09759000729485332 * x39
x41 = -x34 - B[1]
x42 = x12 * x30
x43 = x41 * x42
x44 = x35 * x43
x45 = x16 * x43 + x44
x46 = x12 * x31
x47 = x45 * x46
x48 = x27 * x33
x49 = x26 * x33
x50 = 0.2581988897471611 * x39
x51 = -x37 - B[2]
x52 = x46 * x51
x53 = x38 * x52
x54 = x16 * x52 + x53
x55 = x41 * x45
x56 = x41**2 * x42
x57 = x2 * x42
x58 = x56 + x57
x59 = x9 * (x1 * x58 - x42)
x60 = x35 * x57
x61 = x55 + x59 + x60
x62 = x21 * x46
x63 = 0.3333333333333333 * x39
x64 = 1.732050807568877 * x63
x65 = x51 * x54
x66 = x46 * x51**2
x67 = x2 * x46
x68 = x66 + x67
x69 = x9 * (x1 * x68 - x46)
x70 = x38 * x67
x71 = x65 + x69 + x70
x72 = x21 * x42
x73 = x41 * (2.0 * x57 + x58)
x74 = x2 * (x24 * x43 + 2.0 * x44) + x41 * x61 + x9 * (x1 * x73 - 2.0 * x43)
x75 = x11 * x32
x76 = x74 * x75
x77 = x5 * x75
x78 = 3.141592653589793 * x11 * x3 * x30
x79 = x5 * x78
x80 = x51 * (2.0 * x67 + x68)
x81 = x2 * (x24 * x52 + 2.0 * x53) + x51 * x71 + x9 * (x1 * x80 - 2.0 * x52)
x82 = x78 * x81
x83 = 3.0 * x56 + 3.0 * x57
x84 = x2 * x83 + x41 * x73
x85 = x75 * x84
x86 = x13 * x58
x87 = 3.0 * x66 + 3.0 * x67
x88 = x2 * x87 + x51 * x80
x89 = x78 * x88
# 15 item(s)
result[0, 0] = numpy.sum(
x40
* (
x33 * (3.0 * x2 * (x18 + x22 + x23) + x27 * x5 + x9 * (2.0 * bx * x29 - x28))
+ x35 * x36
+ x36 * x38
)
)
result[0, 1] = numpy.sum(x50 * (x26 * x47 + x38 * x41 * x49 + x41 * x48))
result[0, 2] = numpy.sum(x50 * (x26 * x42 * x54 + x35 * x49 * x51 + x48 * x51))
result[0, 3] = numpy.sum(x63 * (x25 * x46 * x58 + x38 * x58 * x62 + x61 * x62))
result[0, 4] = numpy.sum(
x64 * (x21 * x43 * x54 + x21 * x47 * x51 + x25 * x33 * x41 * x51)
)
result[0, 5] = numpy.sum(x63 * (x25 * x42 * x68 + x35 * x68 * x72 + x71 * x72))
result[0, 6] = numpy.sum(x50 * (x17 * x46 * x73 + x38 * x73 * x77 + x5 * x76))
result[0, 7] = numpy.sum(x64 * (x14 * x54 * x58 + x17 * x52 * x58 + x51 * x61 * x77))
result[0, 8] = numpy.sum(x64 * (x14 * x45 * x68 + x17 * x43 * x68 + x41 * x71 * x79))
result[0, 9] = numpy.sum(x50 * (x17 * x42 * x80 + x35 * x79 * x80 + x5 * x82))
result[0, 10] = numpy.sum(
x40
* (
x38 * x85
+ x75
* (3.0 * x2 * (x55 + x59 + x60) + x41 * x74 + x9 * (2.0 * bx * x84 - x83))
+ x8 * x85
)
)
result[0, 11] = numpy.sum(x50 * (x13 * x54 * x73 + x51 * x73 * x75 * x8 + x51 * x76))
result[0, 12] = numpy.sum(x63 * (x13 * x61 * x68 + x68 * x8 * x86 + x71 * x86))
result[0, 13] = numpy.sum(x50 * (x13 * x45 * x80 + x41 * x78 * x8 * x80 + x41 * x82))
result[0, 14] = numpy.sum(
x40
* (
x35 * x89
+ x78
* (3.0 * x2 * (x65 + x69 + x70) + x51 * x81 + x9 * (2.0 * bx * x88 - x87))
+ x8 * x89
)
)
return result
[docs]
def kinetic3d_10(ax, da, A, bx, db, B):
"""Cartesian 3D (ps) kinetic energy integral.
Generated code; DO NOT modify by hand!"""
result = numpy.zeros((3, 1), dtype=float)
x0 = (ax + bx) ** (-1.0)
x1 = -x0 * (ax * A[0] + bx * B[0]) + A[0]
x2 = -x0 * (ax * A[1] + bx * B[1]) + A[1]
x3 = ax * (x0 + 2.0 * x2**2)
x4 = -x0 * (ax * A[2] + bx * B[2]) + A[2]
x5 = bx * x0
x6 = -2.0 * x5
x7 = ax * (x0 + 2.0 * x4**2) + x6 - 3.0
x8 = ax * x5
x9 = (
5.568327996831708
* ax
* da
* db
* x0**1.5
* numpy.exp(-x8 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2))
)
x10 = ax * (x0 + 2.0 * x1**2)
# 3 item(s)
result[0, 0] = numpy.sum(x1 * x9 * (ax * (x0 + 2.0 * x1**2) + x3 + x7))
result[1, 0] = numpy.sum(x2 * x9 * (ax * (x0 + 2.0 * x2**2) + x10 + x7))
result[2, 0] = numpy.sum(x4 * x9 * (ax * (x0 + 2.0 * x4**2) + x10 + x3 + x6 - 3.0))
return result
[docs]
def kinetic3d_11(ax, da, A, bx, db, B):
"""Cartesian 3D (pp) kinetic energy integral.
Generated code; DO NOT modify by hand!"""
result = numpy.zeros((3, 3), dtype=float)
x0 = (ax + bx) ** (-1.0)
x1 = -x0 * (ax * A[0] + bx * B[0])
x2 = x1 + A[0]
x3 = x0 + 2.0 * x2**2
x4 = ax * x3
x5 = x4 - 1.0
x6 = 0.5 * x0
x7 = -x0 * (ax * A[1] + bx * B[1])
x8 = x7 + A[1]
x9 = x0 + 2.0 * x8**2
x10 = ax * x9
x11 = x10 - 1.0
x12 = x1 + B[0]
x13 = x12 * x2
x14 = x0 + 2.0 * x13
x15 = 0.5 * x14
x16 = -x0 * (ax * A[2] + bx * B[2])
x17 = x16 + A[2]
x18 = x0 + 2.0 * x17**2
x19 = ax * x18
x20 = x19 - 1.0
x21 = bx * x0
x22 = 2.0 * x21 + 1.0
x23 = ax * x21
x24 = (
5.568327996831708
* ax
* da
* db
* x0**1.5
* numpy.exp(-x23 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2))
)
x25 = x7 + B[1]
x26 = x24 * (x10 + x19 - 4.0 * x21 + x4 - 3.0)
x27 = x2 * x26
x28 = x16 + B[2]
x29 = x26 * x8
x30 = x25 * x8
x31 = x0 + 2.0 * x30
x32 = 0.5 * x31
x33 = x17 * x26
x34 = x17 * x28
x35 = x0 + 2.0 * x34
x36 = 0.5 * x35
# 9 item(s)
result[0, 0] = numpy.sum(
-x24 * (x11 * x15 + x13 * (ax * x3 - x22) - x14 * x21 + x15 * x20 + x5 * x6)
)
result[0, 1] = numpy.sum(-x25 * x27)
result[0, 2] = numpy.sum(-x27 * x28)
result[1, 0] = numpy.sum(-x12 * x29)
result[1, 1] = numpy.sum(
-x24 * (x11 * x6 + x20 * x32 - x21 * x31 + x30 * (ax * x9 - x22) + x32 * x5)
)
result[1, 2] = numpy.sum(-x28 * x29)
result[2, 0] = numpy.sum(-x12 * x33)
result[2, 1] = numpy.sum(-x25 * x33)
result[2, 2] = numpy.sum(
-x24 * (x11 * x36 + x20 * x6 - x21 * x35 + x34 * (ax * x18 - x22) + x36 * x5)
)
return result
[docs]
def kinetic3d_12(ax, da, A, bx, db, B):
"""Cartesian 3D (pd) kinetic energy integral.
Generated code; DO NOT modify by hand!"""
result = numpy.zeros((3, 6), dtype=float)
x0 = (ax + bx) ** (-1.0)
x1 = x0 * (ax * A[0] + bx * B[0])
x2 = -x1
x3 = x2 + B[0]
x4 = x2 + A[0]
x5 = 2.0 * x4
x6 = x3 * x5
x7 = x0 + x6
x8 = x0 * (-2.0 * x1 + A[0] + B[0]) + x3 * x7
x9 = ax * (x0 + 2.0 * x4**2)
x10 = x9 - 1.0
x11 = bx * x0
x12 = 2.0 * x0
x13 = bx * x12
x14 = 0.5 * x0
x15 = x0 * (ax * A[1] + bx * B[1])
x16 = -x15
x17 = x16 + A[1]
x18 = ax * (x0 + 2.0 * x17**2)
x19 = x18 - 1.0
x20 = 0.5 * x8
x21 = x0 * (ax * A[2] + bx * B[2])
x22 = -x21
x23 = x22 + A[2]
x24 = ax * (x0 + 2.0 * x23**2)
x25 = x24 - 1.0
x26 = x0 * x10
x27 = x13 + 1.0
x28 = x27 - x9
x29 = -x28
x30 = -2.0 * bx * x0 * x7 + x26 + x29 * x6
x31 = 0.5 * x3
x32 = ax * x11
x33 = (
5.568327996831708
* ax
* da
* db
* numpy.sqrt(x0)
* numpy.exp(-x32 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2))
)
x34 = 1.732050807568877 * x33
x35 = 0.3333333333333333 * x0 * x34
x36 = x0 * x30
x37 = ax * (x0 + 2.0 * x23**2) - 1.0
x38 = x0 * x7
x39 = -x18 + x27
x40 = x16 + B[1]
x41 = 0.5 * x40
x42 = x33 * x41
x43 = ax * (x0 + 2.0 * x17**2) - 1.0
x44 = -x24 + x27
x45 = x22 + B[2]
x46 = 0.5 * x45
x47 = x33 * x46
x48 = x0 * x19
x49 = 2.0 * x40**2
x50 = x0 + x49
x51 = -x39
x52 = x0 * (-x12 * (bx * x50 - 1.0) + x48 + x49 * x51)
x53 = x0 * x50
x54 = 0.1666666666666667 * x34
x55 = x4 * x54
x56 = 6.0 * bx * x0 - x18 - x24 - x9 + 3.0
x57 = x0 * x33 * x45 * x56
x58 = x0 * x25
x59 = 2.0 * x45**2
x60 = x0 + x59
x61 = -x44
x62 = x0 * (-x12 * (bx * x60 - 1.0) + x58 + x59 * x61)
x63 = x0 * x60
x64 = 2.0 * x3**2
x65 = x0 + x64
x66 = x0 * (-x12 * (bx * x65 - 1.0) + x26 + x29 * x64)
x67 = x0 * x65
x68 = x17 * x54
x69 = 2.0 * x17 * x40
x70 = x0 + x69
x71 = -x13 * x70 + x48 + x51 * x69
x72 = x0 * x71
x73 = x0 * x70
x74 = x31 * x33
x75 = x0 * (-2.0 * x15 + A[1] + B[1]) + x40 * x70
x76 = 0.5 * x75
x77 = ax * (x0 + 2.0 * x4**2) - 1.0
x78 = x23 * x54
x79 = 2.0 * x23 * x45
x80 = x0 + x79
x81 = -x13 * x80 + x58 + x61 * x79
x82 = x0 * x81
x83 = x0 * x80
x84 = x0 * (-2.0 * x21 + A[2] + B[2]) + x45 * x80
x85 = 0.5 * x84
# 18 item(s)
result[0, 0] = numpy.sum(
x35
* (
-x0 * (bx * x8 + x1 - A[0])
+ x14 * (x10 * x3 + x10 * x4 - x11 * x5 - x13 * x3)
+ x19 * x20
+ x20 * x25
+ x30 * x31
)
)
result[0, 1] = numpy.sum(x42 * (x36 + x37 * x38 - x38 * x39))
result[0, 2] = numpy.sum(x47 * (x36 + x38 * x43 - x38 * x44))
result[0, 3] = numpy.sum(x55 * (-x28 * x53 + x37 * x53 + x52))
result[0, 4] = numpy.sum(-x4 * x40 * x57)
result[0, 5] = numpy.sum(x55 * (-x28 * x63 + x43 * x63 + x62))
result[1, 0] = numpy.sum(x68 * (x37 * x67 - x39 * x67 + x66))
result[1, 1] = numpy.sum(x74 * (-x28 * x73 + x37 * x73 + x72))
result[1, 2] = numpy.sum(-x17 * x3 * x57)
result[1, 3] = numpy.sum(
x35
* (
-x0 * (bx * x75 + x15 - A[1])
+ x10 * x76
- x14 * (x13 * x17 + x13 * x40 - x17 * x19 - x19 * x40)
+ x25 * x76
+ x41 * x71
)
)
result[1, 4] = numpy.sum(x47 * (-x44 * x73 + x72 + x73 * x77))
result[1, 5] = numpy.sum(x68 * (-x39 * x63 + x62 + x63 * x77))
result[2, 0] = numpy.sum(x78 * (x43 * x67 - x44 * x67 + x66))
result[2, 1] = numpy.sum(-x0 * x23 * x3 * x33 * x40 * x56)
result[2, 2] = numpy.sum(x74 * (-x28 * x83 + x43 * x83 + x82))
result[2, 3] = numpy.sum(x78 * (-x44 * x53 + x52 + x53 * x77))
result[2, 4] = numpy.sum(x42 * (-x39 * x83 + x77 * x83 + x82))
result[2, 5] = numpy.sum(
x35
* (
-x0 * (bx * x84 + x21 - A[2])
+ x10 * x85
- x14 * (x13 * x23 + x13 * x45 - x23 * x25 - x25 * x45)
+ x19 * x85
+ x46 * x81
)
)
return result
[docs]
def kinetic3d_13(ax, da, A, bx, db, B):
"""Cartesian 3D (pf) kinetic energy integral.
Generated code; DO NOT modify by hand!"""
result = numpy.zeros((3, 10), dtype=float)
x0 = (ax + bx) ** (-1.0)
x1 = x0 * (ax * A[1] + bx * B[1])
x2 = -x1
x3 = x2 + A[1]
x4 = -x3
x5 = ax * (x0 + 2.0 * x4**2)
x6 = x5 - 1.0
x7 = x0 * (ax * A[0] + bx * B[0])
x8 = -x7
x9 = x8 + B[0]
x10 = x8 + A[0]
x11 = x10 * x9
x12 = 4.0 * x11
x13 = 2.0 * x9**2
x14 = 3.0 * x0
x15 = x13 + x14
x16 = -2.0 * x7 + A[0] + B[0]
x17 = 2.0 * x11
x18 = x0 + x17
x19 = x0 * x16 + x18 * x9
x20 = 2.0 * x9
x21 = x0 * (x12 + x15) + x19 * x20
x22 = x0 * (ax * A[2] + bx * B[2])
x23 = -x22
x24 = x23 + A[2]
x25 = -x24
x26 = ax * (x0 + 2.0 * x25**2)
x27 = x26 - 1.0
x28 = -x10
x29 = x0 + 2.0 * x28**2
x30 = ax * x29 - 1.0
x31 = 2.0 * x0
x32 = bx * x31
x33 = x32 + 1.0
x34 = -ax * x29 + x33
x35 = -x34
x36 = x0 + x13
x37 = x13 * x35 - x31 * (bx * x36 - 1.0)
x38 = -x9
x39 = x28 * x38
x40 = 4.0 * x39
x41 = -x10 * x30 + x10 * x32 - x30 * x9 + x32 * x9
x42 = x0 * x30
x43 = -2.0 * bx * x0 * x18 + x17 * x35 + x42
x44 = -x43
x45 = x31 * (-bx * x19 - x7 + A[0])
x46 = ax * x0
x47 = bx * x46
x48 = (
5.568327996831708
* da
* db
* numpy.exp(-x47 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2))
)
x49 = numpy.sqrt(x0)
x50 = 3.872983346207417 * x49
x51 = 0.01666666666666667 * x46 * x48 * x50
x52 = x0 * (-x0 * x41 + x43 * x9 + x45)
x53 = ax * (x0 + 2.0 * x24**2) - 1.0
x54 = x0 * x19
x55 = x33 - x5
x56 = x2 + B[1]
x57 = x49 * x56
x58 = ax * x48
x59 = 1.732050807568877 * x58
x60 = 0.1666666666666667 * x59
x61 = x57 * x60
x62 = ax * (x0 + 2.0 * x3**2) - 1.0
x63 = -x26 + x33
x64 = x23 + B[2]
x65 = x49 * x60
x66 = x64 * x65
x67 = 2.0 * x56**2
x68 = x0 + x67
x69 = x0 * x6
x70 = -x55
x71 = -x31 * (bx * x68 - 1.0) + x67 * x70
x72 = x69 + x71
x73 = 0.08333333333333333 * x0**1.5 * x59
x74 = x0 * x18
x75 = -x63
x76 = x58 * x64
x77 = 0.5 * x76
x78 = 2.0 * x64**2
x79 = x0 + x78
x80 = x0 * x27
x81 = -x31 * (bx * x79 - 1.0) + x75 * x78
x82 = x80 + x81
x83 = x14 + x67
x84 = -x0 * (x31 * x55 + x31 * (bx * x83 - 2.0) - x72)
x85 = x0 * x83
x86 = 0.03333333333333333 * x50
x87 = x10 * x86
x88 = x56 * x58
x89 = x0 * x68
x90 = x0 * x72 + x35 * x89 + x75 * x89
x91 = x0 * x79
x92 = x0 * x82 + x35 * x91 + x70 * x91
x93 = x14 + x78
x94 = -x0 * (x31 * x63 + x31 * (bx * x93 - 2.0) - x82)
x95 = x0 * x93
x96 = x37 + x42
x97 = -x0 * (x31 * x34 + x31 * (bx * x15 - 2.0) - x96)
x98 = x0 * x15
x99 = x58 * x9
x100 = x3 * x86
x101 = x3 * x56
x102 = 2.0 * x101
x103 = x0 + x102
x104 = x102 * x70 - x103 * x32 + x69
x105 = x0 * x36
x106 = x0 * x96 + x105 * x70 + x105 * x75
x107 = x3 * x32 - x3 * x6 + x32 * x56 - x56 * x6
x108 = -2.0 * x1 + A[1] + B[1]
x109 = x0 * x108 + x103 * x56
x110 = x31 * (-bx * x109 - x1 + A[1])
x111 = x0 * (-x0 * x107 + x104 * x56 + x110)
x112 = x0 * x109
x113 = x65 * x9
x114 = -x104
x115 = x0 * x103
x116 = 4.0 * x101
x117 = 2.0 * x56
x118 = x0 * (x116 + x83) + x109 * x117
x119 = -x56
x120 = x119 * x4
x121 = 4.0 * x120
x122 = ax * (x0 + 2.0 * x10**2) - 1.0
x123 = x24 * x86
x124 = x24 * x64
x125 = 2.0 * x124
x126 = x0 + x125
x127 = x125 * x75 - x126 * x32 + x80
x128 = -x127
x129 = x0 * x126
x130 = -x24 * x27 + x24 * x32 - x27 * x64 + x32 * x64
x131 = -2.0 * x22 + A[2] + B[2]
x132 = x0 * x131 + x126 * x64
x133 = x31 * (-bx * x132 - x22 + A[2])
x134 = x0 * (-x0 * x130 + x127 * x64 + x133)
x135 = x0 * x132
x136 = 4.0 * x124
x137 = 2.0 * x64
x138 = x0 * (x136 + x93) + x132 * x137
x139 = -x64
x140 = x139 * x25
x141 = 4.0 * x140
# 30 item(s)
result[0, 0] = numpy.sum(
-x51
* (
x0 * (-4.0 * bx * x0 * x18 + x12 * x35 + x14 * x30 + x37)
- x20 * (x0 * x41 + x44 * x9 - x45)
+ x21 * x27
+ x21 * x6
+ x31
* (
-bx
* (
x0 * (x14 + 2.0 * x38**2 + x40)
- 2.0 * x38 * (x0 * x16 - x38 * (x0 + 2.0 * x39))
)
+ x31
+ x40
)
)
)
result[0, 1] = numpy.sum(x61 * (x0 * x19 * x55 - x52 - x53 * x54))
result[0, 2] = numpy.sum(x66 * (x0 * x19 * x63 - x52 - x54 * x62))
result[0, 3] = numpy.sum(-x73 * (x18 * x53 * x68 + x18 * x72 + x43 * x68))
result[0, 4] = numpy.sum(x57 * x77 * (x0 * x44 - x70 * x74 - x74 * x75))
result[0, 5] = numpy.sum(-x73 * (x18 * x62 * x79 + x18 * x82 + x43 * x79))
result[0, 6] = numpy.sum(x87 * x88 * (x0 * x34 * x83 - x53 * x85 - x84))
result[0, 7] = numpy.sum(-x10 * x66 * x90)
result[0, 8] = numpy.sum(-x10 * x61 * x92)
result[0, 9] = numpy.sum(x76 * x87 * (x0 * x34 * x93 - x62 * x95 - x94))
result[1, 0] = numpy.sum(x100 * x99 * (x0 * x15 * x55 - x53 * x98 - x97))
result[1, 1] = numpy.sum(-x73 * (x103 * x36 * x53 + x103 * x96 + x104 * x36))
result[1, 2] = numpy.sum(-x106 * x3 * x66)
result[1, 3] = numpy.sum(x113 * (x0 * x109 * x34 - x111 - x112 * x53))
result[1, 4] = numpy.sum(x49 * x77 * x9 * (x0 * x114 - x115 * x35 - x115 * x75))
result[1, 5] = numpy.sum(-x113 * x3 * x92)
result[1, 6] = numpy.sum(
-x51
* (
x0 * (-4.0 * bx * x0 * x103 + x116 * x70 + x14 * x6 + x71)
- x117 * (x0 * x107 - x110 + x114 * x56)
+ x118 * x27
+ x118 * x30
+ x31
* (
-bx
* (
x0 * (2.0 * x119**2 + x121 + x14)
- 2.0 * x119 * (x0 * x108 - x119 * (x0 + 2.0 * x120))
)
+ x121
+ x31
)
)
)
result[1, 7] = numpy.sum(x66 * (x0 * x109 * x63 - x111 - x112 * x122))
result[1, 8] = numpy.sum(-x73 * (x103 * x122 * x79 + x103 * x82 + x104 * x79))
result[1, 9] = numpy.sum(x100 * x76 * (x0 * x55 * x93 - x122 * x95 - x94))
result[2, 0] = numpy.sum(x123 * x99 * (x0 * x15 * x63 - x62 * x98 - x97))
result[2, 1] = numpy.sum(-x106 * x24 * x61)
result[2, 2] = numpy.sum(-x73 * (x126 * x36 * x62 + x126 * x96 + x127 * x36))
result[2, 3] = numpy.sum(-x113 * x24 * x90)
result[2, 4] = numpy.sum(0.5 * x57 * x99 * (x0 * x128 - x129 * x35 - x129 * x70))
result[2, 5] = numpy.sum(x113 * (x0 * x132 * x34 - x134 - x135 * x62))
result[2, 6] = numpy.sum(x123 * x88 * (x0 * x63 * x83 - x122 * x85 - x84))
result[2, 7] = numpy.sum(-x73 * (x122 * x126 * x68 + x126 * x72 + x127 * x68))
result[2, 8] = numpy.sum(x61 * (x0 * x132 * x55 - x122 * x135 - x134))
result[2, 9] = numpy.sum(
-x51
* (
x0 * (-4.0 * bx * x0 * x126 + x136 * x75 + x14 * x27 + x81)
- x137 * (x0 * x130 + x128 * x64 - x133)
+ x138 * x30
+ x138 * x6
+ x31
* (
-bx
* (
x0 * (2.0 * x139**2 + x14 + x141)
- 2.0 * x139 * (x0 * x131 - x139 * (x0 + 2.0 * x140))
)
+ x141
+ x31
)
)
)
return result
[docs]
def kinetic3d_14(ax, da, A, bx, db, B):
"""Cartesian 3D (pg) kinetic energy integral.
Generated code; DO NOT modify by hand!"""
result = numpy.zeros((3, 15), dtype=float)
x0 = 2.0 * ax
x1 = 2.0 * bx
x2 = (x0 + x1) ** (-1.0)
x3 = -ax
x4 = (ax + bx) ** (-1.0)
x5 = -x4 * (ax * A[0] + bx * B[0])
x6 = -x5 - A[0]
x7 = 2.0 * ax**2
x8 = -x3 - x7 * (x2 + x6**2)
x9 = -x5 - B[0]
x10 = ax * x4
x11 = bx * x10
x12 = numpy.exp(-x11 * (A[0] - B[0]) ** 2)
x13 = 1.772453850905516 * numpy.sqrt(x4)
x14 = x12 * x13
x15 = x14 * x9
x16 = x15 * x8
x17 = bx * x0 * x4
x18 = x15 * x17 + x16
x19 = x14 * x6
x20 = x19 * (x17 + x8)
x21 = x2 * (x18 + x20)
x22 = x18 * x6
x23 = x14 * x2
x24 = x19 * x9
x25 = x23 + x24
x26 = x23 * x8
x27 = x17 * x25 + x22 + x26
x28 = x27 * x9
x29 = x2 * (x15 + x19)
x30 = x25 * x9
x31 = x29 + x30
x32 = x10 * (x1 * x31 - x19)
x33 = 4.0 * x11
x34 = x18 * x9
x35 = x14 * x9**2
x36 = x23 + x35
x37 = x10 * (x1 * x36 - x14)
x38 = x34 + x37
x39 = x26 + x38
x40 = 2.0 * x23
x41 = x9 * (x36 + x40)
x42 = x10 * (x1 * x41 - 2.0 * x15) + x2 * (x15 * x33 + 2.0 * x16) + x39 * x9
x43 = 3.0 * x26
x44 = x21 + x28 + x32
x45 = 3.0 * x23
x46 = 2.0 * x24
x47 = x2 * (x35 + x45 + x46) + x31 * x9
x48 = (
-x10 * (-2.0 * bx * x47 + x40 + x46)
+ x2 * (2.0 * x22 + x25 * x33 + x38 + x43)
+ x44 * x9
)
x49 = 3.0 * x29 + 3.0 * x30
x50 = x2 * (x41 + x49) + x47 * x9
x51 = numpy.exp(-x11 * (A[1] - B[1]) ** 2)
x52 = numpy.exp(-x11 * (A[2] - B[2]) ** 2)
x53 = 3.141592653589793 * x4 * x52
x54 = x51 * x53
x55 = -x4 * (ax * A[1] + bx * B[1])
x56 = -x55 - A[1]
x57 = -x3 - x7 * (x2 + x56**2)
x58 = x50 * x54
x59 = -x4 * (ax * A[2] + bx * B[2])
x60 = -x59 - A[2]
x61 = -x3 - x7 * (x2 + x60**2)
x62 = da * db
x63 = 0.09759000729485332 * x62
x64 = -x55 - B[1]
x65 = x13 * x51
x66 = x64 * x65
x67 = x57 * x66
x68 = x17 * x66 + x67
x69 = x13 * x52
x70 = x48 * x54
x71 = x47 * x54
x72 = 0.2581988897471611 * x62
x73 = -x59 - B[2]
x74 = x69 * x73
x75 = x61 * x74
x76 = x17 * x74 + x75
x77 = x2 * x65
x78 = x57 * x77
x79 = x64 * x68
x80 = x64**2 * x65
x81 = x77 + x80
x82 = x10 * (x1 * x81 - x65)
x83 = x79 + x82
x84 = x78 + x83
x85 = x31 * x69
x86 = 0.3333333333333333 * x62
x87 = x54 * x73
x88 = 1.732050807568877 * x86
x89 = x2 * x69
x90 = x61 * x89
x91 = x73 * x76
x92 = x69 * x73**2
x93 = x89 + x92
x94 = x10 * (x1 * x93 - x69)
x95 = x91 + x94
x96 = x90 + x95
x97 = x31 * x65
x98 = 2.0 * x77
x99 = x64 * (x81 + x98)
x100 = x69 * x99
x101 = x10 * (x1 * x99 - 2.0 * x66) + x2 * (x33 * x66 + 2.0 * x67) + x64 * x84
x102 = 2.0 * x89
x103 = x73 * (x102 + x93)
x104 = x103 * x65
x105 = x10 * (x1 * x103 - 2.0 * x74) + x2 * (x33 * x74 + 2.0 * x75) + x73 * x96
x106 = 3.0 * x77
x107 = x106 + 3.0 * x80
x108 = x107 * x2 + x64 * x99
x109 = 3.0 * x78
x110 = x12 * x53
x111 = x110 * (
x10 * (2.0 * bx * x108 - x107) + x101 * x64 + x2 * (x109 + 3.0 * x79 + 3.0 * x82)
)
x112 = x110 * x6
x113 = 3.141592653589793 * x12 * x4 * x51
x114 = x113 * x6
x115 = 3.0 * x89
x116 = x115 + 3.0 * x92
x117 = x103 * x73 + x116 * x2
x118 = 3.0 * x90
x119 = x113 * (
x10 * (2.0 * bx * x117 - x116) + x105 * x73 + x2 * (x118 + 3.0 * x91 + 3.0 * x94)
)
x120 = 3.0 * x35 + x45
x121 = x120 * x2 + x41 * x9
x122 = x56 * x65
x123 = x122 * (x17 + x57)
x124 = x54 * (
x10 * (2.0 * bx * x121 - x120) + x2 * (3.0 * x34 + 3.0 * x37 + x43) + x42 * x9
)
x125 = x121 * x54
x126 = x56 * x68
x127 = x122 * x64
x128 = x127 + x77
x129 = x126 + x128 * x17 + x78
x130 = x41 * x69
x131 = x2 * (x122 + x66)
x132 = x128 * x64
x133 = x131 + x132
x134 = x133 * x69
x135 = x2 * (x123 + x68)
x136 = x129 * x64
x137 = x10 * (x1 * x133 - x122)
x138 = x135 + x136 + x137
x139 = 2.0 * x127
x140 = x133 * x64 + x2 * (x106 + x139 + x80)
x141 = (
-x10 * (-2.0 * bx * x140 + x139 + x98)
+ x138 * x64
+ x2 * (x109 + 2.0 * x126 + x128 * x33 + x83)
)
x142 = x110 * x141
x143 = x110 * x9
x144 = x113 * x56
x145 = 3.0 * x131 + 3.0 * x132
x146 = x140 * x64 + x2 * (x145 + x99)
x147 = x110 * x146
x148 = x110 * x8
x149 = x133 * x14
x150 = x103 * x14
x151 = x60 * x69
x152 = x151 * (x17 + x61)
x153 = x60 * x76
x154 = x151 * x73
x155 = x154 + x89
x156 = x153 + x155 * x17 + x90
x157 = x41 * x65
x158 = x2 * (x151 + x74)
x159 = x155 * x73
x160 = x158 + x159
x161 = x160 * x65
x162 = x2 * (x152 + x76)
x163 = x156 * x73
x164 = x10 * (x1 * x160 - x151)
x165 = x162 + x163 + x164
x166 = x113 * x9
x167 = 2.0 * x154
x168 = x160 * x73 + x2 * (x115 + x167 + x92)
x169 = (
-x10 * (-2.0 * bx * x168 + x102 + x167)
+ x165 * x73
+ x2 * (x118 + 2.0 * x153 + x155 * x33 + x95)
)
x170 = x113 * x169
x171 = x14 * x99
x172 = x14 * x160
x173 = 3.0 * x158 + 3.0 * x159
x174 = x168 * x73 + x2 * (x103 + x173)
x175 = x113 * x174
# 45 item(s)
result[0, 0] = numpy.sum(
x63
* (
x54
* (
x10 * (2.0 * bx * x50 - x49)
+ x2 * (3.0 * x21 + 3.0 * x28 + 3.0 * x32 + x42)
+ x48 * x9
)
+ x57 * x58
+ x58 * x61
)
)
result[0, 1] = numpy.sum(x72 * (x47 * x68 * x69 + x61 * x64 * x71 + x64 * x70))
result[0, 2] = numpy.sum(x72 * (x47 * x65 * x76 + x57 * x71 * x73 + x70 * x73))
result[0, 3] = numpy.sum(x86 * (x44 * x69 * x81 + x61 * x81 * x85 + x84 * x85))
result[0, 4] = numpy.sum(x88 * (x31 * x66 * x76 + x31 * x68 * x74 + x44 * x64 * x87))
result[0, 5] = numpy.sum(x86 * (x44 * x65 * x93 + x57 * x93 * x97 + x96 * x97))
result[0, 6] = numpy.sum(x72 * (x100 * x25 * x61 + x100 * x27 + x101 * x25 * x69))
result[0, 7] = numpy.sum(x88 * (x25 * x74 * x84 + x25 * x76 * x81 + x27 * x74 * x81))
result[0, 8] = numpy.sum(x88 * (x25 * x66 * x96 + x25 * x68 * x93 + x27 * x66 * x93))
result[0, 9] = numpy.sum(x72 * (x104 * x25 * x57 + x104 * x27 + x105 * x25 * x65))
result[0, 10] = numpy.sum(x63 * (x108 * x112 * x61 + x108 * x20 * x69 + x111 * x6))
result[0, 11] = numpy.sum(
x72 * (x101 * x112 * x73 + x19 * x76 * x99 + x20 * x74 * x99)
)
result[0, 12] = numpy.sum(x86 * (x19 * x81 * x96 + x19 * x84 * x93 + x20 * x81 * x93))
result[0, 13] = numpy.sum(
x72 * (x103 * x19 * x68 + x103 * x20 * x66 + x105 * x114 * x64)
)
result[0, 14] = numpy.sum(x63 * (x114 * x117 * x57 + x117 * x20 * x65 + x119 * x6))
result[1, 0] = numpy.sum(x63 * (x121 * x123 * x69 + x124 * x56 + x125 * x56 * x61))
result[1, 1] = numpy.sum(x72 * (x128 * x130 * x61 + x128 * x42 * x69 + x129 * x130))
result[1, 2] = numpy.sum(
x72 * (x122 * x41 * x76 + x123 * x41 * x74 + x42 * x56 * x87)
)
result[1, 3] = numpy.sum(x86 * (x134 * x36 * x61 + x134 * x39 + x138 * x36 * x69))
result[1, 4] = numpy.sum(
x88 * (x128 * x36 * x76 + x128 * x39 * x74 + x129 * x36 * x74)
)
result[1, 5] = numpy.sum(
x86 * (x122 * x36 * x96 + x122 * x39 * x93 + x123 * x36 * x93)
)
result[1, 6] = numpy.sum(x72 * (x140 * x143 * x61 + x140 * x18 * x69 + x142 * x9))
result[1, 7] = numpy.sum(
x88 * (x133 * x15 * x76 + x133 * x18 * x74 + x138 * x143 * x73)
)
result[1, 8] = numpy.sum(
x88 * (x128 * x15 * x96 + x128 * x18 * x93 + x129 * x15 * x93)
)
result[1, 9] = numpy.sum(
x72 * (x103 * x122 * x18 + x103 * x123 * x15 + x105 * x144 * x9)
)
result[1, 10] = numpy.sum(
x63
* (
x110
* (
x10 * (2.0 * bx * x146 - x145)
+ x141 * x64
+ x2 * (x101 + 3.0 * x135 + 3.0 * x136 + 3.0 * x137)
)
+ x147 * x61
+ x147 * x8
)
)
result[1, 11] = numpy.sum(x72 * (x14 * x140 * x76 + x140 * x148 * x73 + x142 * x73))
result[1, 12] = numpy.sum(x86 * (x138 * x14 * x93 + x149 * x8 * x93 + x149 * x96))
result[1, 13] = numpy.sum(x72 * (x105 * x128 * x14 + x128 * x150 * x8 + x129 * x150))
result[1, 14] = numpy.sum(x63 * (x117 * x123 * x14 + x117 * x144 * x8 + x119 * x56))
result[2, 0] = numpy.sum(x63 * (x121 * x152 * x65 + x124 * x60 + x125 * x57 * x60))
result[2, 1] = numpy.sum(
x72 * (x151 * x41 * x68 + x152 * x41 * x66 + x42 * x54 * x60 * x64)
)
result[2, 2] = numpy.sum(x72 * (x155 * x157 * x57 + x155 * x42 * x65 + x156 * x157))
result[2, 3] = numpy.sum(
x86 * (x151 * x36 * x84 + x151 * x39 * x81 + x152 * x36 * x81)
)
result[2, 4] = numpy.sum(
x88 * (x155 * x36 * x68 + x155 * x39 * x66 + x156 * x36 * x66)
)
result[2, 5] = numpy.sum(x86 * (x161 * x36 * x57 + x161 * x39 + x165 * x36 * x65))
result[2, 6] = numpy.sum(
x72 * (x101 * x143 * x60 + x15 * x152 * x99 + x151 * x18 * x99)
)
result[2, 7] = numpy.sum(
x88 * (x15 * x155 * x84 + x15 * x156 * x81 + x155 * x18 * x81)
)
result[2, 8] = numpy.sum(
x88 * (x15 * x160 * x68 + x160 * x18 * x66 + x165 * x166 * x64)
)
result[2, 9] = numpy.sum(x72 * (x166 * x168 * x57 + x168 * x18 * x65 + x170 * x9))
result[2, 10] = numpy.sum(x63 * (x108 * x14 * x152 + x108 * x148 * x60 + x111 * x60))
result[2, 11] = numpy.sum(x72 * (x101 * x14 * x155 + x155 * x171 * x8 + x156 * x171))
result[2, 12] = numpy.sum(x86 * (x14 * x165 * x81 + x172 * x8 * x81 + x172 * x84))
result[2, 13] = numpy.sum(
x72 * (x113 * x168 * x64 * x8 + x14 * x168 * x68 + x170 * x64)
)
result[2, 14] = numpy.sum(
x63
* (
x113
* (
x10 * (2.0 * bx * x174 - x173)
+ x169 * x73
+ x2 * (x105 + 3.0 * x162 + 3.0 * x163 + 3.0 * x164)
)
+ x175 * x57
+ x175 * x8
)
)
return result
[docs]
def kinetic3d_20(ax, da, A, bx, db, B):
"""Cartesian 3D (ds) kinetic energy integral.
Generated code; DO NOT modify by hand!"""
result = numpy.zeros((6, 1), dtype=float)
x0 = (ax + bx) ** (-1.0)
x1 = -x0 * (ax * A[0] + bx * B[0]) + A[0]
x2 = x1**2
x3 = x0 + 2.0 * x1**2
x4 = bx * x0
x5 = 2.0 * x4 + 1.0
x6 = ax * x3
x7 = 0.5 * x6 - 0.5
x8 = ax * x0
x9 = -x0 * (ax * A[1] + bx * B[1]) + A[1]
x10 = x0 + 2.0 * x9**2
x11 = ax * x10
x12 = x11 - 1.0
x13 = ax * (x0 + 2.0 * x2)
x14 = 0.5 * x13
x15 = -x0 * (ax * A[2] + bx * B[2]) + A[2]
x16 = x0 + 2.0 * x15**2
x17 = ax * x16
x18 = x17 - 1.0
x19 = ax * x4
x20 = (
5.568327996831708
* da
* db
* numpy.sqrt(x0)
* numpy.exp(-x19 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2))
)
x21 = 0.5773502691896258 * x0 * x20
x22 = x11 + x17 - 4.0 * x4 + x6 - 3.0
x23 = x1 * x20 * x22 * x8
x24 = x9**2
x25 = 0.5 * x8
x26 = ax * (x0 + 2.0 * x24)
x27 = x15**2
x28 = ax * (x0 + 2.0 * x27)
# 6 item(s)
result[0, 0] = numpy.sum(
-x21
* (ax * x2 * (ax * x3 - x5) + x12 * x14 + x14 * x18 - x4 * (x13 - 1.0) + x7 * x8)
)
result[1, 0] = numpy.sum(-x23 * x9)
result[2, 0] = numpy.sum(-x15 * x23)
result[3, 0] = numpy.sum(
-0.5
* x21
* (
2.0 * ax * x24 * (ax * x10 - x5)
+ 2.0 * x12 * x25
+ x18 * x26
+ 2.0 * x26 * x7
- 2.0 * x4 * (x26 - 1.0)
)
)
result[4, 0] = numpy.sum(-x15 * x20 * x22 * x8 * x9)
result[5, 0] = numpy.sum(
-0.5
* x21
* (
2.0 * ax * x27 * (ax * x16 - x5)
+ x12 * x28
+ 2.0 * x18 * x25
+ 2.0 * x28 * x7
- 2.0 * x4 * (x28 - 1.0)
)
)
return result
[docs]
def kinetic3d_21(ax, da, A, bx, db, B):
"""Cartesian 3D (dp) kinetic energy integral.
Generated code; DO NOT modify by hand!"""
result = numpy.zeros((6, 3), dtype=float)
x0 = -B[0]
x1 = (ax + bx) ** (-1.0)
x2 = x1 * (ax * A[0] + bx * B[0])
x3 = -x2
x4 = x3 + A[0]
x5 = x3 + B[0]
x6 = 2.0 * x4
x7 = x5 * x6
x8 = x1 + x7
x9 = ax * (x1 * (-2.0 * x2 + A[0] + B[0]) + x4 * x8)
x10 = bx * x1
x11 = ax * (x1 + 2.0 * x4**2)
x12 = x11 - 1.0
x13 = 2.0 * x10
x14 = 0.5 * ax
x15 = x1 * x14
x16 = x1 * (ax * A[1] + bx * B[1])
x17 = -x16
x18 = x17 + A[1]
x19 = ax * (x1 + 2.0 * x18**2)
x20 = x19 - 1.0
x21 = 0.5 * x9
x22 = x1 * (ax * A[2] + bx * B[2])
x23 = -x22
x24 = x23 + A[2]
x25 = ax * (x1 + 2.0 * x24**2)
x26 = x25 - 1.0
x27 = x1 * x12
x28 = x13 + 1.0
x29 = -x11 + x28
x30 = -x29
x31 = -2.0 * bx * x1 * x8 + x27 + x30 * x7
x32 = x14 * x4
x33 = ax * x10
x34 = -B[1]
x35 = -B[2]
x36 = (
5.568327996831708
* da
* db
* numpy.sqrt(x1)
* numpy.exp(-x33 * ((x0 + A[0]) ** 2 + (x34 + A[1]) ** 2 + (x35 + A[2]) ** 2))
)
x37 = 1.732050807568877 * x36
x38 = 0.3333333333333333 * x1 * x37
x39 = 2.0 * x4**2
x40 = ax * (x1 + x39)
x41 = x40 - 1.0
x42 = x1 * (ax * x27 + ax * x30 * x39 - x13 * x41)
x43 = 2.0 * x24**2
x44 = ax * (x1 + x43)
x45 = x44 - 1.0
x46 = x1 * x40
x47 = -x19 + x28
x48 = x17 + B[1]
x49 = 0.1666666666666667 * x37
x50 = x48 * x49
x51 = 2.0 * x18**2
x52 = ax * (x1 + x51)
x53 = x52 - 1.0
x54 = -x25 + x28
x55 = x23 + B[2]
x56 = x49 * x55
x57 = x1 * x31
x58 = x1 * x8
x59 = x14 * x18
x60 = x36 * x59
x61 = x1 * x20
x62 = 2.0 * x18 * x48
x63 = x1 + x62
x64 = -x47
x65 = -x13 * x63 + x61 + x62 * x64
x66 = x1 * x65
x67 = x1 * x63
x68 = x32 * x36
x69 = 6.0 * bx * x1 - x11 - x19 - x25 + 3.0
x70 = ax * x1 * x36 * x4 * x69
x71 = x14 * x24
x72 = x36 * x71
x73 = x1 * x26
x74 = 2.0 * x24 * x55
x75 = x1 + x74
x76 = -x54
x77 = -x13 * x75 + x73 + x74 * x76
x78 = x1 * x77
x79 = x1 * x75
x80 = x1 * (ax * x51 * x64 + ax * x61 - x13 * x53)
x81 = x1 * x52
x82 = x49 * x5
x83 = ax * (x1 * (-2.0 * x16 + A[1] + B[1]) + x18 * x63)
x84 = 0.5 * x83
x85 = x1 * (ax * x43 * x76 + ax * x73 - x13 * x45)
x86 = x1 * x44
x87 = ax * (x1 * (-2.0 * x22 + A[2] + B[2]) + x24 * x75)
x88 = 0.5 * x87
# 18 item(s)
result[0, 0] = numpy.sum(
x38
* (
-x10 * (x0 + x2 + x9)
- x15 * (x10 * x6 - x12 * x4 - x12 * x5 + x13 * x5)
+ x20 * x21
+ x21 * x26
+ x31 * x32
)
)
result[0, 1] = numpy.sum(x50 * (x42 + x45 * x46 - x46 * x47))
result[0, 2] = numpy.sum(x56 * (x42 + x46 * x53 - x46 * x54))
result[1, 0] = numpy.sum(x60 * (x45 * x58 - x47 * x58 + x57))
result[1, 1] = numpy.sum(x68 * (-x29 * x67 + x45 * x67 + x66))
result[1, 2] = numpy.sum(-x18 * x55 * x70)
result[2, 0] = numpy.sum(x72 * (x53 * x58 - x54 * x58 + x57))
result[2, 1] = numpy.sum(-x24 * x48 * x70)
result[2, 2] = numpy.sum(x68 * (-x29 * x79 + x53 * x79 + x78))
result[3, 0] = numpy.sum(x82 * (-x29 * x81 + x45 * x81 + x80))
result[3, 1] = numpy.sum(
x38
* (
-x10 * (x16 + x34 + x83)
+ x12 * x84
- x15 * (x13 * x18 + x13 * x48 - x18 * x20 - x20 * x48)
+ x26 * x84
+ x59 * x65
)
)
result[3, 2] = numpy.sum(x56 * (x41 * x81 - x54 * x81 + x80))
result[4, 0] = numpy.sum(-ax * x1 * x18 * x24 * x36 * x5 * x69)
result[4, 1] = numpy.sum(x72 * (x41 * x67 - x54 * x67 + x66))
result[4, 2] = numpy.sum(x60 * (x41 * x79 - x47 * x79 + x78))
result[5, 0] = numpy.sum(x82 * (-x29 * x86 + x53 * x86 + x85))
result[5, 1] = numpy.sum(x50 * (x41 * x86 - x47 * x86 + x85))
result[5, 2] = numpy.sum(
x38
* (
-x10 * (x22 + x35 + x87)
+ x12 * x88
- x15 * (x13 * x24 + x13 * x55 - x24 * x26 - x26 * x55)
+ x20 * x88
+ x71 * x77
)
)
return result
[docs]
def kinetic3d_22(ax, da, A, bx, db, B):
"""Cartesian 3D (dd) kinetic energy integral.
Generated code; DO NOT modify by hand!"""
result = numpy.zeros((6, 6), dtype=float)
x0 = (ax + bx) ** (-1.0)
x1 = x0 * (ax * A[1] + bx * B[1])
x2 = -x1
x3 = x2 + A[1]
x4 = -x3
x5 = ax * (x0 + 2.0 * x4**2)
x6 = x5 - 1.0
x7 = x0 * (ax * A[0] + bx * B[0])
x8 = -x7
x9 = x8 + B[0]
x10 = 2.0 * x9**2
x11 = 3.0 * x0
x12 = x8 + A[0]
x13 = x12 * x9
x14 = 4.0 * x13
x15 = -2.0 * x7 + A[0] + B[0]
x16 = x0 * x15
x17 = 2.0 * x13
x18 = x0 + x17
x19 = x16 + x18 * x9
x20 = 2.0 * x12
x21 = ax * (x0 * (x10 + x11 + x14) + x19 * x20)
x22 = x0 * (ax * A[2] + bx * B[2])
x23 = -x22
x24 = x23 + A[2]
x25 = -x24
x26 = ax * (x0 + 2.0 * x25**2)
x27 = x26 - 1.0
x28 = -x12
x29 = x0 + 2.0 * x28**2
x30 = ax * x29 - 1.0
x31 = 2.0 * x0
x32 = bx * x31
x33 = x32 + 1.0
x34 = -ax * x29 + x33
x35 = -x34
x36 = x0 + x10
x37 = x10 * x35 - x31 * (bx * x36 - 1.0)
x38 = ax * x0
x39 = bx * x0 * x20 - x12 * x30 - x30 * x9 + x32 * x9
x40 = x0 * x30
x41 = -2.0 * bx * x0 * x18 + x17 * x35 + x40
x42 = -x41
x43 = x31 * (-bx * x19 - x7 + A[0])
x44 = -x9
x45 = 2.0 * x44**2
x46 = x28 * x44
x47 = numpy.sqrt(x0)
x48 = -B[0]
x49 = bx * x38
x50 = -B[1]
x51 = -B[2]
x52 = (
5.568327996831708
* da
* db
* numpy.exp(-x49 * ((x48 + A[0]) ** 2 + (x50 + A[1]) ** 2 + (x51 + A[2]) ** 2))
)
x53 = 0.08333333333333333 * x52
x54 = x0 * x47 * x53
x55 = ax * x12
x56 = x0 * x39
x57 = x12 * x18 + x16
x58 = ax * x57
x59 = -x0 * (ax * x56 + x32 * (x48 + x58 + x7) - x41 * x55)
x60 = 2.0 * x24**2
x61 = ax * (x0 + x60)
x62 = x61 - 1.0
x63 = x0 * x58
x64 = x33 - x5
x65 = x2 + B[1]
x66 = x47 * x52
x67 = x65 * x66
x68 = 0.2886751345948129
x69 = x67 * x68
x70 = 2.0 * x3**2
x71 = ax * (x0 + x70)
x72 = x71 - 1.0
x73 = -x26 + x33
x74 = x23 + B[2]
x75 = x66 * x68
x76 = x74 * x75
x77 = 2.0 * x65**2
x78 = x0 + x77
x79 = 2.0 * x12**2
x80 = ax * (x0 + x79)
x81 = x80 - 1.0
x82 = ax * x35 * x79 + ax * x40 - x32 * x81
x83 = x0 * x6
x84 = -x64
x85 = -x31 * (bx * x78 - 1.0) + x77 * x84
x86 = x83 + x85
x87 = x0**1.5
x88 = x53 * x87
x89 = x0 * x80
x90 = -x73
x91 = 2.0 * x74**2
x92 = x0 + x91
x93 = x0 * x27
x94 = -x31 * (bx * x92 - 1.0) + x90 * x91
x95 = x93 + x94
x96 = x0 * (x41 * x9 + x43 - x56)
x97 = x0 * x19
x98 = ax * x3
x99 = x75 * x98
x100 = x3 * x65
x101 = 2.0 * x100
x102 = x0 + x101
x103 = x101 * x84 - x102 * x32 + x83
x104 = 0.25 * ax * x52 * x87
x105 = x0 * x18
x106 = -0.5 * x0 * x42 + 0.5 * x105 * x84 + 0.5 * x105 * x90
x107 = x66 * x74
x108 = x3 * x32 - x3 * x6 + x32 * x65 - x6 * x65
x109 = x0 * x108
x110 = -2.0 * x1 + A[1] + B[1]
x111 = x0 * x110
x112 = x102 * x65 + x111
x113 = x31 * (-bx * x112 - x1 + A[1])
x114 = x0 * (x103 * x65 - x109 + x113)
x115 = x0 * x112
x116 = x55 * x75
x117 = -x103
x118 = x0 * x102
x119 = -x0 * x117 + x118 * x35 + x118 * x90
x120 = 0.5 * x55
x121 = x0 * x92
x122 = ax * x24
x123 = x122 * x75
x124 = x24 * x74
x125 = 2.0 * x124
x126 = x0 + x125
x127 = x125 * x90 - x126 * x32 + x93
x128 = x0 * x78
x129 = -x127
x130 = x0 * x126
x131 = -x0 * x129 + x130 * x35 + x130 * x84
x132 = -x24 * x27 + x24 * x32 - x27 * x74 + x32 * x74
x133 = x0 * x132
x134 = -2.0 * x22 + A[2] + B[2]
x135 = x0 * x134
x136 = x126 * x74 + x135
x137 = x31 * (-bx * x136 - x22 + A[2])
x138 = x0 * (x127 * x74 - x133 + x137)
x139 = x0 * x136
x140 = ax * x70 * x84 + ax * x83 - x32 * x72
x141 = x37 + x40
x142 = x102 * x3 + x111
x143 = ax * x142
x144 = -x0 * (ax * x109 - x103 * x98 + x32 * (x1 + x143 + x50))
x145 = x0 * x143
x146 = x75 * x9
x147 = x0 * x71
x148 = 4.0 * x100
x149 = ax * (x0 * (x11 + x148 + x77) + 2.0 * x112 * x3)
x150 = -x65
x151 = 2.0 * x150**2
x152 = x150 * x4
x153 = x0 * x36
x154 = 0.5 * x66 * x9
x155 = ax * x60 * x90 + ax * x93 - x32 * x62
x156 = x0 * x61
x157 = x126 * x24 + x135
x158 = ax * x157
x159 = -x0 * (ax * x133 - x122 * x127 + x32 * (x158 + x22 + x51))
x160 = x0 * x158
x161 = 4.0 * x124
x162 = ax * (x0 * (x11 + x161 + x91) + 2.0 * x136 * x24)
x163 = -x74
x164 = 2.0 * x163**2
x165 = x163 * x25
# 36 item(s)
result[0, 0] = numpy.sum(
-x54
* (
-ax * x20 * (x0 * x39 + x42 * x9 - x43)
+ x21 * x27
+ x21 * x6
+ x32
* (
-ax
* (
x0 * (x11 + x45 + 4.0 * x46)
- 2.0 * x28 * (x0 * x15 - x44 * (x0 + 2.0 * x46))
)
+ x0
+ x45
)
+ x38 * (-4.0 * bx * x0 * x18 + x11 * x30 + x14 * x35 + x37)
)
)
result[0, 1] = numpy.sum(x69 * (ax * x0 * x57 * x64 - x59 - x62 * x63))
result[0, 2] = numpy.sum(x76 * (ax * x0 * x57 * x73 - x59 - x63 * x72))
result[0, 3] = numpy.sum(-x88 * (x62 * x78 * x80 + x78 * x82 + x80 * x86))
result[0, 4] = numpy.sum(-x69 * x74 * (x0 * x82 + x84 * x89 + x89 * x90))
result[0, 5] = numpy.sum(-x88 * (x72 * x80 * x92 + x80 * x95 + x82 * x92))
result[1, 0] = numpy.sum(x99 * (x0 * x19 * x64 - x62 * x97 - x96))
result[1, 1] = numpy.sum(-x104 * (x102 * x18 * x62 + x102 * x41 + x103 * x18))
result[1, 2] = numpy.sum(-x106 * x107 * x98)
result[1, 3] = numpy.sum(x116 * (x0 * x112 * x34 - x114 - x115 * x62))
result[1, 4] = numpy.sum(-x107 * x119 * x120)
result[1, 5] = numpy.sum(-x116 * x3 * (x0 * x95 + x121 * x35 + x121 * x84))
result[2, 0] = numpy.sum(x123 * (x0 * x19 * x73 - x72 * x97 - x96))
result[2, 1] = numpy.sum(-x106 * x122 * x67)
result[2, 2] = numpy.sum(-x104 * (x126 * x18 * x72 + x126 * x41 + x127 * x18))
result[2, 3] = numpy.sum(-x116 * x24 * (x0 * x86 + x128 * x35 + x128 * x90))
result[2, 4] = numpy.sum(-x120 * x131 * x67)
result[2, 5] = numpy.sum(x116 * (x0 * x136 * x34 - x138 - x139 * x72))
result[3, 0] = numpy.sum(-x88 * (x140 * x36 + x141 * x71 + x36 * x62 * x71))
result[3, 1] = numpy.sum(x146 * (ax * x0 * x142 * x34 - x144 - x145 * x62))
result[3, 2] = numpy.sum(-x76 * x9 * (x0 * x140 + x147 * x35 + x147 * x90))
result[3, 3] = numpy.sum(
-x54
* (
x149 * x27
+ x149 * x30
+ x32
* (
-ax
* (
x0 * (x11 + x151 + 4.0 * x152)
- 2.0 * x4 * (x0 * x110 - x150 * (x0 + 2.0 * x152))
)
+ x0
+ x151
)
+ x38 * (-4.0 * bx * x0 * x102 + x11 * x6 + x148 * x84 + x85)
- 2.0 * x98 * (x0 * x108 - x113 + x117 * x65)
)
)
result[3, 4] = numpy.sum(x76 * (ax * x0 * x142 * x73 - x144 - x145 * x81))
result[3, 5] = numpy.sum(-x88 * (x140 * x92 + x71 * x81 * x92 + x71 * x95))
result[4, 0] = numpy.sum(-x24 * x99 * (x0 * x141 + x153 * x84 + x153 * x90))
result[4, 1] = numpy.sum(-x119 * x122 * x154)
result[4, 2] = numpy.sum(-x131 * x154 * x98)
result[4, 3] = numpy.sum(x123 * (x0 * x112 * x73 - x114 - x115 * x81))
result[4, 4] = numpy.sum(-x104 * (x102 * x126 * x81 + x102 * x127 + x103 * x126))
result[4, 5] = numpy.sum(x99 * (x0 * x136 * x64 - x138 - x139 * x81))
result[5, 0] = numpy.sum(-x88 * (x141 * x61 + x155 * x36 + x36 * x61 * x72))
result[5, 1] = numpy.sum(-x69 * x9 * (x0 * x155 + x156 * x35 + x156 * x84))
result[5, 2] = numpy.sum(x146 * (ax * x0 * x157 * x34 - x159 - x160 * x72))
result[5, 3] = numpy.sum(-x88 * (x155 * x78 + x61 * x78 * x81 + x61 * x86))
result[5, 4] = numpy.sum(x69 * (ax * x0 * x157 * x64 - x159 - x160 * x81))
result[5, 5] = numpy.sum(
-x54
* (
-2.0 * x122 * (x0 * x132 + x129 * x74 - x137)
+ x162 * x30
+ x162 * x6
+ x32
* (
-ax
* (
x0 * (x11 + x164 + 4.0 * x165)
- 2.0 * x25 * (x0 * x134 - x163 * (x0 + 2.0 * x165))
)
+ x0
+ x164
)
+ x38 * (-4.0 * bx * x0 * x126 + x11 * x27 + x161 * x90 + x94)
)
)
return result
[docs]
def kinetic3d_23(ax, da, A, bx, db, B):
"""Cartesian 3D (df) kinetic energy integral.
Generated code; DO NOT modify by hand!"""
result = numpy.zeros((6, 10), dtype=float)
x0 = (ax + bx) ** (-1.0)
x1 = x0 * (ax * A[0] + bx * B[0])
x2 = -x1
x3 = x2 + B[0]
x4 = x2 + A[0]
x5 = -x4
x6 = x0 + 2.0 * x5**2
x7 = ax * x6 - 1.0
x8 = x0 * x7
x9 = x3 * x4
x10 = 2.0 * x9
x11 = x0 + x10
x12 = 2.0 * x0
x13 = bx * x12
x14 = x13 + 1.0
x15 = -ax * x6 + x14
x16 = -x15
x17 = 4.0 * x9
x18 = 2.0 * x3**2
x19 = x0 + x18
x20 = -x12 * (bx * x19 - 1.0) + x16 * x18
x21 = 4.0 * bx * x0 * x11 - x16 * x17 - x20 - 3.0 * x8
x22 = ax * x4
x23 = x13 * x3 + x13 * x4 - x3 * x7 - x4 * x7
x24 = -x0 * x23
x25 = -2.0 * bx * x0 * x11 + x10 * x16 + x8
x26 = -x25
x27 = x26 * x3
x28 = -2.0 * x1 + A[0] + B[0]
x29 = x0 * x28
x30 = x11 * x3
x31 = x29 + x30
x32 = x12 * (-bx * x31 - x1 + A[0])
x33 = x24 - x27 + x32
x34 = 2.0 * x33
x35 = -x3
x36 = 2.0 * x35**2
x37 = 3.0 * x0
x38 = x35 * x5
x39 = 4.0 * x38
x40 = x0 * (x36 + x37 + x39)
x41 = -x0 * x28
x42 = x0 + 2.0 * x38
x43 = x35 * x42
x44 = 2.0 * x41 + 2.0 * x43
x45 = x40 + x44 * x5
x46 = -ax * x0 * x21 + x13 * (-ax * x45 + x0 + x36) + x22 * x34
x47 = ax * x24
x48 = -B[0]
x49 = x11 * x4
x50 = ax * (x29 + x49)
x51 = -x13 * (x1 + x48 + x50)
x52 = -x22 * x26 + x51
x53 = x0 * (ax * A[1] + bx * B[1])
x54 = -x53
x55 = x54 + A[1]
x56 = -x55
x57 = ax * (x0 + 2.0 * x56**2)
x58 = x57 - 1.0
x59 = x18 + x37
x60 = x0 * (x17 + x59)
x61 = 2.0 * x31
x62 = x4 * x61 + x60
x63 = ax * (x12 * (2.0 * x29 + x30 + x49) + x3 * x62)
x64 = x0 * (ax * A[2] + bx * B[2])
x65 = -x64
x66 = x65 + A[2]
x67 = -x66
x68 = ax * (x0 + 2.0 * x67**2)
x69 = x68 - 1.0
x70 = x42 * x5
x71 = 2.0 * x41
x72 = ax * x12
x73 = numpy.sqrt(x0)
x74 = ax * bx * x0
x75 = -B[1]
x76 = -B[2]
x77 = (
5.568327996831708
* da
* db
* numpy.exp(-x74 * ((x48 + A[0]) ** 2 + (x75 + A[1]) ** 2 + (x76 + A[2]) ** 2))
)
x78 = x73 * x77
x79 = 0.03726779962499649
x80 = x0 * x78 * x79
x81 = x0 * x46
x82 = 2.0 * x66**2
x83 = ax * (x0 + x82)
x84 = x83 - 1.0
x85 = ax * x0
x86 = x62 * x85
x87 = x14 - x57
x88 = x54 + B[1]
x89 = 0.08333333333333333 * x77
x90 = x73 * x89
x91 = x88 * x90
x92 = 2.0 * x55**2
x93 = ax * (x0 + x92)
x94 = x93 - 1.0
x95 = x14 - x68
x96 = x65 + B[2]
x97 = x90 * x96
x98 = 2.0 * x88**2
x99 = x0 + x98
x100 = x0 * x23
x101 = -ax * x100 + x22 * x25 + x51
x102 = x0 * x58
x103 = -x87
x104 = x103 * x98 - x12 * (bx * x99 - 1.0)
x105 = x102 + x104
x106 = x0**1.5
x107 = x106 * x89
x108 = x0 * x50
x109 = -x95
x110 = x78 * x96
x111 = 1.732050807568877
x112 = 0.1666666666666667 * x111
x113 = x110 * x112
x114 = 2.0 * x96**2
x115 = x0 + x114
x116 = x0 * x69
x117 = x109 * x114 - x12 * (bx * x115 - 1.0)
x118 = x116 + x117
x119 = x37 + x98
x120 = 2.0 * x4**2
x121 = ax * (x0 + x120)
x122 = x121 - 1.0
x123 = ax * x120 * x16 + ax * x8 - x122 * x13
x124 = x105 - x12 * (bx * x119 - 2.0)
x125 = -x12 * x87 + x124
x126 = x106 * x77
x127 = x126 * x79
x128 = x127 * x88
x129 = -x123
x130 = -x105
x131 = x107 * x96
x132 = -x118
x133 = x107 * x88
x134 = x114 + x37
x135 = x118 - x12 * (bx * x134 - 2.0)
x136 = -x12 * x95 + x135
x137 = x127 * x96
x138 = x0 * (-x0 * x21 + x12 * (-bx * (x35 * x44 + x40) + x12 + x39) + x3 * x34)
x139 = x0 * (x3 * x61 + x60)
x140 = ax * x55
x141 = x140 * x78
x142 = 3.872983346207417
x143 = 0.01666666666666667 * x142
x144 = x141 * x143
x145 = 2.0 * x88
x146 = x145 * x55
x147 = x0 + x146
x148 = -x100 + x25 * x3 + x32
x149 = x102 + x103 * x146 - x13 * x147
x150 = x107 * x111
x151 = ax * x150
x152 = x0 * x31
x153 = x0 * x33 + x103 * x152 + x109 * x152
x154 = x13 * x55 + x13 * x88 - x55 * x58 - x58 * x88
x155 = x0 * x154
x156 = -2.0 * x53 + A[1] + B[1]
x157 = x0 * x156
x158 = x147 * x88
x159 = x157 + x158
x160 = x12 * (-bx * x159 - x53 + A[1])
x161 = x149 * x88 - x155 + x160
x162 = -x149
x163 = x109 * x11
x164 = 0.25 * ax * x126
x165 = x103 * x11
x166 = x140 * x150
x167 = 4.0 * x55 * x88
x168 = x0 * (4.0 * bx * x0 * x147 - x103 * x167 - x104 - x37 * x58)
x169 = -x88
x170 = 2.0 * x169**2
x171 = x169 * x56
x172 = 4.0 * x171
x173 = x0 * (x170 + x172 + x37)
x174 = -x156
x175 = x0 + 2.0 * x171
x176 = x169 * x175
x177 = 2.0 * x0 * x174 + 2.0 * x176
x178 = -x154
x179 = x0 * x178
x180 = x162 * x88
x181 = x160 + x179 - x180
x182 = x0 * (x12 * (-bx * (x169 * x177 + x173) + x12 + x172) + x145 * x181 - x168)
x183 = x0 * (x119 + x167)
x184 = x0 * (x145 * x159 + x183)
x185 = x143 * x78
x186 = x185 * x22
x187 = x0 * x159
x188 = x0 * x181 + x109 * x187 + x16 * x187
x189 = x147 * x16
x190 = x150 * x22
x191 = x0 * x134
x192 = 0.03333333333333333 * x142
x193 = x192 * x22
x194 = ax * x66
x195 = x185 * x194
x196 = x78 * x88
x197 = x112 * x196
x198 = 2.0 * x96
x199 = x198 * x66
x200 = x0 + x199
x201 = x109 * x199 + x116 - x13 * x200
x202 = x150 * x194
x203 = -x201
x204 = x13 * x66 + x13 * x96 - x66 * x69 - x69 * x96
x205 = x0 * x204
x206 = -2.0 * x64 + A[2] + B[2]
x207 = x0 * x206
x208 = x200 * x96
x209 = x207 + x208
x210 = x12 * (-bx * x209 - x64 + A[2])
x211 = x201 * x96 - x205 + x210
x212 = x0 * x119
x213 = x16 * x99
x214 = -x204
x215 = x0 * x214
x216 = x203 * x96
x217 = x210 + x215 - x216
x218 = x0 * x209
x219 = x0 * x217 + x103 * x218 + x16 * x218
x220 = 4.0 * x66 * x96
x221 = x0 * (4.0 * bx * x0 * x200 - x109 * x220 - x117 - x37 * x69)
x222 = -x96
x223 = 2.0 * x222**2
x224 = x222 * x67
x225 = 4.0 * x224
x226 = x0 * (x223 + x225 + x37)
x227 = -x206
x228 = x0 + 2.0 * x224
x229 = x222 * x228
x230 = 2.0 * x0 * x227 + 2.0 * x229
x231 = x0 * (x12 * (-bx * (x222 * x230 + x226) + x12 + x225) + x198 * x217 - x221)
x232 = x0 * (x134 + x220)
x233 = x0 * (x198 * x209 + x232)
x234 = ax * x102 + ax * x103 * x92 - x13 * x94
x235 = x20 + x8
x236 = -x12 * (bx * x59 - 2.0) + x235
x237 = -x12 * x15 + x236
x238 = x127 * x3
x239 = x147 * x55
x240 = ax * (x157 + x239)
x241 = -x13 * (x240 + x53 + x75)
x242 = -ax * x155 + x140 * x149 + x241
x243 = -x234
x244 = -x235
x245 = x109 * x19
x246 = x173 + x177 * x56
x247 = -ax * x168 + x13 * (-ax * x246 + x0 + x170) + 2.0 * x140 * x181
x248 = x0 * x247
x249 = 2.0 * x159 * x55 + x183
x250 = x249 * x85
x251 = x3 * x90
x252 = -x140 * x162 + x241
x253 = x0 * x240
x254 = x107 * x3
x255 = ax * (x12 * (x12 * x156 + x158 + x239) + x249 * x88)
x256 = x175 * x56
x257 = x12 * x174
x258 = x0 * x59
x259 = x103 * x19
x260 = x112 * x3
x261 = ax * x109 * x82 + ax * x116 - x13 * x84
x262 = -x261
x263 = x200 * x66
x264 = ax * (x207 + x263)
x265 = -x13 * (x264 + x64 + x76)
x266 = -ax * x205 + x194 * x201 + x265
x267 = -x194 * x203 + x265
x268 = x0 * x264
x269 = x226 + x230 * x67
x270 = -ax * x221 + x13 * (-ax * x269 + x0 + x223) + 2.0 * x194 * x217
x271 = x0 * x270
x272 = 2.0 * x209 * x66 + x232
x273 = x272 * x85
x274 = ax * (x12 * (x12 * x206 + x208 + x263) + x272 * x96)
x275 = x228 * x67
x276 = x12 * x227
# 60 item(s)
result[0, 0] = numpy.sum(
x80
* (
x12 * (-ax * x27 + ax * x32 + 2.0 * x47 + x52)
+ x3 * x46
+ x58 * x63
+ x63 * x69
- x72 * (-bx * (x12 * (x43 + x70 + x71) + x35 * x45) + 2.0 * x70 + x71)
)
)
result[0, 1] = numpy.sum(x91 * (x81 + x84 * x86 - x86 * x87))
result[0, 2] = numpy.sum(x97 * (x81 + x86 * x94 - x86 * x95))
result[0, 3] = numpy.sum(x107 * (x101 * x99 + x105 * x50 + x50 * x84 * x99))
result[0, 4] = numpy.sum(x113 * x88 * (x0 * (x47 + x52) + x103 * x108 + x108 * x109))
result[0, 5] = numpy.sum(x107 * (x101 * x115 + x115 * x50 * x94 + x118 * x50))
result[0, 6] = numpy.sum(x128 * (x119 * x121 * x84 + x119 * x123 + x121 * x125))
result[0, 7] = numpy.sum(x131 * (x109 * x121 * x99 - x121 * x130 - x129 * x99))
result[0, 8] = numpy.sum(x133 * (x103 * x115 * x121 - x115 * x129 - x121 * x132))
result[0, 9] = numpy.sum(x137 * (x121 * x134 * x94 + x121 * x136 + x123 * x134))
result[1, 0] = numpy.sum(x144 * (x138 + x139 * x84 - x139 * x87))
result[1, 1] = numpy.sum(x151 * (x147 * x148 + x147 * x31 * x84 + x149 * x31))
result[1, 2] = numpy.sum(x113 * x140 * x153)
result[1, 3] = numpy.sum(x151 * (x11 * x159 * x84 + x11 * x161 + x159 * x25))
result[1, 4] = numpy.sum(x164 * x96 * (-x11 * x162 + x147 * x163 - x147 * x26))
result[1, 5] = numpy.sum(x166 * (-x11 * x132 + x115 * x165 - x115 * x26))
result[1, 6] = numpy.sum(x186 * (-x15 * x184 + x182 + x184 * x84))
result[1, 7] = numpy.sum(x113 * x188 * x22)
result[1, 8] = numpy.sum(x190 * (-x115 * x162 + x115 * x189 - x132 * x147))
result[1, 9] = numpy.sum(
x110 * x193 * x55 * (x0 * (x109 * x12 + x135) + x103 * x191 + x16 * x191)
)
result[2, 0] = numpy.sum(x195 * (x138 + x139 * x94 - x139 * x95))
result[2, 1] = numpy.sum(x153 * x194 * x197)
result[2, 2] = numpy.sum(x151 * (x148 * x200 + x200 * x31 * x94 + x201 * x31))
result[2, 3] = numpy.sum(x202 * (-x11 * x130 + x163 * x99 - x26 * x99))
result[2, 4] = numpy.sum(x164 * x88 * (-x11 * x203 + x165 * x200 - x200 * x26))
result[2, 5] = numpy.sum(x151 * (x11 * x209 * x94 + x11 * x211 + x209 * x25))
result[2, 6] = numpy.sum(
x193 * x196 * x66 * (x0 * (x103 * x12 + x124) + x109 * x212 + x16 * x212)
)
result[2, 7] = numpy.sum(x190 * (-x130 * x200 + x200 * x213 - x203 * x99))
result[2, 8] = numpy.sum(x197 * x219 * x22)
result[2, 9] = numpy.sum(x186 * (-x15 * x233 + x231 + x233 * x94))
result[3, 0] = numpy.sum(x238 * (x234 * x59 + x237 * x93 + x59 * x84 * x93))
result[3, 1] = numpy.sum(x107 * (x19 * x240 * x84 + x19 * x242 + x235 * x240))
result[3, 2] = numpy.sum(x131 * (-x19 * x243 - x244 * x93 + x245 * x93))
result[3, 3] = numpy.sum(x251 * (-x15 * x250 + x248 + x250 * x84))
result[3, 4] = numpy.sum(
x113 * x3 * (x0 * (ax * x179 + x252) + x109 * x253 + x16 * x253)
)
result[3, 5] = numpy.sum(x254 * (x115 * x16 * x93 - x115 * x243 - x132 * x93))
result[3, 6] = numpy.sum(
x80
* (
x12 * (ax * x160 - ax * x180 + x178 * x72 + x252)
+ x247 * x88
+ x255 * x69
+ x255 * x7
- x72 * (-bx * (x12 * (x176 + x256 + x257) + x169 * x246) + 2.0 * x256 + x257)
)
)
result[3, 7] = numpy.sum(x97 * (x122 * x250 + x248 - x250 * x95))
result[3, 8] = numpy.sum(x107 * (x115 * x122 * x240 + x115 * x242 + x118 * x240))
result[3, 9] = numpy.sum(x137 * (x122 * x134 * x93 + x134 * x234 + x136 * x93))
result[4, 0] = numpy.sum(
x141 * x192 * x3 * x66 * (x0 * (x12 * x16 + x236) + x103 * x258 + x109 * x258)
)
result[4, 1] = numpy.sum(x202 * (-x147 * x244 + x147 * x245 - x162 * x19))
result[4, 2] = numpy.sum(x166 * (-x19 * x203 - x200 * x244 + x200 * x259))
result[4, 3] = numpy.sum(x188 * x194 * x260 * x78)
result[4, 4] = numpy.sum(x164 * x3 * (-x147 * x203 - x162 * x200 + x189 * x200))
result[4, 5] = numpy.sum(x141 * x219 * x260)
result[4, 6] = numpy.sum(x195 * (x122 * x184 + x182 - x184 * x95))
result[4, 7] = numpy.sum(x151 * (x122 * x159 * x200 + x159 * x201 + x161 * x200))
result[4, 8] = numpy.sum(x151 * (x122 * x147 * x209 + x147 * x211 + x149 * x209))
result[4, 9] = numpy.sum(x144 * (x122 * x233 + x231 - x233 * x87))
result[5, 0] = numpy.sum(x238 * (x237 * x83 + x261 * x59 + x59 * x83 * x94))
result[5, 1] = numpy.sum(x133 * (-x19 * x262 - x244 * x83 + x259 * x83))
result[5, 2] = numpy.sum(x107 * (x19 * x264 * x94 + x19 * x266 + x235 * x264))
result[5, 3] = numpy.sum(x254 * (-x130 * x83 + x213 * x83 - x262 * x99))
result[5, 4] = numpy.sum(
x196 * x260 * (x0 * (ax * x215 + x267) + x103 * x268 + x16 * x268)
)
result[5, 5] = numpy.sum(x251 * (-x15 * x273 + x271 + x273 * x94))
result[5, 6] = numpy.sum(x128 * (x119 * x122 * x83 + x119 * x261 + x125 * x83))
result[5, 7] = numpy.sum(x107 * (x105 * x264 + x122 * x264 * x99 + x266 * x99))
result[5, 8] = numpy.sum(x91 * (x122 * x273 + x271 - x273 * x87))
result[5, 9] = numpy.sum(
x80
* (
x12 * (ax * x210 - ax * x216 + x214 * x72 + x267)
+ x270 * x96
+ x274 * x58
+ x274 * x7
- x72 * (-bx * (x12 * (x229 + x275 + x276) + x222 * x269) + 2.0 * x275 + x276)
)
)
return result
[docs]
def kinetic3d_24(ax, da, A, bx, db, B):
"""Cartesian 3D (dg) kinetic energy integral.
Generated code; DO NOT modify by hand!"""
result = numpy.zeros((6, 15), dtype=float)
x0 = 2.0 * ax
x1 = 2.0 * bx
x2 = (x0 + x1) ** (-1.0)
x3 = (ax + bx) ** (-1.0)
x4 = -x3 * (ax * A[0] + bx * B[0])
x5 = -x4 - B[0]
x6 = -ax
x7 = -x4 - A[0]
x8 = x7**2
x9 = 2.0 * ax**2
x10 = -x6 - x9 * (x2 + x8)
x11 = ax * x3
x12 = bx * x11
x13 = numpy.exp(-x12 * (A[0] - B[0]) ** 2)
x14 = 1.772453850905516 * numpy.sqrt(x3)
x15 = x13 * x14
x16 = x15 * x5
x17 = x10 * x16
x18 = bx * x3
x19 = x0 * x18
x20 = x16 * x19 + x17
x21 = x15 * x7
x22 = x21 * (x10 + x19)
x23 = x2 * (x20 + x22)
x24 = x20 * x7
x25 = x15 * x2
x26 = x21 * x5
x27 = x25 + x26
x28 = x10 * x25
x29 = x19 * x27 + x24 + x28
x30 = x29 * x5
x31 = x2 * (x16 + x21)
x32 = x27 * x5
x33 = x31 + x32
x34 = x1 * x33 - x21
x35 = x11 * x34
x36 = x23 + x30 + x35
x37 = x36 * x5
x38 = x36 * x7
x39 = 3.0 * x28
x40 = 4.0 * x12
x41 = x20 * x5
x42 = x15 * x5**2
x43 = x25 + x42
x44 = -x15
x45 = x11 * (x1 * x43 + x44)
x46 = x41 + x45
x47 = x2 * (2.0 * x24 + x27 * x40 + x39 + x46)
x48 = 3.0 * x25
x49 = 2.0 * x26
x50 = x2 * (x42 + x48 + x49)
x51 = x33 * x5
x52 = x50 + x51
x53 = 2.0 * x25
x54 = 2.0 * bx * x52 - x49 - x53
x55 = x0 * x3
x56 = x33 * x7
x57 = x50 + x56
x58 = x18 * (2.0 * ax * x57 - x43)
x59 = x29 * x7
x60 = x27 * x7
x61 = x31 + x60
x62 = x0 * x61 - x16
x63 = x1 * x3
x64 = x38 + x47 + x58
x65 = 2.0 * x60
x66 = x2 * (4.0 * x31 + 2.0 * x32 + x65) + x5 * x57
x67 = (
-x11 * (-2.0 * bx * x66 + 2.0 * x31 + x65)
+ x2 * (4.0 * x23 + 2.0 * x30 + x34 * x55 + 2.0 * x59 + x62 * x63)
+ x5 * x64
)
x68 = 3.0 * x56
x69 = x2 * (5.0 * x50 + 2.0 * x51 + x68) + x5 * x66
x70 = numpy.exp(-x12 * (A[1] - B[1]) ** 2)
x71 = numpy.exp(-x12 * (A[2] - B[2]) ** 2)
x72 = 3.141592653589793 * x3 * x71
x73 = x70 * x72
x74 = -x3 * (ax * A[1] + bx * B[1])
x75 = -x74 - A[1]
x76 = x75**2
x77 = -x6 - x9 * (x2 + x76)
x78 = x69 * x73
x79 = -x3 * (ax * A[2] + bx * B[2])
x80 = -x79 - A[2]
x81 = x80**2
x82 = -x6 - x9 * (x2 + x81)
x83 = da * db
x84 = 0.009523809523809524 * x83
x85 = 5.916079783099616 * x84
x86 = -x74 - B[1]
x87 = x14 * x70
x88 = x86 * x87
x89 = x77 * x88
x90 = x19 * x88 + x89
x91 = x14 * x71
x92 = x67 * x73
x93 = x66 * x73
x94 = 0.06666666666666667 * x83
x95 = 2.23606797749979 * x94
x96 = -x79 - B[2]
x97 = x91 * x96
x98 = x82 * x97
x99 = x19 * x97 + x98
x100 = x2 * x87
x101 = x100 * x77
x102 = x86 * x90
x103 = x86**2 * x87
x104 = x100 + x103
x105 = -x87
x106 = x11 * (x1 * x104 + x105)
x107 = x102 + x106
x108 = x101 + x107
x109 = x57 * x91
x110 = 1.732050807568877
x111 = 0.1111111111111111 * x110 * x83
x112 = x73 * x96
x113 = 0.3333333333333333 * x83
x114 = x2 * x91
x115 = x114 * x82
x116 = x96 * x99
x117 = x91 * x96**2
x118 = x114 + x117
x119 = -x91
x120 = x11 * (x1 * x118 + x119)
x121 = x116 + x120
x122 = x115 + x121
x123 = x57 * x87
x124 = 2.0 * x100
x125 = x86 * (x104 + x124)
x126 = x108 * x86 + x11 * (x1 * x125 - 2.0 * x88) + x2 * (x40 * x88 + 2.0 * x89)
x127 = x61 * x91
x128 = x18 * x62 + x23 + x59
x129 = 2.0 * x114
x130 = x96 * (x118 + x129)
x131 = x11 * (x1 * x130 - 2.0 * x97) + x122 * x96 + x2 * (x40 * x97 + 2.0 * x98)
x132 = x61 * x87
x133 = x15 * x8 + x25
x134 = x18 * (x0 * x133 + x44) + x22 * x7 + x28
x135 = 3.0 * x100
x136 = 3.0 * x103 + x135
x137 = x125 * x86 + x136 * x2
x138 = x137 * x91
x139 = 3.0 * x101
x140 = (
x11 * (2.0 * bx * x137 - x136)
+ x126 * x86
+ x2 * (3.0 * x102 + 3.0 * x106 + x139)
)
x141 = 3.0 * x114
x142 = 3.0 * x117 + x141
x143 = x130 * x96 + x142 * x2
x144 = x143 * x87
x145 = 3.0 * x115
x146 = (
x11 * (2.0 * bx * x143 - x142)
+ x131 * x96
+ x2 * (3.0 * x116 + 3.0 * x120 + x145)
)
x147 = x75 * x87
x148 = x147 * (x19 + x77)
x149 = x5 * (x43 + x53)
x150 = 3.0 * x31 + 3.0 * x32
x151 = x2 * (x149 + x150) + x5 * x52
x152 = x28 + x46
x153 = x11 * (x1 * x149 - 2.0 * x16) + x152 * x5 + x2 * (x16 * x40 + 2.0 * x17)
x154 = x11 * x54 + x37 + x47
x155 = x73 * (
x11 * (2.0 * bx * x151 - x150)
+ x154 * x5
+ x2 * (x153 + 3.0 * x23 + 3.0 * x30 + 3.0 * x35)
)
x156 = x151 * x73
x157 = 10.2469507659596 * x84
x158 = x75 * x90
x159 = x147 * x86
x160 = x100 + x159
x161 = x101 + x158 + x160 * x19
x162 = x52 * x91
x163 = 3.872983346207417 * x94
x164 = x2 * (x148 + x90)
x165 = x161 * x86
x166 = x2 * (x147 + x88)
x167 = x160 * x86
x168 = x166 + x167
x169 = x1 * x168 - x147
x170 = x11 * x169
x171 = x164 + x165 + x170
x172 = x33 * x91
x173 = x110 * x113
x174 = 2.0 * x159
x175 = x2 * (x103 + x135 + x174)
x176 = x168 * x86
x177 = x175 + x176
x178 = x177 * x91
x179 = x2 * (x107 + x139 + 2.0 * x158 + x160 * x40)
x180 = x171 * x86
x181 = 2.0 * bx * x177 - x124 - x174
x182 = x11 * x181 + x179 + x180
x183 = 3.0 * x166 + 3.0 * x167
x184 = x177 * x86 + x2 * (x125 + x183)
x185 = x13 * x72
x186 = x185 * (
x11 * (2.0 * bx * x184 - x183)
+ x182 * x86
+ x2 * (x126 + 3.0 * x164 + 3.0 * x165 + 3.0 * x170)
)
x187 = x185 * x7
x188 = 3.141592653589793 * x13 * x3 * x70
x189 = x188 * x7
x190 = x80 * x91
x191 = x190 * (x19 + x82)
x192 = x73 * x80
x193 = x80 * x99
x194 = x190 * x96
x195 = x114 + x194
x196 = x115 + x19 * x195 + x193
x197 = x52 * x87
x198 = x2 * (x191 + x99)
x199 = x196 * x96
x200 = x2 * (x190 + x97)
x201 = x195 * x96
x202 = x200 + x201
x203 = x1 * x202 - x190
x204 = x11 * x203
x205 = x198 + x199 + x204
x206 = x33 * x87
x207 = 2.0 * x194
x208 = x2 * (x117 + x141 + x207)
x209 = x202 * x96
x210 = x208 + x209
x211 = x210 * x87
x212 = x2 * (x121 + x145 + 2.0 * x193 + x195 * x40)
x213 = x205 * x96
x214 = 2.0 * bx * x210 - x129 - x207
x215 = x11 * x214 + x212 + x213
x216 = 3.0 * x200 + 3.0 * x201
x217 = x2 * (x130 + x216) + x210 * x96
x218 = x188 * (
x11 * (2.0 * bx * x217 - x216)
+ x2 * (x131 + 3.0 * x198 + 3.0 * x199 + 3.0 * x204)
+ x215 * x96
)
x219 = x100 + x76 * x87
x220 = x101 + x148 * x75 + x18 * (x0 * x219 + x105)
x221 = 3.0 * x42 + x48
x222 = x149 * x5 + x2 * x221
x223 = x222 * x91
x224 = x11 * (2.0 * bx * x222 - x221) + x153 * x5 + x2 * (x39 + 3.0 * x41 + 3.0 * x45)
x225 = x160 * x75
x226 = x166 + x225
x227 = x226 * x91
x228 = x161 * x75
x229 = x0 * x226 - x88
x230 = x164 + x18 * x229 + x228
x231 = x168 * x75
x232 = x175 + x231
x233 = x232 * x91
x234 = x171 * x75
x235 = x18 * (2.0 * ax * x232 - x104)
x236 = x179 + x234 + x235
x237 = 2.0 * x225
x238 = x2 * (4.0 * x166 + 2.0 * x167 + x237) + x232 * x86
x239 = (
-x11 * (-2.0 * bx * x238 + 2.0 * x166 + x237)
+ x2 * (4.0 * x164 + 2.0 * x165 + x169 * x55 + 2.0 * x228 + x229 * x63)
+ x236 * x86
)
x240 = x185 * x239
x241 = x185 * x5
x242 = 3.0 * x231
x243 = x2 * (5.0 * x175 + 2.0 * x176 + x242) + x238 * x86
x244 = x185 * x243
x245 = x10 * x185
x246 = x15 * x232
x247 = x15 * x226
x248 = x143 * x15
x249 = x188 * x75
x250 = x15 * x177
x251 = x15 * x168
x252 = x15 * x210
x253 = x114 + x81 * x91
x254 = x115 + x18 * (x0 * x253 + x119) + x191 * x80
x255 = x222 * x87
x256 = x195 * x80
x257 = x200 + x256
x258 = x257 * x87
x259 = x196 * x80
x260 = x0 * x257 - x97
x261 = x18 * x260 + x198 + x259
x262 = x202 * x80
x263 = x208 + x262
x264 = x263 * x87
x265 = x205 * x80
x266 = x18 * (2.0 * ax * x263 - x118)
x267 = x212 + x265 + x266
x268 = x188 * x5
x269 = 2.0 * x256
x270 = x2 * (4.0 * x200 + 2.0 * x201 + x269) + x263 * x96
x271 = (
-x11 * (-2.0 * bx * x270 + 2.0 * x200 + x269)
+ x2 * (4.0 * x198 + 2.0 * x199 + x203 * x55 + 2.0 * x259 + x260 * x63)
+ x267 * x96
)
x272 = x188 * x271
x273 = x137 * x15
x274 = x15 * x257
x275 = x15 * x263
x276 = 3.0 * x262
x277 = x2 * (5.0 * x208 + 2.0 * x209 + x276) + x270 * x96
x278 = x188 * x277
# 90 item(s)
result[0, 0] = numpy.sum(
x85
* (
x73
* (
-x11 * (-2.0 * bx * x69 + 3.0 * x50 + x68)
+ x2 * (2.0 * x37 + 3.0 * x38 + 5.0 * x47 + x54 * x55 + 3.0 * x58)
+ x5 * x67
)
+ x77 * x78
+ x78 * x82
)
)
result[0, 1] = numpy.sum(x95 * (x66 * x90 * x91 + x82 * x86 * x93 + x86 * x92))
result[0, 2] = numpy.sum(x95 * (x66 * x87 * x99 + x77 * x93 * x96 + x92 * x96))
result[0, 3] = numpy.sum(x111 * (x104 * x109 * x82 + x104 * x64 * x91 + x108 * x109))
result[0, 4] = numpy.sum(
x113 * (x112 * x64 * x86 + x57 * x88 * x99 + x57 * x90 * x97)
)
result[0, 5] = numpy.sum(x111 * (x118 * x123 * x77 + x118 * x64 * x87 + x122 * x123))
result[0, 6] = numpy.sum(x95 * (x125 * x127 * x82 + x125 * x128 * x91 + x126 * x127))
result[0, 7] = numpy.sum(
x113 * (x104 * x128 * x97 + x104 * x61 * x99 + x108 * x61 * x97)
)
result[0, 8] = numpy.sum(
x113 * (x118 * x128 * x88 + x118 * x61 * x90 + x122 * x61 * x88)
)
result[0, 9] = numpy.sum(x95 * (x128 * x130 * x87 + x130 * x132 * x77 + x131 * x132))
result[0, 10] = numpy.sum(x85 * (x133 * x138 * x82 + x133 * x140 * x91 + x134 * x138))
result[0, 11] = numpy.sum(
x95 * (x125 * x133 * x99 + x125 * x134 * x97 + x126 * x133 * x97)
)
result[0, 12] = numpy.sum(
x111 * (x104 * x118 * x134 + x104 * x122 * x133 + x108 * x118 * x133)
)
result[0, 13] = numpy.sum(
x95 * (x130 * x133 * x90 + x130 * x134 * x88 + x131 * x133 * x88)
)
result[0, 14] = numpy.sum(x85 * (x133 * x144 * x77 + x133 * x146 * x87 + x134 * x144))
result[1, 0] = numpy.sum(x157 * (x148 * x151 * x91 + x155 * x75 + x156 * x75 * x82))
result[1, 1] = numpy.sum(x163 * (x154 * x160 * x91 + x160 * x162 * x82 + x161 * x162))
result[1, 2] = numpy.sum(
x163 * (x112 * x154 * x75 + x147 * x52 * x99 + x148 * x52 * x97)
)
result[1, 3] = numpy.sum(x113 * (x168 * x172 * x82 + x168 * x36 * x91 + x171 * x172))
result[1, 4] = numpy.sum(
x173 * (x160 * x33 * x99 + x160 * x36 * x97 + x161 * x33 * x97)
)
result[1, 5] = numpy.sum(
x113 * (x118 * x147 * x36 + x118 * x148 * x33 + x122 * x147 * x33)
)
result[1, 6] = numpy.sum(x163 * (x178 * x27 * x82 + x178 * x29 + x182 * x27 * x91))
result[1, 7] = numpy.sum(
x173 * (x168 * x27 * x99 + x168 * x29 * x97 + x171 * x27 * x97)
)
result[1, 8] = numpy.sum(
x173 * (x118 * x160 * x29 + x118 * x161 * x27 + x122 * x160 * x27)
)
result[1, 9] = numpy.sum(
x163 * (x130 * x147 * x29 + x130 * x148 * x27 + x131 * x147 * x27)
)
result[1, 10] = numpy.sum(x157 * (x184 * x187 * x82 + x184 * x22 * x91 + x186 * x7))
result[1, 11] = numpy.sum(
x163 * (x177 * x21 * x99 + x177 * x22 * x97 + x182 * x187 * x96)
)
result[1, 12] = numpy.sum(
x113 * (x118 * x168 * x22 + x118 * x171 * x21 + x122 * x168 * x21)
)
result[1, 13] = numpy.sum(
x163 * (x130 * x160 * x22 + x130 * x161 * x21 + x131 * x160 * x21)
)
result[1, 14] = numpy.sum(
x157 * (x143 * x147 * x22 + x143 * x148 * x21 + x146 * x189 * x75)
)
result[2, 0] = numpy.sum(x157 * (x151 * x191 * x87 + x155 * x80 + x156 * x77 * x80))
result[2, 1] = numpy.sum(
x163 * (x154 * x192 * x86 + x190 * x52 * x90 + x191 * x52 * x88)
)
result[2, 2] = numpy.sum(x163 * (x154 * x195 * x87 + x195 * x197 * x77 + x196 * x197))
result[2, 3] = numpy.sum(
x113 * (x104 * x190 * x36 + x104 * x191 * x33 + x108 * x190 * x33)
)
result[2, 4] = numpy.sum(
x173 * (x195 * x33 * x90 + x195 * x36 * x88 + x196 * x33 * x88)
)
result[2, 5] = numpy.sum(x113 * (x202 * x206 * x77 + x202 * x36 * x87 + x205 * x206))
result[2, 6] = numpy.sum(
x163 * (x125 * x190 * x29 + x125 * x191 * x27 + x126 * x190 * x27)
)
result[2, 7] = numpy.sum(
x173 * (x104 * x195 * x29 + x104 * x196 * x27 + x108 * x195 * x27)
)
result[2, 8] = numpy.sum(
x173 * (x202 * x27 * x90 + x202 * x29 * x88 + x205 * x27 * x88)
)
result[2, 9] = numpy.sum(x163 * (x211 * x27 * x77 + x211 * x29 + x215 * x27 * x87))
result[2, 10] = numpy.sum(
x157 * (x137 * x190 * x22 + x137 * x191 * x21 + x140 * x187 * x80)
)
result[2, 11] = numpy.sum(
x163 * (x125 * x195 * x22 + x125 * x196 * x21 + x126 * x195 * x21)
)
result[2, 12] = numpy.sum(
x113 * (x104 * x202 * x22 + x104 * x205 * x21 + x108 * x202 * x21)
)
result[2, 13] = numpy.sum(
x163 * (x189 * x215 * x86 + x21 * x210 * x90 + x210 * x22 * x88)
)
result[2, 14] = numpy.sum(x157 * (x189 * x217 * x77 + x217 * x22 * x87 + x218 * x7))
result[3, 0] = numpy.sum(x85 * (x219 * x223 * x82 + x219 * x224 * x91 + x220 * x223))
result[3, 1] = numpy.sum(x95 * (x149 * x227 * x82 + x149 * x230 * x91 + x153 * x227))
result[3, 2] = numpy.sum(
x95 * (x149 * x219 * x99 + x149 * x220 * x97 + x153 * x219 * x97)
)
result[3, 3] = numpy.sum(x111 * (x152 * x233 + x233 * x43 * x82 + x236 * x43 * x91))
result[3, 4] = numpy.sum(
x113 * (x152 * x226 * x97 + x226 * x43 * x99 + x230 * x43 * x97)
)
result[3, 5] = numpy.sum(
x111 * (x118 * x152 * x219 + x118 * x220 * x43 + x122 * x219 * x43)
)
result[3, 6] = numpy.sum(x95 * (x20 * x238 * x91 + x238 * x241 * x82 + x240 * x5))
result[3, 7] = numpy.sum(
x113 * (x16 * x232 * x99 + x20 * x232 * x97 + x236 * x241 * x96)
)
result[3, 8] = numpy.sum(
x113 * (x118 * x16 * x230 + x118 * x20 * x226 + x122 * x16 * x226)
)
result[3, 9] = numpy.sum(
x95 * (x130 * x16 * x220 + x130 * x20 * x219 + x131 * x16 * x219)
)
result[3, 10] = numpy.sum(
x85
* (
x10 * x244
+ x185
* (
-x11 * (-2.0 * bx * x243 + 3.0 * x175 + x242)
+ x2 * (5.0 * x179 + 2.0 * x180 + x181 * x55 + 3.0 * x234 + 3.0 * x235)
+ x239 * x86
)
+ x244 * x82
)
)
result[3, 11] = numpy.sum(x95 * (x15 * x238 * x99 + x238 * x245 * x96 + x240 * x96))
result[3, 12] = numpy.sum(
x111 * (x10 * x118 * x246 + x118 * x15 * x236 + x122 * x246)
)
result[3, 13] = numpy.sum(x95 * (x10 * x130 * x247 + x130 * x15 * x230 + x131 * x247))
result[3, 14] = numpy.sum(x85 * (x10 * x219 * x248 + x146 * x15 * x219 + x220 * x248))
result[4, 0] = numpy.sum(
x157 * (x147 * x191 * x222 + x148 * x190 * x222 + x192 * x224 * x75)
)
result[4, 1] = numpy.sum(
x163 * (x149 * x160 * x191 + x149 * x161 * x190 + x153 * x160 * x190)
)
result[4, 2] = numpy.sum(
x163 * (x147 * x149 * x196 + x147 * x153 * x195 + x148 * x149 * x195)
)
result[4, 3] = numpy.sum(
x113 * (x152 * x168 * x190 + x168 * x191 * x43 + x171 * x190 * x43)
)
result[4, 4] = numpy.sum(
x173 * (x152 * x160 * x195 + x160 * x196 * x43 + x161 * x195 * x43)
)
result[4, 5] = numpy.sum(
x113 * (x147 * x152 * x202 + x147 * x205 * x43 + x148 * x202 * x43)
)
result[4, 6] = numpy.sum(
x163 * (x16 * x177 * x191 + x177 * x190 * x20 + x182 * x241 * x80)
)
result[4, 7] = numpy.sum(
x173 * (x16 * x168 * x196 + x16 * x171 * x195 + x168 * x195 * x20)
)
result[4, 8] = numpy.sum(
x173 * (x16 * x160 * x205 + x16 * x161 * x202 + x160 * x20 * x202)
)
result[4, 9] = numpy.sum(
x163 * (x147 * x20 * x210 + x148 * x16 * x210 + x215 * x249 * x5)
)
result[4, 10] = numpy.sum(x157 * (x15 * x184 * x191 + x184 * x245 * x80 + x186 * x80))
result[4, 11] = numpy.sum(
x163 * (x10 * x195 * x250 + x15 * x182 * x195 + x196 * x250)
)
result[4, 12] = numpy.sum(
x113 * (x10 * x202 * x251 + x15 * x171 * x202 + x205 * x251)
)
result[4, 13] = numpy.sum(
x163 * (x10 * x160 * x252 + x15 * x160 * x215 + x161 * x252)
)
result[4, 14] = numpy.sum(x157 * (x10 * x217 * x249 + x148 * x15 * x217 + x218 * x75))
result[5, 0] = numpy.sum(x85 * (x224 * x253 * x87 + x253 * x255 * x77 + x254 * x255))
result[5, 1] = numpy.sum(
x95 * (x149 * x253 * x90 + x149 * x254 * x88 + x153 * x253 * x88)
)
result[5, 2] = numpy.sum(x95 * (x149 * x258 * x77 + x149 * x261 * x87 + x153 * x258))
result[5, 3] = numpy.sum(
x111 * (x104 * x152 * x253 + x104 * x254 * x43 + x108 * x253 * x43)
)
result[5, 4] = numpy.sum(
x113 * (x152 * x257 * x88 + x257 * x43 * x90 + x261 * x43 * x88)
)
result[5, 5] = numpy.sum(x111 * (x152 * x264 + x264 * x43 * x77 + x267 * x43 * x87))
result[5, 6] = numpy.sum(
x95 * (x125 * x16 * x254 + x125 * x20 * x253 + x126 * x16 * x253)
)
result[5, 7] = numpy.sum(
x113 * (x104 * x16 * x261 + x104 * x20 * x257 + x108 * x16 * x257)
)
result[5, 8] = numpy.sum(
x113 * (x16 * x263 * x90 + x20 * x263 * x88 + x267 * x268 * x86)
)
result[5, 9] = numpy.sum(x95 * (x20 * x270 * x87 + x268 * x270 * x77 + x272 * x5))
result[5, 10] = numpy.sum(x85 * (x10 * x253 * x273 + x140 * x15 * x253 + x254 * x273))
result[5, 11] = numpy.sum(x95 * (x10 * x125 * x274 + x125 * x15 * x261 + x126 * x274))
result[5, 12] = numpy.sum(
x111 * (x10 * x104 * x275 + x104 * x15 * x267 + x108 * x275)
)
result[5, 13] = numpy.sum(
x95 * (x10 * x188 * x270 * x86 + x15 * x270 * x90 + x272 * x86)
)
result[5, 14] = numpy.sum(
x85
* (
x10 * x278
+ x188
* (
-x11 * (-2.0 * bx * x277 + 3.0 * x208 + x276)
+ x2 * (5.0 * x212 + 2.0 * x213 + x214 * x55 + 3.0 * x265 + 3.0 * x266)
+ x271 * x96
)
+ x278 * x77
)
)
return result
[docs]
def kinetic3d_30(ax, da, A, bx, db, B):
"""Cartesian 3D (fs) kinetic energy integral.
Generated code; DO NOT modify by hand!"""
result = numpy.zeros((10, 1), dtype=float)
x0 = (ax + bx) ** (-1.0)
x1 = -x0 * (ax * A[0] + bx * B[0]) + A[0]
x2 = x1**2
x3 = ax * (x0 + 2.0 * x1**2)
x4 = bx * x0
x5 = 2.0 * x4
x6 = x5 + 1.0
x7 = -x3 + x6
x8 = -ax * x7
x9 = 2.0 * x2
x10 = 3.0 * x0
x11 = ax * (x10 + x9)
x12 = x3 - 1.0
x13 = ax * x0
x14 = x12 * x13
x15 = -x0 * (ax * A[1] + bx * B[1]) + A[1]
x16 = ax * (x0 + 2.0 * x15**2)
x17 = x16 - 1.0
x18 = 0.5 * x11
x19 = -x0 * (ax * A[2] + bx * B[2]) + A[2]
x20 = ax * (x0 + 2.0 * x19**2)
x21 = x20 - 1.0
x22 = ax * (x0 + x9)
x23 = x22 - 1.0
x24 = ax * x4
x25 = (
5.568327996831708
* da
* db
* numpy.sqrt(x0)
* numpy.exp(-x24 * ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2 + (A[2] - B[2]) ** 2))
)
x26 = 0.2581988897471611 * x0
x27 = x25 * x26
x28 = x0 * (x14 - x23 * x5 + x8 * x9)
x29 = x19**2
x30 = 2.0 * x29
x31 = ax * (x0 + x30)
x32 = x31 - 1.0
x33 = x0 * x22
x34 = -x16 + x6
x35 = x15 * x25
x36 = 0.2886751345948129
x37 = x35 * x36
x38 = x15**2
x39 = 2.0 * x38
x40 = ax * (x0 + x39)
x41 = x40 - 1.0
x42 = -x20 + x6
x43 = x25 * x36
x44 = x19 * x43
x45 = x13 * x17
x46 = -x34
x47 = ax * x46
x48 = x0 * (x39 * x47 - x41 * x5 + x45)
x49 = x0 * x40
x50 = x1 * x43
x51 = x13 * x21
x52 = -x42
x53 = ax * x52
x54 = x0 * (x30 * x53 - x32 * x5 + x51)
x55 = x0 * x31
x56 = ax * (x10 + x39)
x57 = 0.5 * x56
x58 = ax * (x10 + x30)
x59 = 0.5 * x58
# 10 item(s)
result[0, 0] = numpy.sum(
0.5
* x1
* x27
* (
2.0 * x0 * x8
+ x14
+ 2.0 * x17 * x18
+ 2.0 * x18 * x21
+ 2.0 * x2 * x8
- 2.0 * x23 * x4
- 2.0 * x4 * (x11 - 2.0)
)
)
result[1, 0] = numpy.sum(x37 * (x28 + x32 * x33 - x33 * x34))
result[2, 0] = numpy.sum(x44 * (x28 + x33 * x41 - x33 * x42))
result[3, 0] = numpy.sum(x50 * (x32 * x49 + x48 - x49 * x7))
result[4, 0] = numpy.sum(
x1 * x13 * x19 * x35 * (-6.0 * bx * x0 + x16 + x20 + x3 - 3.0)
)
result[5, 0] = numpy.sum(x50 * (x41 * x55 + x54 - x55 * x7))
result[6, 0] = numpy.sum(
0.5
* x26
* x35
* (
2.0 * x12 * x57
+ 2.0 * x13 * x46
+ 2.0 * x21 * x57
+ 2.0 * x38 * x47
- 2.0 * x4 * x41
- 2.0 * x4 * (x56 - 2.0)
+ x45
)
)
result[7, 0] = numpy.sum(x44 * (x23 * x49 - x42 * x49 + x48))
result[8, 0] = numpy.sum(x37 * (x23 * x55 - x34 * x55 + x54))
result[9, 0] = numpy.sum(
0.5
* x19
* x27
* (
2.0 * x12 * x59
+ 2.0 * x13 * x52
+ 2.0 * x17 * x59
+ 2.0 * x29 * x53
- 2.0 * x32 * x4
- 2.0 * x4 * (x58 - 2.0)
+ x51
)
)
return result
[docs]
def kinetic3d_31(ax, da, A, bx, db, B):
"""Cartesian 3D (fp) kinetic energy integral.
Generated code; DO NOT modify by hand!"""
result = numpy.zeros((10, 3), dtype=float)
x0 = (ax + bx) ** (-1.0)
x1 = x0 * (ax * A[0] + bx * B[0])
x2 = -x1
x3 = x2 + A[0]
x4 = -x3
x5 = 2.0 * x4**2
x6 = x0 + x5
x7 = ax * x6 - 1.0
x8 = x0 * x7
x9 = ax * x8
x10 = x2 + B[0]
x11 = 2.0 * x3
x12 = x10 * x11
x13 = x0 + x12
x14 = 2.0 * x0
x15 = bx * x14
x16 = x15 + 1.0
x17 = -ax * x6 + x16
x18 = -x17
x19 = ax * x3
x20 = 4.0 * x10
x21 = 2.0 * x3**2
x22 = ax * (x0 + x21)
x23 = x22 - 1.0
x24 = ax * x18 * x21 - x15 * x23
x25 = x10 * x15 - x10 * x7 + x15 * x3 - x3 * x7
x26 = ax * x0
x27 = -2.0 * bx * x0 * x13 + x12 * x18 + x8
x28 = -x27
x29 = -B[0]
x30 = -2.0 * x1 + A[0] + B[0]
x31 = x0 * x30 + x13 * x3
x32 = ax * x31
x33 = -x15 * (x1 + x29 + x32)
x34 = x0 * (ax * A[1] + bx * B[1])
x35 = -x34
x36 = x35 + A[1]
x37 = -x36
x38 = 2.0 * x37**2
x39 = ax * (x0 + x38)
x40 = x39 - 1.0
x41 = 3.0 * x0
x42 = x21 + x41
x43 = ax * (x0 * (x20 * x3 + x42) + x11 * x31)
x44 = x0 * (ax * A[2] + bx * B[2])
x45 = -x44
x46 = x45 + A[2]
x47 = -x46
x48 = 2.0 * x47**2
x49 = ax * (x0 + x48)
x50 = x49 - 1.0
x51 = -x10 * x4
x52 = 4.0 * x51
x53 = numpy.sqrt(x0)
x54 = bx * x26
x55 = -B[1]
x56 = -B[2]
x57 = (
5.568327996831708
* da
* db
* numpy.exp(-x54 * ((x29 + A[0]) ** 2 + (x55 + A[1]) ** 2 + (x56 + A[2]) ** 2))
)
x58 = x53 * x57
x59 = 3.872983346207417 * x58
x60 = 0.01666666666666667 * x0 * x59
x61 = x35 + B[1]
x62 = ax * x14
x63 = ax * x42
x64 = x24 + x9
x65 = -x0 * (x15 * (x63 - 2.0) + x17 * x62 - x64)
x66 = 2.0 * x46**2
x67 = ax * (x0 + x66)
x68 = x67 - 1.0
x69 = x0 * x63
x70 = x16 - x39
x71 = 0.03333333333333333 * x59
x72 = x3 * x71
x73 = x45 + B[2]
x74 = 2.0 * x36**2
x75 = ax * (x0 + x74)
x76 = x75 - 1.0
x77 = x16 - x49
x78 = x0 * (x19 * x27 - x25 * x26 + x33)
x79 = x0 * x32
x80 = 1.732050807568877 * x57
x81 = 0.1666666666666667 * x53 * x80
x82 = x36 * x81
x83 = 2.0 * x36
x84 = x61 * x83
x85 = x0 + x84
x86 = x0 * x40
x87 = -x70
x88 = -x15 * x85 + x84 * x87 + x86
x89 = 0.08333333333333333 * x0**1.5 * x80
x90 = x0 * x22
x91 = -x77
x92 = x0 * x64 + x87 * x90 + x90 * x91
x93 = x46 * x81
x94 = 2.0 * x46
x95 = x73 * x94
x96 = x0 + x95
x97 = x0 * x50
x98 = -x15 * x96 + x91 * x95 + x97
x99 = ax * x74 * x87 - x15 * x76
x100 = ax * x86 + x99
x101 = ax * x36
x102 = x15 * x36 + x15 * x61 - x36 * x40 - x40 * x61
x103 = -2.0 * x34 + A[1] + B[1]
x104 = x0 * x103 + x36 * x85
x105 = ax * x104
x106 = -x15 * (x105 + x34 + x55)
x107 = x0 * (x101 * x88 - x102 * x26 + x106)
x108 = x0 * x105
x109 = x3 * x81
x110 = x0 * x75
x111 = x0 * x100 + x110 * x18 + x110 * x91
x112 = x0 * x13
x113 = 0.5 * x58
x114 = x113 * x46
x115 = -x88
x116 = x0 * x85
x117 = -x98
x118 = x0 * x96
x119 = ax * x66 * x91 - x15 * x68
x120 = ax * x97 + x119
x121 = x0 * x67
x122 = x0 * x120 + x121 * x18 + x121 * x87
x123 = ax * x46
x124 = x15 * x46 + x15 * x73 - x46 * x50 - x50 * x73
x125 = -2.0 * x44 + A[2] + B[2]
x126 = x0 * x125 + x46 * x96
x127 = ax * x126
x128 = -x15 * (x127 + x44 + x56)
x129 = x0 * (x123 * x98 - x124 * x26 + x128)
x130 = x0 * x127
x131 = x41 + x74
x132 = ax * x131
x133 = -x0 * (-x100 + x15 * (x132 - 2.0) + x62 * x70)
x134 = x0 * x132
x135 = x36 * x71
x136 = ax * x41
x137 = 4.0 * x61
x138 = ax * (x0 * (x131 + x137 * x36) + x104 * x83)
x139 = -x37 * x61
x140 = 4.0 * x139
x141 = x41 + x66
x142 = ax * x141
x143 = -x0 * (-x120 + x15 * (x142 - 2.0) + x62 * x77)
x144 = x0 * x142
x145 = x46 * x71
x146 = 4.0 * x73
x147 = ax * (x0 * (x141 + x146 * x46) + x126 * x94)
x148 = -x47 * x73
x149 = 4.0 * x148
# 30 item(s)
result[0, 0] = numpy.sum(
-x60
* (
x0 * (-4.0 * ax * bx * x0 * x13 + x18 * x19 * x20 + x24 + 3.0 * x9)
- x11 * (x19 * x28 + x25 * x26 - x33)
+ x15
* (
-ax
* (x0 * (x41 + x5 + x52) - 2.0 * x4 * (x0 * x30 - x4 * (x0 + 2.0 * x51)))
+ x14
+ x52
)
+ x40 * x43
+ x43 * x50
)
)
result[0, 1] = numpy.sum(x61 * x72 * (ax * x0 * x42 * x70 - x65 - x68 * x69))
result[0, 2] = numpy.sum(x72 * x73 * (ax * x0 * x42 * x77 - x65 - x69 * x76))
result[1, 0] = numpy.sum(x82 * (ax * x0 * x31 * x70 - x68 * x79 - x78))
result[1, 1] = numpy.sum(-x89 * (x22 * x68 * x85 + x22 * x88 + x64 * x85))
result[1, 2] = numpy.sum(-x73 * x82 * x92)
result[2, 0] = numpy.sum(x93 * (ax * x0 * x31 * x77 - x76 * x79 - x78))
result[2, 1] = numpy.sum(-x61 * x92 * x93)
result[2, 2] = numpy.sum(-x89 * (x22 * x76 * x96 + x22 * x98 + x64 * x96))
result[3, 0] = numpy.sum(-x89 * (x100 * x13 + x13 * x68 * x75 + x27 * x75))
result[3, 1] = numpy.sum(x109 * (ax * x0 * x104 * x17 - x107 - x108 * x68))
result[3, 2] = numpy.sum(-x109 * x111 * x73)
result[4, 0] = numpy.sum(x101 * x114 * (x0 * x28 - x112 * x87 - x112 * x91))
result[4, 1] = numpy.sum(x114 * x19 * (x0 * x115 - x116 * x18 - x116 * x91))
result[4, 2] = numpy.sum(x113 * x19 * x36 * (x0 * x117 - x118 * x18 - x118 * x87))
result[5, 0] = numpy.sum(-x89 * (x120 * x13 + x13 * x67 * x76 + x27 * x67))
result[5, 1] = numpy.sum(-x109 * x122 * x61)
result[5, 2] = numpy.sum(x109 * (ax * x0 * x126 * x17 - x129 - x130 * x76))
result[6, 0] = numpy.sum(x10 * x135 * (ax * x0 * x131 * x17 - x133 - x134 * x68))
result[6, 1] = numpy.sum(
-x60
* (
x0 * (-4.0 * ax * bx * x0 * x85 + x101 * x137 * x87 + x136 * x40 + x99)
+ x138 * x50
+ x138 * x7
+ x15
* (
-ax
* (
x0 * (x140 + x38 + x41)
- 2.0 * x37 * (x0 * x103 - x37 * (x0 + 2.0 * x139))
)
+ x14
+ x140
)
- x83 * (x101 * x115 + x102 * x26 - x106)
)
)
result[6, 2] = numpy.sum(x135 * x73 * (ax * x0 * x131 * x77 - x133 - x134 * x23))
result[7, 0] = numpy.sum(-x10 * x111 * x93)
result[7, 1] = numpy.sum(x93 * (ax * x0 * x104 * x77 - x107 - x108 * x23))
result[7, 2] = numpy.sum(-x89 * (x100 * x96 + x23 * x75 * x96 + x75 * x98))
result[8, 0] = numpy.sum(-x10 * x122 * x82)
result[8, 1] = numpy.sum(-x89 * (x120 * x85 + x23 * x67 * x85 + x67 * x88))
result[8, 2] = numpy.sum(x82 * (ax * x0 * x126 * x70 - x129 - x130 * x23))
result[9, 0] = numpy.sum(x10 * x145 * (ax * x0 * x141 * x17 - x143 - x144 * x76))
result[9, 1] = numpy.sum(x145 * x61 * (ax * x0 * x141 * x70 - x143 - x144 * x23))
result[9, 2] = numpy.sum(
-x60
* (
x0 * (-4.0 * ax * bx * x0 * x96 + x119 + x123 * x146 * x91 + x136 * x50)
+ x147 * x40
+ x147 * x7
+ x15
* (
-ax
* (
x0 * (x149 + x41 + x48)
- 2.0 * x47 * (x0 * x125 - x47 * (x0 + 2.0 * x148))
)
+ x14
+ x149
)
- x94 * (x117 * x123 + x124 * x26 - x128)
)
)
return result
[docs]
def kinetic3d_32(ax, da, A, bx, db, B):
"""Cartesian 3D (fd) kinetic energy integral.
Generated code; DO NOT modify by hand!"""
result = numpy.zeros((10, 6), dtype=float)
x0 = (ax + bx) ** (-1.0)
x1 = x0 * (ax * A[0] + bx * B[0])
x2 = -x1
x3 = x2 + A[0]
x4 = -x3
x5 = 2.0 * x4**2
x6 = x0 + x5
x7 = ax * x6 - 1.0
x8 = x0 * x7
x9 = 3.0 * x8
x10 = x2 + B[0]
x11 = x10 * x3
x12 = 2.0 * x11
x13 = x0 + x12
x14 = 2.0 * x0
x15 = bx * x14
x16 = x15 + 1.0
x17 = -ax * x6 + x16
x18 = -x17
x19 = 4.0 * x11
x20 = x18 * x19
x21 = 2.0 * x10**2
x22 = x0 + x21
x23 = -x14 * (bx * x22 - 1.0) + x18 * x21
x24 = x10 * x15 - x10 * x7 + x15 * x3 - x3 * x7
x25 = -x0 * x24
x26 = -2.0 * bx * x0 * x13 + x12 * x18 + x8
x27 = -x26
x28 = x10 * x27
x29 = -2.0 * x1 + A[0] + B[0]
x30 = x0 * x29
x31 = x10 * x13
x32 = x30 + x31
x33 = x14 * (-bx * x32 - x1 + A[0])
x34 = x25 - x28 + x33
x35 = ax * x3
x36 = -x10
x37 = 2.0 * x36**2
x38 = 3.0 * x0
x39 = x36 * x4
x40 = 4.0 * x39
x41 = x38 + x40
x42 = -x0 * x29
x43 = x0 + 2.0 * x39
x44 = x36 * x43
x45 = 2.0 * x4
x46 = x0 * (x37 + x41) + x45 * (x42 + x44)
x47 = (
ax * x0 * (-4.0 * bx * x0 * x13 + x20 + x23 + x9)
+ x15 * (-ax * x46 + x0 + x37)
+ 2.0 * x34 * x35
)
x48 = ax * x25
x49 = -B[0]
x50 = x13 * x3
x51 = x30 + x50
x52 = ax * x51
x53 = -x15 * (x1 + x49 + x52)
x54 = -x27 * x35 + x53
x55 = x0 * (ax * A[1] + bx * B[1])
x56 = -x55
x57 = x56 + A[1]
x58 = -x57
x59 = 2.0 * x58**2
x60 = ax * (x0 + x59)
x61 = x60 - 1.0
x62 = 2.0 * x3
x63 = x0 * (x19 + x21 + x38) + x32 * x62
x64 = ax * (x14 * (2.0 * x30 + x31 + x50) + x3 * x63)
x65 = x0 * (ax * A[2] + bx * B[2])
x66 = -x65
x67 = x66 + A[2]
x68 = -x67
x69 = 2.0 * x68**2
x70 = ax * (x0 + x69)
x71 = x70 - 1.0
x72 = x4 * x43
x73 = 2.0 * x42
x74 = 2.23606797749979
x75 = numpy.sqrt(x0)
x76 = ax * x0
x77 = bx * x76
x78 = -B[1]
x79 = -B[2]
x80 = (
5.568327996831708
* da
* db
* numpy.exp(-x77 * ((x49 + A[0]) ** 2 + (x78 + A[1]) ** 2 + (x79 + A[2]) ** 2))
)
x81 = x75 * x80
x82 = 0.01666666666666667 * x81
x83 = x0 * x74 * x82
x84 = 2.0 * x3**2
x85 = ax * (x0 + x84)
x86 = x85 - 1.0
x87 = ax * x18
x88 = -x15 * x86 + x84 * x87
x89 = x48 + x54
x90 = x0 * (
x0 * (-4.0 * ax * bx * x0 * x13 + ax * x20 + ax * x9 + x88)
+ x15 * (-ax * (x0 * (x41 + x5) + x45 * (x42 + x72)) + x14 + x40)
+ x62 * x89
)
x91 = 2.0 * x67**2
x92 = ax * (x0 + x91)
x93 = x92 - 1.0
x94 = x38 + x84
x95 = x76 * (x0 * (x19 + x94) + x51 * x62)
x96 = x16 - x60
x97 = x56 + B[1]
x98 = 3.872983346207417
x99 = x82 * x98
x100 = x97 * x99
x101 = 2.0 * x57**2
x102 = ax * (x0 + x101)
x103 = x102 - 1.0
x104 = x16 - x70
x105 = x66 + B[2]
x106 = x105 * x99
x107 = 2.0 * x97**2
x108 = x0 + x107
x109 = ax * x14
x110 = ax * x94
x111 = ax * x8 + x88
x112 = x111 - x15 * (x110 - 2.0)
x113 = -x109 * x17 + x112
x114 = x0 * x61
x115 = -x96
x116 = x107 * x115 - x14 * (bx * x108 - 1.0)
x117 = x114 + x116
x118 = x0**1.5
x119 = x118 * x80
x120 = 0.01666666666666667 * x119 * x74
x121 = x120 * x3
x122 = x0 * x110
x123 = -x104
x124 = x105 * x81
x125 = 0.03333333333333333 * x98
x126 = 2.0 * x105**2
x127 = x0 + x126
x128 = x0 * x71
x129 = x123 * x126 - x14 * (bx * x127 - 1.0)
x130 = x128 + x129
x131 = x0 * x47
x132 = x63 * x76
x133 = 0.08333333333333333 * x80
x134 = x133 * x75
x135 = x134 * x57
x136 = x57 * x97
x137 = 2.0 * x136
x138 = x0 + x137
x139 = x0 * x24
x140 = -ax * x139 + x26 * x35 + x53
x141 = x114 + x115 * x137 - x138 * x15
x142 = 1.732050807568877
x143 = x118 * x133
x144 = x142 * x143
x145 = x124 * x57
x146 = x0 * x52
x147 = 0.1666666666666667 * x142
x148 = x147 * (x0 * x89 + x115 * x146 + x123 * x146)
x149 = -2.0 * x55 + A[1] + B[1]
x150 = x0 * x149
x151 = x138 * x97
x152 = x150 + x151
x153 = x15 * x57 + x15 * x97 - x57 * x61 - x61 * x97
x154 = x0 * x153
x155 = x14 * (-bx * x152 - x55 + A[1])
x156 = x141 * x97 - x154 + x155
x157 = -x111
x158 = -x141
x159 = x123 * x138
x160 = x105 * x144
x161 = -x130
x162 = x143 * x57
x163 = x134 * x67
x164 = x81 * x97
x165 = x164 * x67
x166 = x105 * x67
x167 = 2.0 * x166
x168 = x0 + x167
x169 = x123 * x167 + x128 - x15 * x168
x170 = -x117
x171 = x143 * x67
x172 = -x169
x173 = x115 * x168
x174 = x144 * x97
x175 = -2.0 * x65 + A[2] + B[2]
x176 = x0 * x175
x177 = x105 * x168
x178 = x176 + x177
x179 = x105 * x15 - x105 * x71 + x15 * x67 - x67 * x71
x180 = x0 * x179
x181 = x14 * (-bx * x178 - x65 + A[2])
x182 = x105 * x169 - x180 + x181
x183 = ax * x115
x184 = x101 * x183 - x103 * x15
x185 = ax * x114 + x184
x186 = x10 * x26 - x139 + x33
x187 = ax * x57
x188 = x138 * x57
x189 = x150 + x188
x190 = ax * x189
x191 = -x15 * (x190 + x55 + x78)
x192 = -ax * x154 + x141 * x187 + x191
x193 = -x185
x194 = x102 * x123
x195 = x38 * x61
x196 = 4.0 * x136
x197 = -x153
x198 = x0 * x197
x199 = x158 * x97
x200 = x155 + x198 - x199
x201 = -x97
x202 = 2.0 * x201**2
x203 = x201 * x58
x204 = 4.0 * x203
x205 = x204 + x38
x206 = -x149
x207 = x0 * x206
x208 = x0 + 2.0 * x203
x209 = x201 * x208
x210 = 2.0 * x58
x211 = x0 * (x202 + x205) + x210 * (x207 + x209)
x212 = (
x15 * (-ax * x211 + x0 + x202)
+ 2.0 * x187 * x200
+ x76 * (-4.0 * bx * x0 * x138 + x115 * x196 + x116 + x195)
)
x213 = x0 * x212
x214 = 2.0 * x57
x215 = x0 * (x107 + x196 + x38) + x152 * x214
x216 = x215 * x76
x217 = x134 * x3
x218 = -x158 * x187 + x191
x219 = ax * x198 + x218
x220 = x0 * x190
x221 = x0 * x219 + x123 * x220 + x18 * x220
x222 = x147 * x3
x223 = x143 * x3
x224 = x0 * x32
x225 = x147 * x81
x226 = x225 * x67
x227 = ax * x67
x228 = 0.25 * x119
x229 = x0 * x152
x230 = x168 * x18
x231 = -x179
x232 = x0 * x231
x233 = x105 * x172
x234 = x181 + x232 - x233
x235 = x0 * x178
x236 = ax * x123
x237 = -x15 * x93 + x236 * x91
x238 = ax * x128 + x237
x239 = -x238
x240 = x115 * x92
x241 = x168 * x67
x242 = x176 + x241
x243 = ax * x242
x244 = -x15 * (x243 + x65 + x79)
x245 = -ax * x180 + x169 * x227 + x244
x246 = x18 * x92
x247 = -x172 * x227 + x244
x248 = ax * x232 + x247
x249 = x0 * x243
x250 = x0 * x248 + x115 * x249 + x18 * x249
x251 = x38 * x71
x252 = 4.0 * x166
x253 = -x105
x254 = 2.0 * x253**2
x255 = x253 * x68
x256 = 4.0 * x255
x257 = x256 + x38
x258 = -x175
x259 = x0 * x258
x260 = x0 + 2.0 * x255
x261 = x253 * x260
x262 = 2.0 * x68
x263 = x0 * (x254 + x257) + x262 * (x259 + x261)
x264 = (
x15 * (-ax * x263 + x0 + x254)
+ 2.0 * x227 * x234
+ x76 * (-4.0 * bx * x0 * x168 + x123 * x252 + x129 + x251)
)
x265 = x0 * x264
x266 = 2.0 * x67
x267 = x0 * (x126 + x252 + x38) + x178 * x266
x268 = x267 * x76
x269 = x101 + x38
x270 = ax * x269
x271 = -x15 * (x270 - 2.0) + x185
x272 = -x109 * x96 + x271
x273 = x23 + x8
x274 = x120 * x57
x275 = x208 * x58
x276 = x0 * (
x0 * (-4.0 * ax * bx * x0 * x138 + ax * x195 + x183 * x196 + x184)
+ x15 * (-ax * (x0 * (x205 + x59) + x210 * (x207 + x275)) + x14 + x204)
+ x214 * x219
)
x277 = x76 * (x0 * (x196 + x269) + x189 * x214)
x278 = x10 * x99
x279 = x0 * x270
x280 = x10 * x125
x281 = ax * (x14 * (x14 * x149 + x151 + x188) + x215 * x57)
x282 = x14 * x206
x283 = -x273
x284 = x10 * x225
x285 = x10 * x144
x286 = x38 + x91
x287 = ax * x286
x288 = -x15 * (x287 - 2.0) + x238
x289 = -x104 * x109 + x288
x290 = x120 * x67
x291 = x0 * x287
x292 = x260 * x68
x293 = x0 * (
x0 * (-4.0 * ax * bx * x0 * x168 + ax * x251 + x236 * x252 + x237)
+ x15 * (-ax * (x0 * (x257 + x69) + x262 * (x259 + x292)) + x14 + x256)
+ x248 * x266
)
x294 = x76 * (x0 * (x252 + x286) + x242 * x266)
x295 = ax * (x14 * (x14 * x175 + x177 + x241) + x267 * x67)
x296 = x14 * x258
# 60 item(s)
result[0, 0] = numpy.sum(
x83
* (
x14 * (-ax * x28 + ax * x33 + 2.0 * x48 + x54)
- x15 * (-ax * (x14 * (x44 + x72 + x73) + x4 * x46) + 2.0 * x44 + x73)
+ x3 * x47
+ x61 * x64
+ x64 * x71
)
)
result[0, 1] = numpy.sum(x100 * (x90 + x93 * x95 - x95 * x96))
result[0, 2] = numpy.sum(x106 * (x103 * x95 - x104 * x95 + x90))
result[0, 3] = numpy.sum(x121 * (x108 * x110 * x93 + x108 * x113 + x110 * x117))
result[0, 4] = numpy.sum(
x124 * x125 * x3 * x97 * (x0 * (x112 + x14 * x87) + x115 * x122 + x122 * x123)
)
result[0, 5] = numpy.sum(x121 * (x103 * x110 * x127 + x110 * x130 + x113 * x127))
result[1, 0] = numpy.sum(x135 * (x131 + x132 * x93 - x132 * x96))
result[1, 1] = numpy.sum(x144 * (x138 * x140 + x138 * x52 * x93 + x141 * x52))
result[1, 2] = numpy.sum(x145 * x148)
result[1, 3] = numpy.sum(x143 * (x111 * x152 + x152 * x85 * x93 + x156 * x85))
result[1, 4] = numpy.sum(x160 * (-x138 * x157 - x158 * x85 + x159 * x85))
result[1, 5] = numpy.sum(x162 * (x115 * x127 * x85 - x127 * x157 - x161 * x85))
result[2, 0] = numpy.sum(x163 * (x103 * x132 - x104 * x132 + x131))
result[2, 1] = numpy.sum(x148 * x165)
result[2, 2] = numpy.sum(x144 * (x103 * x168 * x52 + x140 * x168 + x169 * x52))
result[2, 3] = numpy.sum(x171 * (x108 * x123 * x85 - x108 * x157 - x170 * x85))
result[2, 4] = numpy.sum(x174 * (-x157 * x168 - x172 * x85 + x173 * x85))
result[2, 5] = numpy.sum(x143 * (x103 * x178 * x85 + x111 * x178 + x182 * x85))
result[3, 0] = numpy.sum(x143 * (x102 * x186 + x102 * x32 * x93 + x185 * x32))
result[3, 1] = numpy.sum(x144 * (x13 * x190 * x93 + x13 * x192 + x190 * x26))
result[3, 2] = numpy.sum(x160 * (-x102 * x27 - x13 * x193 + x13 * x194))
result[3, 3] = numpy.sum(x217 * (-x17 * x216 + x213 + x216 * x93))
result[3, 4] = numpy.sum(x124 * x221 * x222)
result[3, 5] = numpy.sum(x223 * (x102 * x127 * x18 - x102 * x161 - x127 * x193))
result[4, 0] = numpy.sum(x187 * x226 * (x0 * x34 + x115 * x224 + x123 * x224))
result[4, 1] = numpy.sum(x227 * x228 * (-x13 * x158 + x13 * x159 - x138 * x27))
result[4, 2] = numpy.sum(x187 * x228 * (-x13 * x172 + x13 * x173 - x168 * x27))
result[4, 3] = numpy.sum(x226 * x35 * (x0 * x200 + x123 * x229 + x18 * x229))
result[4, 4] = numpy.sum(x228 * x35 * (-x138 * x172 + x138 * x230 - x158 * x168))
result[4, 5] = numpy.sum(x225 * x35 * x57 * (x0 * x234 + x115 * x235 + x18 * x235))
result[5, 0] = numpy.sum(x143 * (x103 * x32 * x92 + x186 * x92 + x238 * x32))
result[5, 1] = numpy.sum(x174 * (-x13 * x239 + x13 * x240 - x27 * x92))
result[5, 2] = numpy.sum(x144 * (x103 * x13 * x243 + x13 * x245 + x243 * x26))
result[5, 3] = numpy.sum(x223 * (-x108 * x239 + x108 * x246 - x170 * x92))
result[5, 4] = numpy.sum(x164 * x222 * x250)
result[5, 5] = numpy.sum(x217 * (x103 * x268 - x17 * x268 + x265))
result[6, 0] = numpy.sum(x274 * (x22 * x270 * x93 + x22 * x272 + x270 * x273))
result[6, 1] = numpy.sum(x278 * (-x17 * x277 + x276 + x277 * x93))
result[6, 2] = numpy.sum(
x145 * x280 * (x0 * (x109 * x115 + x271) + x123 * x279 + x18 * x279)
)
result[6, 3] = numpy.sum(
x83
* (
x14 * (ax * x155 - ax * x199 + x109 * x197 + x218)
- x15 * (-ax * (x14 * (x209 + x275 + x282) + x211 * x58) + 2.0 * x209 + x282)
+ x212 * x57
+ x281 * x7
+ x281 * x71
)
)
result[6, 4] = numpy.sum(x106 * (-x104 * x277 + x276 + x277 * x86))
result[6, 5] = numpy.sum(x274 * (x127 * x270 * x86 + x127 * x272 + x130 * x270))
result[7, 0] = numpy.sum(x171 * (-x102 * x283 - x193 * x22 + x194 * x22))
result[7, 1] = numpy.sum(x221 * x284 * x67)
result[7, 2] = numpy.sum(x285 * (-x102 * x172 + x102 * x230 - x168 * x193))
result[7, 3] = numpy.sum(x163 * (-x104 * x216 + x213 + x216 * x86))
result[7, 4] = numpy.sum(x144 * (x168 * x190 * x86 + x168 * x192 + x169 * x190))
result[7, 5] = numpy.sum(x143 * (x102 * x178 * x86 + x102 * x182 + x178 * x185))
result[8, 0] = numpy.sum(x162 * (-x22 * x239 + x22 * x240 - x283 * x92))
result[8, 1] = numpy.sum(x285 * (-x138 * x239 + x138 * x246 - x158 * x92))
result[8, 2] = numpy.sum(x250 * x284 * x57)
result[8, 3] = numpy.sum(x143 * (x152 * x238 + x152 * x86 * x92 + x156 * x92))
result[8, 4] = numpy.sum(x144 * (x138 * x243 * x86 + x138 * x245 + x141 * x243))
result[8, 5] = numpy.sum(x135 * (x265 + x268 * x86 - x268 * x96))
result[9, 0] = numpy.sum(x290 * (x103 * x22 * x287 + x22 * x289 + x273 * x287))
result[9, 1] = numpy.sum(
x165 * x280 * (x0 * (x109 * x123 + x288) + x115 * x291 + x18 * x291)
)
result[9, 2] = numpy.sum(x278 * (x103 * x294 - x17 * x294 + x293))
result[9, 3] = numpy.sum(x290 * (x108 * x287 * x86 + x108 * x289 + x117 * x287))
result[9, 4] = numpy.sum(x100 * (x293 + x294 * x86 - x294 * x96))
result[9, 5] = numpy.sum(
x83
* (
x14 * (ax * x181 - ax * x233 + x109 * x231 + x247)
- x15 * (-ax * (x14 * (x261 + x292 + x296) + x263 * x68) + 2.0 * x261 + x296)
+ x264 * x67
+ x295 * x61
+ x295 * x7
)
)
return result
[docs]
def kinetic3d_33(ax, da, A, bx, db, B):
"""Cartesian 3D (ff) kinetic energy integral.
Generated code; DO NOT modify by hand!"""
result = numpy.zeros((10, 10), dtype=float)
x0 = (ax + bx) ** (-1.0)
x1 = x0 * (ax * A[0] + bx * B[0])
x2 = -x1
x3 = x2 + A[0]
x4 = -x3
x5 = 2.0 * x4**2
x6 = x0 + x5
x7 = ax * x6 - 1.0
x8 = x0 * x7
x9 = 3.0 * x8
x10 = x2 + B[0]
x11 = 2.0 * x3
x12 = x10 * x11
x13 = x0 + x12
x14 = 2.0 * x0
x15 = bx * x14
x16 = x15 + 1.0
x17 = -ax * x6 + x16
x18 = -x17
x19 = 4.0 * x10
x20 = x19 * x3
x21 = 2.0 * x10**2
x22 = x0 + x21
x23 = -x14 * (bx * x22 - 1.0) + x18 * x21
x24 = 4.0 * bx * x0 * x13 - x18 * x20 - x23 - x9
x25 = -x10
x26 = 2.0 * x25**2
x27 = 3.0 * x0
x28 = x25 * x4
x29 = 4.0 * x28
x30 = x27 + x29
x31 = x0 * (x26 + x30)
x32 = -2.0 * x1 + A[0] + B[0]
x33 = -x0 * x32
x34 = x0 + 2.0 * x28
x35 = x25 * x34
x36 = x33 + x35
x37 = 2.0 * x36
x38 = x14 + x29
x39 = -bx * (x25 * x37 + x31) + x38
x40 = ax * x0
x41 = 4.0 * x40
x42 = x10 * x15 - x10 * x7 + x15 * x3 - x3 * x7
x43 = -x0 * x42
x44 = -2.0 * bx * x0 * x13 + x12 * x18 + x8
x45 = -x44
x46 = x10 * x45
x47 = x0 * x32
x48 = x10 * x13
x49 = x47 + x48
x50 = x14 * (-bx * x49 - x1 + A[0])
x51 = x43 - x46 + x50
x52 = ax * x51
x53 = ax * x3
x54 = x31 + x37 * x4
x55 = -ax * x54 + x0 + x26
x56 = bx * x0
x57 = 6.0 * x56
x58 = -ax * x0 * x24 + x11 * x52 + x15 * x55
x59 = -x58
x60 = ax * x43
x61 = -B[0]
x62 = x13 * x3
x63 = x47 + x62
x64 = ax * x63
x65 = -x15 * (x1 + x61 + x64)
x66 = -x45 * x53 + x65
x67 = x14 * (ax * x46 - ax * x50 - 2.0 * x60 - x66)
x68 = x34 * x4
x69 = 2.0 * x33
x70 = x14 * (x35 + x68 + x69)
x71 = x25 * x54 + x70
x72 = ax * x14
x73 = x10 * x59 + x67 + x72 * (-bx * x71 + 2.0 * x68 + x69)
x74 = ax * A[1] + bx * B[1]
x75 = x0 * x74
x76 = -x75
x77 = x76 + A[1]
x78 = -x77
x79 = 2.0 * x78**2
x80 = ax * (x0 + x79)
x81 = x80 - 1.0
x82 = x21 + x27
x83 = x0 * (x20 + x82)
x84 = x11 * x49 + x83
x85 = x14 * (2.0 * x47 + x48 + x62)
x86 = x10 * x84 + x85
x87 = ax * (x0 * (x19 * x49 + 6.0 * x3 * x49 + 5.0 * x83) + x11 * x86)
x88 = ax * A[2] + bx * B[2]
x89 = x0 * x88
x90 = -x89
x91 = x90 + A[2]
x92 = -x91
x93 = 2.0 * x92**2
x94 = ax * (x0 + x93)
x95 = x94 - 1.0
x96 = 4.0 * x25 * x36
x97 = 2.0 * x4
x98 = ax * x56
x99 = -B[1]
x100 = -B[2]
x101 = (
5.568327996831708
* da
* db
* numpy.exp(-x98 * ((x100 + A[2]) ** 2 + (x61 + A[0]) ** 2 + (x99 + A[1]) ** 2))
)
x102 = numpy.sqrt(x0) * x101
x103 = 0.008333333333333333 * x0 * x102
x104 = x0 * (x15 * (-ax * (x4 * x54 + x70) + 2.0 * x35 + x69) + x3 * x59 + x67)
x105 = x16 - x80
x106 = x40 * (x3 * x84 + x85)
x107 = 2.0 * x91**2
x108 = ax * (x0 + x107)
x109 = x108 - 1.0
x110 = x76 + B[1]
x111 = 0.01666666666666667 * x110
x112 = 2.23606797749979
x113 = x102 * x112
x114 = x111 * x113
x115 = x16 - x94
x116 = 2.0 * x77**2
x117 = ax * (x0 + x116)
x118 = x117 - 1.0
x119 = x90 + B[2]
x120 = 0.01666666666666667 * x119
x121 = x113 * x120
x122 = 2.0 * x110**2
x123 = x0 + x122
x124 = 2.0 * x3**2
x125 = ax * (x0 + x124)
x126 = x125 - 1.0
x127 = ax * x124 * x18 - x126 * x15
x128 = x60 + x66
x129 = (
x0 * (-4.0 * ax * bx * x0 * x13 + ax * x9 + x127 + x18 * x19 * x53)
+ x11 * x128
- x15 * (ax * (x0 * (x30 + x5) + x97 * (x33 + x68)) - x38)
)
x130 = x0 * x81
x131 = -x105
x132 = x122 * x131 - x14 * (bx * x123 - 1.0)
x133 = x130 + x132
x134 = x124 + x27
x135 = ax * (x0 * (x134 + x20) + x11 * x63)
x136 = x0**1.5 * x101
x137 = x112 * x136
x138 = 0.008333333333333333 * x137
x139 = x0 * x135
x140 = -x115
x141 = 3.872983346207417 * x102
x142 = x111 * x141
x143 = 2.0 * x119**2
x144 = x0 + x143
x145 = x0 * x95
x146 = -x14 * (bx * x144 - 1.0) + x140 * x143
x147 = x145 + x146
x148 = x122 + x27
x149 = x14 * x17
x150 = ax * x134
x151 = ax * x8 + x127
x152 = -x15 * (x150 - 2.0) + x151
x153 = -ax * x149 + x152
x154 = x105 * x14
x155 = x133 - x14 * (bx * x148 - 2.0)
x156 = -x154 + x155
x157 = x136 * x3
x158 = x14 * x18
x159 = ax * x158 + x152
x160 = -x133
x161 = x123 * x140
x162 = x137 * x3
x163 = x120 * x162
x164 = -x147
x165 = x131 * x144
x166 = x111 * x162
x167 = x143 + x27
x168 = x115 * x14
x169 = -x14 * (bx * x167 - 2.0) + x147
x170 = -x168 + x169
x171 = x0 * x73
x172 = x40 * x86
x173 = 0.01666666666666667 * x113
x174 = x173 * x77
x175 = x110 * x77
x176 = 2.0 * x175
x177 = x0 + x176
x178 = x130 + x131 * x176 - x15 * x177
x179 = ax * x84
x180 = 0.04166666666666667 * x136
x181 = x0 * x179
x182 = 0.08333333333333333 * x102
x183 = x182 * (-x0 * x59 + x131 * x181 + x140 * x181)
x184 = -x14 * x74 + A[1] + B[1]
x185 = x0 * x184
x186 = x110 * x177
x187 = x185 + x186
x188 = x0 * x42
x189 = -ax * x188 + x44 * x53 + x65
x190 = x110 * x15 - x110 * x81 + x15 * x77 - x77 * x81
x191 = x0 * x190
x192 = x14 * (-bx * x187 - x75 + A[1])
x193 = x110 * x178 - x191 + x192
x194 = 0.08333333333333333 * x136
x195 = -x178
x196 = x140 * x177
x197 = 1.732050807568877
x198 = x119 * x194
x199 = x197 * x198
x200 = x194 * x77
x201 = 4.0 * x175
x202 = x0 * (x148 + x201)
x203 = 2.0 * x110
x204 = x187 * x203 + x202
x205 = x27 * x81
x206 = x131 * x201
x207 = 4.0 * bx * x0 * x177 - x132 - x205 - x206
x208 = x0 * x207
x209 = -x110
x210 = 2.0 * x209**2
x211 = x209 * x78
x212 = 4.0 * x211
x213 = x212 + x27
x214 = x210 + x213
x215 = x0 * x214
x216 = -x184
x217 = x0 * x216
x218 = x0 + 2.0 * x211
x219 = x209 * x218
x220 = x217 + x219
x221 = 2.0 * x220
x222 = x14 + x212
x223 = -bx * (x209 * x221 + x215) + x222
x224 = -x190
x225 = x0 * x224
x226 = x110 * x195
x227 = x192 + x225 - x226
x228 = x14 * x223 + x203 * x227 - x208
x229 = -x151
x230 = x140 * x187
x231 = x14 * x140
x232 = x169 + x231
x233 = x137 * x77
x234 = x120 * x233
x235 = x173 * x91
x236 = x119 * x91
x237 = 2.0 * x236
x238 = x0 + x237
x239 = x140 * x237 + x145 - x15 * x238
x240 = x194 * x91
x241 = -x239
x242 = x131 * x238
x243 = x110 * x194
x244 = x197 * x243
x245 = -x14 * x88 + A[2] + B[2]
x246 = x0 * x245
x247 = x119 * x238
x248 = x246 + x247
x249 = x119 * x15 - x119 * x95 + x15 * x91 - x91 * x95
x250 = x0 * x249
x251 = x14 * (-bx * x248 - x89 + A[2])
x252 = x119 * x239 - x250 + x251
x253 = x131 * x14
x254 = x155 + x253
x255 = x137 * x91
x256 = x111 * x255
x257 = -x249
x258 = x0 * x257
x259 = x119 * x241
x260 = x251 + x258 - x259
x261 = x131 * x248
x262 = 4.0 * x236
x263 = x0 * (x167 + x262)
x264 = 2.0 * x119
x265 = x248 * x264 + x263
x266 = x27 * x95
x267 = x140 * x262
x268 = 4.0 * bx * x0 * x238 - x146 - x266 - x267
x269 = x0 * x268
x270 = -x119
x271 = 2.0 * x270**2
x272 = x270 * x92
x273 = 4.0 * x272
x274 = x27 + x273
x275 = x271 + x274
x276 = x0 * x275
x277 = -x245
x278 = x0 * x277
x279 = x0 + 2.0 * x272
x280 = x270 * x279
x281 = x278 + x280
x282 = 2.0 * x281
x283 = x14 + x273
x284 = -bx * (x270 * x282 + x276) + x283
x285 = x14 * x284 + x260 * x264 - x269
x286 = 2.0 * x10
x287 = x286 * x49 + x83
x288 = ax * x116 * x131 - x118 * x15
x289 = ax * x130 + x288
x290 = -x0 * x24 + x14 * x39 + x286 * x51
x291 = ax * x77
x292 = x177 * x77
x293 = x185 + x292
x294 = ax * x293
x295 = -x15 * (x294 + x75 + x99)
x296 = -ax * x191 + x178 * x291 + x295
x297 = x10 * x44 - x188 + x50
x298 = -x289
x299 = x117 * x140
x300 = x227 * x291
x301 = x215 + x221 * x78
x302 = -ax * x301 + x0 + x210
x303 = -ax * x208 + x15 * x302 + 2.0 * x300
x304 = 2.0 * x77
x305 = x187 * x304 + x202
x306 = ax * x44
x307 = ax * x305
x308 = -x195 * x291 + x295
x309 = ax * x225 + x308
x310 = x140 * x294
x311 = -x303
x312 = x14 * (-ax * x192 + ax * x226 - x224 * x72 - x308)
x313 = x218 * x78
x314 = x14 * x216
x315 = x14 * (x219 + x313 + x314)
x316 = x209 * x301 + x315
x317 = x110 * x311 + x312 + x72 * (-bx * x316 + 2.0 * x313 + x314)
x318 = x0 * x317
x319 = x14 * (x14 * x184 + x186 + x292)
x320 = x110 * x305 + x319
x321 = x320 * x40
x322 = x173 * x3
x323 = x0 * x307
x324 = -x0 * x311 + x140 * x323 + x18 * x323
x325 = x182 * x3
x326 = x144 * x18
x327 = x194 * x3
x328 = x0 * x287
x329 = 0.01666666666666667 * x141
x330 = x329 * x91
x331 = ax * x91
x332 = x194 * x197
x333 = x331 * x332
x334 = x291 * x332
x335 = x0 * x204
x336 = x18 * x238
x337 = x332 * x53
x338 = x18 * x248
x339 = x0 * x265
x340 = ax * x107 * x140 - x109 * x15
x341 = ax * x145 + x340
x342 = -x341
x343 = x108 * x131
x344 = x238 * x91
x345 = x246 + x344
x346 = ax * x345
x347 = -x15 * (x100 + x346 + x89)
x348 = -ax * x250 + x239 * x331 + x347
x349 = -x241 * x331 + x347
x350 = ax * x258 + x349
x351 = x131 * x346
x352 = x260 * x331
x353 = x276 + x282 * x92
x354 = -ax * x353 + x0 + x271
x355 = -ax * x269 + x15 * x354 + 2.0 * x352
x356 = 2.0 * x91
x357 = x248 * x356 + x263
x358 = ax * x357
x359 = x108 * x18
x360 = x18 * x346
x361 = -x355
x362 = x0 * x358
x363 = -x0 * x361 + x131 * x362 + x18 * x362
x364 = x14 * (-ax * x251 + ax * x259 - x257 * x72 - x349)
x365 = x279 * x92
x366 = x14 * x277
x367 = x14 * (x280 + x365 + x366)
x368 = x270 * x353 + x367
x369 = x119 * x361 + x364 + x72 * (-bx * x368 + 2.0 * x365 + x366)
x370 = x0 * x369
x371 = x14 * (x14 * x245 + x247 + x344)
x372 = x119 * x357 + x371
x373 = x372 * x40
x374 = x116 + x27
x375 = ax * x374
x376 = -x15 * (x375 - 2.0) + x289
x377 = -ax * x154 + x376
x378 = x23 + x8
x379 = -x14 * (bx * x82 - 2.0) + x378
x380 = -x149 + x379
x381 = x136 * x77
x382 = 0.01666666666666667 * x10
x383 = 2.0 * x78
x384 = (
x0 * (-4.0 * ax * bx * x0 * x177 + ax * x205 + ax * x206 + x288)
- x15 * (ax * (x0 * (x213 + x79) + x383 * (x217 + x313)) - x222)
+ x304 * x309
)
x385 = ax * (x0 * (x201 + x374) + x293 * x304)
x386 = ax * x253 + x376
x387 = -x378
x388 = x0 * (
x15 * (-ax * (x301 * x78 + x315) + 2.0 * x219 + x314) + x311 * x77 + x312
)
x389 = x40 * (x305 * x77 + x319)
x390 = x10 * x173
x391 = x0 * x385
x392 = x233 * x382
x393 = 4.0 * x110
x394 = ax * (x0 * (x187 * x393 + 6.0 * x187 * x77 + 5.0 * x202) + x304 * x320)
x395 = 4.0 * x209 * x220
x396 = x158 + x379
x397 = x255 * x382
x398 = x10 * x182
x399 = x10 * x194
x400 = x197 * x399
x401 = x107 + x27
x402 = ax * x401
x403 = -x15 * (x402 - 2.0) + x341
x404 = -ax * x168 + x403
x405 = x136 * x91
x406 = ax * x231 + x403
x407 = 2.0 * x92
x408 = (
x0 * (-4.0 * ax * bx * x0 * x238 + ax * x266 + ax * x267 + x340)
- x15 * (ax * (x0 * (x274 + x93) + x407 * (x278 + x365)) - x283)
+ x350 * x356
)
x409 = ax * (x0 * (x262 + x401) + x345 * x356)
x410 = x0 * x409
x411 = x0 * (
x15 * (-ax * (x353 * x92 + x367) + 2.0 * x280 + x366) + x361 * x91 + x364
)
x412 = x40 * (x357 * x91 + x371)
x413 = 4.0 * x119
x414 = ax * (x0 * (x248 * x413 + 6.0 * x248 * x91 + 5.0 * x263) + x356 * x372)
x415 = 4.0 * x270 * x281
# 100 item(s)
result[0, 0] = numpy.sum(
-x103
* (
x0
* (-5.0 * ax * x0 * x24 + x19 * x52 + x39 * x41 + 6.0 * x51 * x53 + x55 * x57)
- x11 * x73
+ x15
* (
-ax * (x0 * (5.0 * x31 + 6.0 * x36 * x4 + x96) + x71 * x97)
+ 2.0 * x31
+ x96
)
+ x81 * x87
+ x87 * x95
)
)
result[0, 1] = numpy.sum(x114 * (x104 + x105 * x106 - x106 * x109))
result[0, 2] = numpy.sum(x121 * (x104 + x106 * x115 - x106 * x118))
result[0, 3] = numpy.sum(-x138 * (x109 * x123 * x135 + x123 * x129 + x133 * x135))
result[0, 4] = numpy.sum(-x119 * x142 * (x0 * x129 + x131 * x139 + x139 * x140))
result[0, 5] = numpy.sum(-x138 * (x118 * x135 * x144 + x129 * x144 + x135 * x147))
result[0, 6] = numpy.sum(
-x111 * x157 * (x109 * x148 * x150 + x148 * x153 + x150 * x156)
)
result[0, 7] = numpy.sum(x163 * (-x123 * x159 + x150 * x160 - x150 * x161))
result[0, 8] = numpy.sum(x166 * (-x144 * x159 + x150 * x164 - x150 * x165))
result[0, 9] = numpy.sum(
-x120 * x157 * (x118 * x150 * x167 + x150 * x170 + x153 * x167)
)
result[1, 0] = numpy.sum(x174 * (x105 * x172 - x109 * x172 + x171))
result[1, 1] = numpy.sum(-x180 * (x109 * x177 * x179 + x177 * x58 + x178 * x179))
result[1, 2] = numpy.sum(-x119 * x183 * x77)
result[1, 3] = numpy.sum(-x194 * (x109 * x187 * x64 + x187 * x189 + x193 * x64))
result[1, 4] = numpy.sum(x199 * (-x128 * x177 + x195 * x64 - x196 * x64))
result[1, 5] = numpy.sum(x200 * (-x128 * x144 + x164 * x64 - x165 * x64))
result[1, 6] = numpy.sum(-x138 * (x109 * x125 * x204 + x125 * x228 + x151 * x204))
result[1, 7] = numpy.sum(x198 * (-x125 * x227 - x125 * x230 + x187 * x229))
result[1, 8] = numpy.sum(
-x180 * (x125 * x144 * x178 + x125 * x147 * x177 + x144 * x151 * x177)
)
result[1, 9] = numpy.sum(x234 * (-x125 * x131 * x167 - x125 * x232 + x167 * x229))
result[2, 0] = numpy.sum(x235 * (x115 * x172 - x118 * x172 + x171))
result[2, 1] = numpy.sum(-x110 * x183 * x91)
result[2, 2] = numpy.sum(-x180 * (x118 * x179 * x238 + x179 * x239 + x238 * x58))
result[2, 3] = numpy.sum(x240 * (-x123 * x128 + x160 * x64 - x161 * x64))
result[2, 4] = numpy.sum(x244 * (-x128 * x238 + x241 * x64 - x242 * x64))
result[2, 5] = numpy.sum(-x194 * (x118 * x248 * x64 + x189 * x248 + x252 * x64))
result[2, 6] = numpy.sum(x256 * (-x125 * x140 * x148 - x125 * x254 + x148 * x229))
result[2, 7] = numpy.sum(
-x180 * (x123 * x125 * x239 + x123 * x151 * x238 + x125 * x133 * x238)
)
result[2, 8] = numpy.sum(x243 * (-x125 * x260 - x125 * x261 + x229 * x248))
result[2, 9] = numpy.sum(-x138 * (x118 * x125 * x265 + x125 * x285 + x151 * x265))
result[3, 0] = numpy.sum(-x138 * (x109 * x117 * x287 + x117 * x290 + x287 * x289))
result[3, 1] = numpy.sum(-x194 * (x109 * x294 * x49 + x294 * x297 + x296 * x49))
result[3, 2] = numpy.sum(x198 * (-x117 * x51 + x298 * x49 - x299 * x49))
result[3, 3] = numpy.sum(-x180 * (x109 * x13 * x307 + x13 * x303 + x305 * x306))
result[3, 4] = numpy.sum(x199 * (-x13 * x309 - x13 * x310 + x294 * x45))
result[3, 5] = numpy.sum(
-x180 * (x117 * x13 * x147 + x117 * x144 * x44 + x13 * x144 * x289)
)
result[3, 6] = numpy.sum(x322 * (-x109 * x321 + x17 * x321 + x318))
result[3, 7] = numpy.sum(-x119 * x324 * x325)
result[3, 8] = numpy.sum(x327 * (-x144 * x309 + x164 * x294 - x294 * x326))
result[3, 9] = numpy.sum(x163 * (-x117 * x167 * x18 - x117 * x232 + x167 * x298))
result[4, 0] = numpy.sum(-x291 * x330 * (x0 * x290 + x131 * x328 + x140 * x328))
result[4, 1] = numpy.sum(x333 * (-x177 * x51 + x195 * x49 - x196 * x49))
result[4, 2] = numpy.sum(x334 * (-x238 * x51 + x241 * x49 - x242 * x49))
result[4, 3] = numpy.sum(x333 * (-x13 * x227 - x13 * x230 + x187 * x45))
result[4, 4] = numpy.sum(
-0.125 * ax * x136 * (x13 * x177 * x239 + x13 * x178 * x238 + x177 * x238 * x44)
)
result[4, 5] = numpy.sum(x334 * (-x13 * x260 - x13 * x261 + x248 * x45))
result[4, 6] = numpy.sum(-x330 * x53 * (x0 * x228 + x140 * x335 + x18 * x335))
result[4, 7] = numpy.sum(x337 * (x187 * x241 - x187 * x336 - x227 * x238))
result[4, 8] = numpy.sum(x337 * (-x177 * x260 - x177 * x338 + x195 * x248))
result[4, 9] = numpy.sum(-x329 * x53 * x77 * (x0 * x285 + x131 * x339 + x18 * x339))
result[5, 0] = numpy.sum(-x138 * (x108 * x118 * x287 + x108 * x290 + x287 * x341))
result[5, 1] = numpy.sum(x243 * (-x108 * x51 + x342 * x49 - x343 * x49))
result[5, 2] = numpy.sum(-x194 * (x118 * x346 * x49 + x297 * x346 + x348 * x49))
result[5, 3] = numpy.sum(
-x180 * (x108 * x123 * x44 + x108 * x13 * x133 + x123 * x13 * x341)
)
result[5, 4] = numpy.sum(x244 * (-x13 * x350 - x13 * x351 + x346 * x45))
result[5, 5] = numpy.sum(-x180 * (x118 * x13 * x358 + x13 * x355 + x306 * x357))
result[5, 6] = numpy.sum(x166 * (-x108 * x254 + x148 * x342 - x148 * x359))
result[5, 7] = numpy.sum(x327 * (-x123 * x350 - x123 * x360 + x160 * x346))
result[5, 8] = numpy.sum(-x110 * x325 * x363)
result[5, 9] = numpy.sum(x322 * (-x118 * x373 + x17 * x373 + x370))
result[6, 0] = numpy.sum(
-x381 * x382 * (x109 * x375 * x82 + x375 * x380 + x377 * x82)
)
result[6, 1] = numpy.sum(-x138 * (x109 * x22 * x385 + x22 * x384 + x378 * x385))
result[6, 2] = numpy.sum(x234 * (-x140 * x22 * x375 - x22 * x386 + x375 * x387))
result[6, 3] = numpy.sum(x390 * (-x109 * x389 + x17 * x389 + x388))
result[6, 4] = numpy.sum(-x10 * x120 * x141 * (x0 * x384 + x140 * x391 + x18 * x391))
result[6, 5] = numpy.sum(x392 * (-x144 * x386 + x164 * x375 - x326 * x375))
result[6, 6] = numpy.sum(
-x103
* (
x0
* (
-5.0 * ax * x0 * x207
+ ax * x227 * x393
+ x223 * x41
+ 6.0 * x300
+ x302 * x57
)
+ x15
* (
-ax * (x0 * (5.0 * x215 + 6.0 * x220 * x78 + x395) + x316 * x383)
+ x14 * x214
+ x395
)
- x304 * x317
+ x394 * x7
+ x394 * x95
)
)
result[6, 7] = numpy.sum(x121 * (x115 * x389 - x126 * x389 + x388))
result[6, 8] = numpy.sum(-x138 * (x126 * x144 * x385 + x144 * x384 + x147 * x385))
result[6, 9] = numpy.sum(
-x120 * x381 * (x126 * x167 * x375 + x167 * x377 + x170 * x375)
)
result[7, 0] = numpy.sum(x397 * (-x117 * x396 + x298 * x82 - x299 * x82))
result[7, 1] = numpy.sum(x240 * (-x22 * x309 - x22 * x310 + x294 * x387))
result[7, 2] = numpy.sum(
-x180 * (x117 * x22 * x239 + x117 * x238 * x378 + x22 * x238 * x289)
)
result[7, 3] = numpy.sum(-x324 * x398 * x91)
result[7, 4] = numpy.sum(x400 * (-x238 * x309 + x241 * x294 - x294 * x336))
result[7, 5] = numpy.sum(x399 * (-x117 * x260 - x117 * x338 + x248 * x298))
result[7, 6] = numpy.sum(x235 * (x115 * x321 - x126 * x321 + x318))
result[7, 7] = numpy.sum(-x180 * (x126 * x238 * x307 + x238 * x303 + x239 * x307))
result[7, 8] = numpy.sum(-x194 * (x126 * x248 * x294 + x248 * x296 + x252 * x294))
result[7, 9] = numpy.sum(-x138 * (x117 * x126 * x265 + x117 * x285 + x265 * x289))
result[8, 0] = numpy.sum(x392 * (-x108 * x396 + x342 * x82 - x343 * x82))
result[8, 1] = numpy.sum(
-x180 * (x108 * x177 * x378 + x108 * x178 * x22 + x177 * x22 * x341)
)
result[8, 2] = numpy.sum(x200 * (-x22 * x350 - x22 * x351 + x346 * x387))
result[8, 3] = numpy.sum(x399 * (-x108 * x227 + x187 * x342 - x187 * x359))
result[8, 4] = numpy.sum(x400 * (-x177 * x350 - x177 * x360 + x195 * x346))
result[8, 5] = numpy.sum(-x363 * x398 * x77)
result[8, 6] = numpy.sum(-x138 * (x108 * x126 * x204 + x108 * x228 + x204 * x341))
result[8, 7] = numpy.sum(-x194 * (x126 * x187 * x346 + x187 * x348 + x193 * x346))
result[8, 8] = numpy.sum(-x180 * (x126 * x177 * x358 + x177 * x355 + x178 * x358))
result[8, 9] = numpy.sum(x174 * (x105 * x373 - x126 * x373 + x370))
result[9, 0] = numpy.sum(
-x382 * x405 * (x118 * x402 * x82 + x380 * x402 + x404 * x82)
)
result[9, 1] = numpy.sum(x256 * (-x131 * x22 * x402 - x22 * x406 + x387 * x402))
result[9, 2] = numpy.sum(-x138 * (x118 * x22 * x409 + x22 * x408 + x378 * x409))
result[9, 3] = numpy.sum(x397 * (-x123 * x18 * x402 - x123 * x406 + x160 * x402))
result[9, 4] = numpy.sum(-x10 * x142 * (x0 * x408 + x131 * x410 + x18 * x410))
result[9, 5] = numpy.sum(x390 * (-x118 * x412 + x17 * x412 + x411))
result[9, 6] = numpy.sum(
-x111 * x405 * (x126 * x148 * x402 + x148 * x404 + x156 * x402)
)
result[9, 7] = numpy.sum(-x138 * (x123 * x126 * x409 + x123 * x408 + x133 * x409))
result[9, 8] = numpy.sum(x114 * (x105 * x412 - x126 * x412 + x411))
result[9, 9] = numpy.sum(
-x103
* (
x0
* (
-5.0 * ax * x0 * x268
+ ax * x260 * x413
+ x284 * x41
+ 6.0 * x352
+ x354 * x57
)
+ x15
* (
-ax * (x0 * (5.0 * x276 + 6.0 * x281 * x92 + x415) + x368 * x407)
+ x14 * x275
+ x415
)
- x356 * x369
+ x414 * x7
+ x414 * x81
)
)
return result
[docs]
def kinetic3d_34(ax, da, A, bx, db, B):
"""Cartesian 3D (fg) kinetic energy integral.
Generated code; DO NOT modify by hand!"""
result = numpy.zeros((10, 15), dtype=float)
x0 = 2.0 * ax
x1 = 2.0 * bx
x2 = (x0 + x1) ** (-1.0)
x3 = (ax + bx) ** (-1.0)
x4 = -x3 * (ax * A[0] + bx * B[0])
x5 = -x4 - A[0]
x6 = -x4 - B[0]
x7 = -ax
x8 = x5**2
x9 = 2.0 * ax**2
x10 = -x7 - x9 * (x2 + x8)
x11 = ax * x3
x12 = bx * x11
x13 = numpy.exp(-x12 * (A[0] - B[0]) ** 2)
x14 = 1.772453850905516 * numpy.sqrt(x3)
x15 = x13 * x14
x16 = x15 * x6
x17 = x10 * x16
x18 = bx * x3
x19 = x0 * x18
x20 = x16 * x19 + x17
x21 = x20 * x6
x22 = x15 * x6**2
x23 = x15 * x2
x24 = x22 + x23
x25 = -x15
x26 = x11 * (x1 * x24 + x25)
x27 = x21 + x26
x28 = x10 * x23
x29 = 3.0 * x28
x30 = x20 * x5
x31 = x15 * x5
x32 = x31 * x6
x33 = x23 + x32
x34 = 4.0 * x12
x35 = x29 + 2.0 * x30 + x33 * x34
x36 = x2 * (x27 + x35)
x37 = x10 * x31
x38 = x19 * x31 + x37
x39 = x2 * (x20 + x38)
x40 = x19 * x33 + x28 + x30
x41 = x40 * x6
x42 = x2 * (x16 + x31)
x43 = x33 * x6
x44 = x42 + x43
x45 = x1 * x44 - x31
x46 = x11 * x45
x47 = x39 + x41 + x46
x48 = x47 * x5
x49 = 3.0 * x23
x50 = 2.0 * x32
x51 = x49 + x50
x52 = x2 * (x22 + x51)
x53 = x44 * x5
x54 = x52 + x53
x55 = x18 * (2.0 * ax * x54 - x24)
x56 = x36 + x48 + x55
x57 = x5 * x56
x58 = x56 * x6
x59 = x40 * x5
x60 = x0 * x3
x61 = x33 * x5
x62 = x42 + x61
x63 = x0 * x62 - x16
x64 = x1 * x3
x65 = x2 * (4.0 * x39 + 2.0 * x41 + x45 * x60 + 2.0 * x59 + x63 * x64)
x66 = 2.0 * x61
x67 = 2.0 * x43
x68 = x2 * (4.0 * x42 + x66 + x67)
x69 = x54 * x6
x70 = x68 + x69
x71 = 2.0 * x42
x72 = x11 * (2.0 * bx * x70 - x66 - x71)
x73 = x5 * x54
x74 = x68 + x73
x75 = x18 * (2.0 * ax * x74 - x67 - x71)
x76 = x47 * x6
x77 = x44 * x6
x78 = x52 + x77
x79 = 2.0 * x23
x80 = x50 + x79
x81 = 2.0 * bx * x78 - x80
x82 = x2 * (5.0 * x36 + 3.0 * x48 + 3.0 * x55 + x60 * x81 + 2.0 * x76)
x83 = x58 + x65 + x72
x84 = 2.0 * x77
x85 = 3.0 * x53
x86 = x2 * (5.0 * x52 + x84 + x85)
x87 = x5 * x70 + x86
x88 = -x18 * (-2.0 * ax * x87 + 2.0 * x52 + x84) + x5 * x83 + x82
x89 = 3.0 * x73
x90 = x2 * (6.0 * x68 + 3.0 * x69 + x89) + x6 * x87
x91 = numpy.exp(-x12 * (A[1] - B[1]) ** 2)
x92 = numpy.exp(-x12 * (A[2] - B[2]) ** 2)
x93 = 3.141592653589793 * x3 * x92
x94 = x91 * x93
x95 = -x3 * (ax * A[1] + bx * B[1])
x96 = -x95 - A[1]
x97 = x96**2
x98 = -x7 - x9 * (x2 + x97)
x99 = x90 * x94
x100 = -x3 * (ax * A[2] + bx * B[2])
x101 = -x100 - A[2]
x102 = x101**2
x103 = -x7 - x9 * (x102 + x2)
x104 = da * db
x105 = 0.009523809523809524 * x104
x106 = 2.645751311064591 * x105
x107 = -x95 - B[1]
x108 = x14 * x91
x109 = x107 * x108
x110 = x109 * x98
x111 = x109 * x19 + x110
x112 = x14 * x92
x113 = x88 * x94
x114 = x87 * x94
x115 = 0.06666666666666667 * x104
x116 = -x100 - B[2]
x117 = x112 * x116
x118 = x103 * x117
x119 = x117 * x19 + x118
x120 = x108 * x2
x121 = x120 * x98
x122 = x107 * x111
x123 = x107**2 * x108
x124 = x120 + x123
x125 = -x108
x126 = x11 * (x1 * x124 + x125)
x127 = x122 + x126
x128 = x121 + x127
x129 = x112 * x74
x130 = x57 + x65 + x75
x131 = 3.872983346207417
x132 = 0.02222222222222222 * x104 * x131
x133 = x116 * x94
x134 = 2.23606797749979 * x115
x135 = x112 * x2
x136 = x103 * x135
x137 = x116 * x119
x138 = x112 * x116**2
x139 = x135 + x138
x140 = -x112
x141 = x11 * (x1 * x139 + x140)
x142 = x137 + x141
x143 = x136 + x142
x144 = x108 * x74
x145 = 2.0 * x120
x146 = x107 * (x124 + x145)
x147 = x107 * x128 + x11 * (x1 * x146 - 2.0 * x109) + x2 * (x109 * x34 + 2.0 * x110)
x148 = x15 * x8
x149 = x2 * (x148 + x51) + x5 * x62
x150 = x112 * x149
x151 = x148 + x23
x152 = x18 * (x0 * x151 + x25) + x38 * x5
x153 = x18 * x63 + x39 + x59
x154 = x153 * x5 + x18 * (2.0 * ax * x149 - x80) + x2 * (x152 + x35)
x155 = 2.0 * x135
x156 = x116 * (x139 + x155)
x157 = x11 * (x1 * x156 - 2.0 * x117) + x116 * x143 + x2 * (x117 * x34 + 2.0 * x118)
x158 = x108 * x149
x159 = x152 + x28
x160 = x5 * (x151 + x79)
x161 = x159 * x5 + x18 * (x0 * x160 - 2.0 * x31) + x2 * (x31 * x34 + 2.0 * x37)
x162 = 3.0 * x120
x163 = 3.0 * x123 + x162
x164 = x107 * x146 + x163 * x2
x165 = x112 * x164
x166 = 3.0 * x121
x167 = (
x107 * x147
+ x11 * (2.0 * bx * x164 - x163)
+ x2 * (3.0 * x122 + 3.0 * x126 + x166)
)
x168 = 3.0 * x135
x169 = 3.0 * x138 + x168
x170 = x116 * x156 + x169 * x2
x171 = x108 * x170
x172 = 3.0 * x136
x173 = (
x11 * (2.0 * bx * x170 - x169)
+ x116 * x157
+ x2 * (3.0 * x137 + 3.0 * x141 + x172)
)
x174 = x108 * x96
x175 = x174 * x98
x176 = x174 * x19 + x175
x177 = x6 * x70 + x86
x178 = x94 * (-x11 * (-2.0 * bx * x177 + 3.0 * x52 + x85) + x6 * x83 + x82)
x179 = x177 * x94
x180 = 5.916079783099616 * x105
x181 = x111 * x96
x182 = x107 * x174
x183 = x120 + x182
x184 = x121 + x181 + x183 * x19
x185 = x112 * x70
x186 = x2 * (x109 + x174)
x187 = x107 * x183
x188 = x186 + x187
x189 = x112 * x188
x190 = x2 * (x111 + x176)
x191 = x107 * x184
x192 = x1 * x188 - x174
x193 = x11 * x192
x194 = x190 + x191 + x193
x195 = 1.732050807568877
x196 = 0.1111111111111111 * x104 * x195
x197 = 0.3333333333333333 * x104
x198 = x166 + 2.0 * x181 + x183 * x34
x199 = x2 * (x127 + x198)
x200 = x107 * x194
x201 = 2.0 * x182
x202 = x162 + x201
x203 = x2 * (x123 + x202)
x204 = x107 * x188
x205 = x203 + x204
x206 = x145 + x201
x207 = 2.0 * bx * x205 - x206
x208 = x11 * x207 + x199 + x200
x209 = x112 * x62
x210 = 3.0 * x186 + 3.0 * x187
x211 = x107 * x205 + x2 * (x146 + x210)
x212 = x112 * x211
x213 = (
x107 * x208
+ x11 * (2.0 * bx * x211 - x210)
+ x2 * (x147 + 3.0 * x190 + 3.0 * x191 + 3.0 * x193)
)
x214 = x101 * x112
x215 = x103 * x214
x216 = x19 * x214 + x215
x217 = x101 * x94
x218 = x101 * x119
x219 = x116 * x214
x220 = x135 + x219
x221 = x136 + x19 * x220 + x218
x222 = x108 * x70
x223 = x2 * (x117 + x214)
x224 = x116 * x220
x225 = x223 + x224
x226 = x108 * x225
x227 = x2 * (x119 + x216)
x228 = x116 * x221
x229 = x1 * x225 - x214
x230 = x11 * x229
x231 = x227 + x228 + x230
x232 = x172 + 2.0 * x218 + x220 * x34
x233 = x2 * (x142 + x232)
x234 = x116 * x231
x235 = 2.0 * x219
x236 = x168 + x235
x237 = x2 * (x138 + x236)
x238 = x116 * x225
x239 = x237 + x238
x240 = x155 + x235
x241 = 2.0 * bx * x239 - x240
x242 = x11 * x241 + x233 + x234
x243 = x108 * x62
x244 = 3.0 * x223 + 3.0 * x224
x245 = x116 * x239 + x2 * (x156 + x244)
x246 = x108 * x245
x247 = (
x11 * (2.0 * bx * x245 - x244)
+ x116 * x242
+ x2 * (x157 + 3.0 * x227 + 3.0 * x228 + 3.0 * x230)
)
x248 = x108 * x97
x249 = x120 + x248
x250 = x176 * x96 + x18 * (x0 * x249 + x125)
x251 = x121 + x250
x252 = x6 * (x24 + x79)
x253 = 3.0 * x42 + 3.0 * x43
x254 = x2 * (x252 + x253) + x6 * x78
x255 = x112 * x254
x256 = x27 + x28
x257 = x11 * (x1 * x252 - 2.0 * x16) + x2 * (x16 * x34 + 2.0 * x17) + x256 * x6
x258 = x11 * x81 + x36 + x76
x259 = (
x11 * (2.0 * bx * x254 - x253)
+ x2 * (x257 + 3.0 * x39 + 3.0 * x41 + 3.0 * x46)
+ x258 * x6
)
x260 = x183 * x96
x261 = x186 + x260
x262 = x112 * x261
x263 = x184 * x96
x264 = x0 * x261 - x109
x265 = x18 * x264 + x190 + x263
x266 = x194 * x96
x267 = x188 * x96
x268 = x203 + x267
x269 = x18 * (2.0 * ax * x268 - x124)
x270 = x199 + x266 + x269
x271 = x112 * x44
x272 = 2.0 * x260
x273 = 2.0 * x187
x274 = x2 * (4.0 * x186 + x272 + x273)
x275 = x107 * x268
x276 = x274 + x275
x277 = x112 * x276
x278 = x2 * (4.0 * x190 + 2.0 * x191 + x192 * x60 + 2.0 * x263 + x264 * x64)
x279 = x107 * x270
x280 = 2.0 * x186
x281 = x11 * (2.0 * bx * x276 - x272 - x280)
x282 = x278 + x279 + x281
x283 = 2.0 * x204
x284 = 3.0 * x267
x285 = x2 * (5.0 * x203 + x283 + x284)
x286 = x107 * x276 + x285
x287 = x2 * (5.0 * x199 + 2.0 * x200 + x207 * x60 + 3.0 * x266 + 3.0 * x269)
x288 = x13 * x93
x289 = x288 * (x107 * x282 - x11 * (-2.0 * bx * x286 + 3.0 * x203 + x284) + x287)
x290 = x288 * x5
x291 = 10.2469507659596 * x105
x292 = x115 * x131
x293 = x195 * x197
x294 = 3.141592653589793 * x13 * x3 * x91
x295 = x294 * x5
x296 = x102 * x112
x297 = x135 + x296
x298 = x101 * x216 + x18 * (x0 * x297 + x140)
x299 = x136 + x298
x300 = x108 * x254
x301 = x101 * x220
x302 = x223 + x301
x303 = x108 * x302
x304 = x101 * x221
x305 = x0 * x302 - x117
x306 = x18 * x305 + x227 + x304
x307 = x101 * x231
x308 = x101 * x225
x309 = x237 + x308
x310 = x18 * (2.0 * ax * x309 - x139)
x311 = x233 + x307 + x310
x312 = x108 * x44
x313 = 2.0 * x301
x314 = 2.0 * x224
x315 = x2 * (4.0 * x223 + x313 + x314)
x316 = x116 * x309
x317 = x315 + x316
x318 = x108 * x317
x319 = x2 * (4.0 * x227 + 2.0 * x228 + x229 * x60 + 2.0 * x304 + x305 * x64)
x320 = x116 * x311
x321 = 2.0 * x223
x322 = x11 * (2.0 * bx * x317 - x313 - x321)
x323 = x319 + x320 + x322
x324 = 2.0 * x238
x325 = 3.0 * x308
x326 = x2 * (5.0 * x237 + x324 + x325)
x327 = x116 * x317 + x326
x328 = x2 * (5.0 * x233 + 2.0 * x234 + x241 * x60 + 3.0 * x307 + 3.0 * x310)
x329 = x294 * (-x11 * (-2.0 * bx * x327 + 3.0 * x237 + x325) + x116 * x323 + x328)
x330 = x96 * (x145 + x249)
x331 = x18 * (x0 * x330 - 2.0 * x174) + x2 * (x174 * x34 + 2.0 * x175) + x251 * x96
x332 = 3.0 * x22 + x49
x333 = x2 * x332 + x252 * x6
x334 = x112 * x333
x335 = x11 * (2.0 * bx * x333 - x332) + x2 * (3.0 * x21 + 3.0 * x26 + x29) + x257 * x6
x336 = x2 * (x202 + x248) + x261 * x96
x337 = x112 * x336
x338 = x18 * (2.0 * ax * x336 - x206) + x2 * (x198 + x250) + x265 * x96
x339 = x268 * x96
x340 = x274 + x339
x341 = x112 * x340
x342 = x270 * x96
x343 = x18 * (2.0 * ax * x340 - x273 - x280)
x344 = x278 + x342 + x343
x345 = x276 * x96 + x285
x346 = -x18 * (-2.0 * ax * x345 + 2.0 * x203 + x283) + x282 * x96 + x287
x347 = x288 * x346
x348 = x288 * x6
x349 = 3.0 * x339
x350 = x107 * x345 + x2 * (6.0 * x274 + 3.0 * x275 + x349)
x351 = x288 * x350
x352 = x10 * x288
x353 = x15 * x340
x354 = x15 * x336
x355 = x15 * x170
x356 = x15 * x276
x357 = x15 * x225
x358 = x15 * x261
x359 = x15 * x245
x360 = x294 * x96
x361 = x15 * x211
x362 = x15 * x302
x363 = x15 * x188
x364 = x15 * x317
x365 = x101 * (x155 + x297)
x366 = x101 * x299 + x18 * (x0 * x365 - 2.0 * x214) + x2 * (x214 * x34 + 2.0 * x215)
x367 = x108 * x333
x368 = x101 * x302 + x2 * (x236 + x296)
x369 = x108 * x368
x370 = x101 * x306 + x18 * (2.0 * ax * x368 - x240) + x2 * (x232 + x298)
x371 = x101 * x309
x372 = x315 + x371
x373 = x108 * x372
x374 = x101 * x311
x375 = x18 * (2.0 * ax * x372 - x314 - x321)
x376 = x319 + x374 + x375
x377 = x294 * x6
x378 = x101 * x317 + x326
x379 = x101 * x323 - x18 * (-2.0 * ax * x378 + 2.0 * x237 + x324) + x328
x380 = x294 * x379
x381 = x15 * x164
x382 = x15 * x368
x383 = x15 * x372
x384 = 3.0 * x371
x385 = x116 * x378 + x2 * (6.0 * x315 + 3.0 * x316 + x384)
x386 = x294 * x385
# 150 item(s)
result[0, 0] = numpy.sum(
x106
* (
x103 * x99
+ x94
* (
-x11 * (-2.0 * bx * x90 + 3.0 * x68 + x89)
+ 3.0 * x2 * (x57 + x58 + 2.0 * x65 + x72 + x75)
+ x6 * x88
)
+ x98 * x99
)
)
result[0, 1] = numpy.sum(
x115 * (x103 * x107 * x114 + x107 * x113 + x111 * x112 * x87)
)
result[0, 2] = numpy.sum(x115 * (x108 * x119 * x87 + x113 * x116 + x114 * x116 * x98))
result[0, 3] = numpy.sum(
x132 * (x103 * x124 * x129 + x112 * x124 * x130 + x128 * x129)
)
result[0, 4] = numpy.sum(
x134 * (x107 * x130 * x133 + x109 * x119 * x74 + x111 * x117 * x74)
)
result[0, 5] = numpy.sum(
x132 * (x108 * x130 * x139 + x139 * x144 * x98 + x143 * x144)
)
result[0, 6] = numpy.sum(
x115 * (x103 * x146 * x150 + x112 * x146 * x154 + x147 * x150)
)
result[0, 7] = numpy.sum(
x134 * (x117 * x124 * x154 + x117 * x128 * x149 + x119 * x124 * x149)
)
result[0, 8] = numpy.sum(
x134 * (x109 * x139 * x154 + x109 * x143 * x149 + x111 * x139 * x149)
)
result[0, 9] = numpy.sum(
x115 * (x108 * x154 * x156 + x156 * x158 * x98 + x157 * x158)
)
result[0, 10] = numpy.sum(
x106 * (x103 * x160 * x165 + x112 * x160 * x167 + x161 * x165)
)
result[0, 11] = numpy.sum(
x115 * (x117 * x146 * x161 + x117 * x147 * x160 + x119 * x146 * x160)
)
result[0, 12] = numpy.sum(
x132 * (x124 * x139 * x161 + x124 * x143 * x160 + x128 * x139 * x160)
)
result[0, 13] = numpy.sum(
x115 * (x109 * x156 * x161 + x109 * x157 * x160 + x111 * x156 * x160)
)
result[0, 14] = numpy.sum(
x106 * (x108 * x160 * x173 + x160 * x171 * x98 + x161 * x171)
)
result[1, 0] = numpy.sum(x180 * (x103 * x179 * x96 + x112 * x176 * x177 + x178 * x96))
result[1, 1] = numpy.sum(
x134 * (x103 * x183 * x185 + x112 * x183 * x83 + x184 * x185)
)
result[1, 2] = numpy.sum(
x134 * (x117 * x176 * x70 + x119 * x174 * x70 + x133 * x83 * x96)
)
result[1, 3] = numpy.sum(x196 * (x103 * x189 * x54 + x112 * x194 * x54 + x189 * x56))
result[1, 4] = numpy.sum(
x197 * (x117 * x183 * x56 + x117 * x184 * x54 + x119 * x183 * x54)
)
result[1, 5] = numpy.sum(
x196 * (x139 * x174 * x56 + x139 * x176 * x54 + x143 * x174 * x54)
)
result[1, 6] = numpy.sum(
x134 * (x103 * x205 * x209 + x112 * x153 * x205 + x208 * x209)
)
result[1, 7] = numpy.sum(
x197 * (x117 * x153 * x188 + x117 * x194 * x62 + x119 * x188 * x62)
)
result[1, 8] = numpy.sum(
x197 * (x139 * x153 * x183 + x139 * x184 * x62 + x143 * x183 * x62)
)
result[1, 9] = numpy.sum(
x134 * (x153 * x156 * x174 + x156 * x176 * x62 + x157 * x174 * x62)
)
result[1, 10] = numpy.sum(
x180 * (x103 * x151 * x212 + x112 * x151 * x213 + x159 * x212)
)
result[1, 11] = numpy.sum(
x134 * (x117 * x151 * x208 + x117 * x159 * x205 + x119 * x151 * x205)
)
result[1, 12] = numpy.sum(
x196 * (x139 * x151 * x194 + x139 * x159 * x188 + x143 * x151 * x188)
)
result[1, 13] = numpy.sum(
x134 * (x151 * x156 * x184 + x151 * x157 * x183 + x156 * x159 * x183)
)
result[1, 14] = numpy.sum(
x180 * (x151 * x170 * x176 + x151 * x173 * x174 + x159 * x170 * x174)
)
result[2, 0] = numpy.sum(
x180 * (x101 * x178 + x101 * x179 * x98 + x108 * x177 * x216)
)
result[2, 1] = numpy.sum(
x134 * (x107 * x217 * x83 + x109 * x216 * x70 + x111 * x214 * x70)
)
result[2, 2] = numpy.sum(x134 * (x108 * x220 * x83 + x220 * x222 * x98 + x221 * x222))
result[2, 3] = numpy.sum(
x196 * (x124 * x214 * x56 + x124 * x216 * x54 + x128 * x214 * x54)
)
result[2, 4] = numpy.sum(
x197 * (x109 * x220 * x56 + x109 * x221 * x54 + x111 * x220 * x54)
)
result[2, 5] = numpy.sum(x196 * (x108 * x231 * x54 + x226 * x54 * x98 + x226 * x56))
result[2, 6] = numpy.sum(
x134 * (x146 * x153 * x214 + x146 * x216 * x62 + x147 * x214 * x62)
)
result[2, 7] = numpy.sum(
x197 * (x124 * x153 * x220 + x124 * x221 * x62 + x128 * x220 * x62)
)
result[2, 8] = numpy.sum(
x197 * (x109 * x153 * x225 + x109 * x231 * x62 + x111 * x225 * x62)
)
result[2, 9] = numpy.sum(
x134 * (x108 * x153 * x239 + x239 * x243 * x98 + x242 * x243)
)
result[2, 10] = numpy.sum(
x180 * (x151 * x164 * x216 + x151 * x167 * x214 + x159 * x164 * x214)
)
result[2, 11] = numpy.sum(
x134 * (x146 * x151 * x221 + x146 * x159 * x220 + x147 * x151 * x220)
)
result[2, 12] = numpy.sum(
x196 * (x124 * x151 * x231 + x124 * x159 * x225 + x128 * x151 * x225)
)
result[2, 13] = numpy.sum(
x134 * (x109 * x151 * x242 + x109 * x159 * x239 + x111 * x151 * x239)
)
result[2, 14] = numpy.sum(
x180 * (x108 * x151 * x247 + x151 * x246 * x98 + x159 * x246)
)
result[3, 0] = numpy.sum(
x180 * (x103 * x249 * x255 + x112 * x249 * x259 + x251 * x255)
)
result[3, 1] = numpy.sum(x134 * (x103 * x262 * x78 + x112 * x265 * x78 + x258 * x262))
result[3, 2] = numpy.sum(
x134 * (x117 * x249 * x258 + x117 * x251 * x78 + x119 * x249 * x78)
)
result[3, 3] = numpy.sum(
x196 * (x103 * x268 * x271 + x112 * x268 * x47 + x270 * x271)
)
result[3, 4] = numpy.sum(
x197 * (x117 * x261 * x47 + x117 * x265 * x44 + x119 * x261 * x44)
)
result[3, 5] = numpy.sum(
x196 * (x139 * x249 * x47 + x139 * x251 * x44 + x143 * x249 * x44)
)
result[3, 6] = numpy.sum(x134 * (x103 * x277 * x33 + x112 * x282 * x33 + x277 * x40))
result[3, 7] = numpy.sum(
x197 * (x117 * x268 * x40 + x117 * x270 * x33 + x119 * x268 * x33)
)
result[3, 8] = numpy.sum(
x197 * (x139 * x261 * x40 + x139 * x265 * x33 + x143 * x261 * x33)
)
result[3, 9] = numpy.sum(
x134 * (x156 * x249 * x40 + x156 * x251 * x33 + x157 * x249 * x33)
)
result[3, 10] = numpy.sum(x180 * (x103 * x286 * x290 + x112 * x286 * x38 + x289 * x5))
result[3, 11] = numpy.sum(
x134 * (x116 * x282 * x290 + x117 * x276 * x38 + x119 * x276 * x31)
)
result[3, 12] = numpy.sum(
x196 * (x139 * x268 * x38 + x139 * x270 * x31 + x143 * x268 * x31)
)
result[3, 13] = numpy.sum(
x134 * (x156 * x261 * x38 + x156 * x265 * x31 + x157 * x261 * x31)
)
result[3, 14] = numpy.sum(
x180 * (x170 * x249 * x38 + x170 * x251 * x31 + x173 * x249 * x31)
)
result[4, 0] = numpy.sum(
x291 * (x174 * x216 * x254 + x176 * x214 * x254 + x217 * x259 * x96)
)
result[4, 1] = numpy.sum(
x292 * (x183 * x214 * x258 + x183 * x216 * x78 + x184 * x214 * x78)
)
result[4, 2] = numpy.sum(
x292 * (x174 * x220 * x258 + x174 * x221 * x78 + x176 * x220 * x78)
)
result[4, 3] = numpy.sum(
x197 * (x188 * x214 * x47 + x188 * x216 * x44 + x194 * x214 * x44)
)
result[4, 4] = numpy.sum(
x293 * (x183 * x220 * x47 + x183 * x221 * x44 + x184 * x220 * x44)
)
result[4, 5] = numpy.sum(
x197 * (x174 * x225 * x47 + x174 * x231 * x44 + x176 * x225 * x44)
)
result[4, 6] = numpy.sum(
x292 * (x205 * x214 * x40 + x205 * x216 * x33 + x208 * x214 * x33)
)
result[4, 7] = numpy.sum(
x293 * (x188 * x220 * x40 + x188 * x221 * x33 + x194 * x220 * x33)
)
result[4, 8] = numpy.sum(
x293 * (x183 * x225 * x40 + x183 * x231 * x33 + x184 * x225 * x33)
)
result[4, 9] = numpy.sum(
x292 * (x174 * x239 * x40 + x174 * x242 * x33 + x176 * x239 * x33)
)
result[4, 10] = numpy.sum(
x291 * (x101 * x213 * x290 + x211 * x214 * x38 + x211 * x216 * x31)
)
result[4, 11] = numpy.sum(
x292 * (x205 * x220 * x38 + x205 * x221 * x31 + x208 * x220 * x31)
)
result[4, 12] = numpy.sum(
x197 * (x188 * x225 * x38 + x188 * x231 * x31 + x194 * x225 * x31)
)
result[4, 13] = numpy.sum(
x292 * (x183 * x239 * x38 + x183 * x242 * x31 + x184 * x239 * x31)
)
result[4, 14] = numpy.sum(
x291 * (x174 * x245 * x38 + x176 * x245 * x31 + x247 * x295 * x96)
)
result[5, 0] = numpy.sum(
x180 * (x108 * x259 * x297 + x297 * x300 * x98 + x299 * x300)
)
result[5, 1] = numpy.sum(
x134 * (x109 * x258 * x297 + x109 * x299 * x78 + x111 * x297 * x78)
)
result[5, 2] = numpy.sum(x134 * (x108 * x306 * x78 + x258 * x303 + x303 * x78 * x98))
result[5, 3] = numpy.sum(
x196 * (x124 * x297 * x47 + x124 * x299 * x44 + x128 * x297 * x44)
)
result[5, 4] = numpy.sum(
x197 * (x109 * x302 * x47 + x109 * x306 * x44 + x111 * x302 * x44)
)
result[5, 5] = numpy.sum(x196 * (x108 * x309 * x47 + x309 * x312 * x98 + x311 * x312))
result[5, 6] = numpy.sum(
x134 * (x146 * x297 * x40 + x146 * x299 * x33 + x147 * x297 * x33)
)
result[5, 7] = numpy.sum(
x197 * (x124 * x302 * x40 + x124 * x306 * x33 + x128 * x302 * x33)
)
result[5, 8] = numpy.sum(
x197 * (x109 * x309 * x40 + x109 * x311 * x33 + x111 * x309 * x33)
)
result[5, 9] = numpy.sum(x134 * (x108 * x323 * x33 + x318 * x33 * x98 + x318 * x40))
result[5, 10] = numpy.sum(
x180 * (x164 * x297 * x38 + x164 * x299 * x31 + x167 * x297 * x31)
)
result[5, 11] = numpy.sum(
x134 * (x146 * x302 * x38 + x146 * x306 * x31 + x147 * x302 * x31)
)
result[5, 12] = numpy.sum(
x196 * (x124 * x309 * x38 + x124 * x31 * x311 + x128 * x309 * x31)
)
result[5, 13] = numpy.sum(
x134 * (x107 * x295 * x323 + x109 * x317 * x38 + x111 * x31 * x317)
)
result[5, 14] = numpy.sum(x180 * (x108 * x327 * x38 + x295 * x327 * x98 + x329 * x5))
result[6, 0] = numpy.sum(
x106 * (x103 * x330 * x334 + x112 * x330 * x335 + x331 * x334)
)
result[6, 1] = numpy.sum(
x115 * (x103 * x252 * x337 + x112 * x252 * x338 + x257 * x337)
)
result[6, 2] = numpy.sum(
x115 * (x117 * x252 * x331 + x117 * x257 * x330 + x119 * x252 * x330)
)
result[6, 3] = numpy.sum(x132 * (x103 * x24 * x341 + x112 * x24 * x344 + x256 * x341))
result[6, 4] = numpy.sum(
x134 * (x117 * x24 * x338 + x117 * x256 * x336 + x119 * x24 * x336)
)
result[6, 5] = numpy.sum(
x132 * (x139 * x24 * x331 + x139 * x256 * x330 + x143 * x24 * x330)
)
result[6, 6] = numpy.sum(x115 * (x103 * x345 * x348 + x112 * x20 * x345 + x347 * x6))
result[6, 7] = numpy.sum(
x134 * (x116 * x344 * x348 + x117 * x20 * x340 + x119 * x16 * x340)
)
result[6, 8] = numpy.sum(
x134 * (x139 * x16 * x338 + x139 * x20 * x336 + x143 * x16 * x336)
)
result[6, 9] = numpy.sum(
x115 * (x156 * x16 * x331 + x156 * x20 * x330 + x157 * x16 * x330)
)
result[6, 10] = numpy.sum(
x106
* (
x10 * x351
+ x103 * x351
+ x288
* (
x107 * x346
- x11 * (-2.0 * bx * x350 + 3.0 * x274 + x349)
+ 3.0 * x2 * (2.0 * x278 + x279 + x281 + x342 + x343)
)
)
)
result[6, 11] = numpy.sum(
x115 * (x116 * x345 * x352 + x116 * x347 + x119 * x15 * x345)
)
result[6, 12] = numpy.sum(
x132 * (x10 * x139 * x353 + x139 * x15 * x344 + x143 * x353)
)
result[6, 13] = numpy.sum(
x115 * (x10 * x156 * x354 + x15 * x156 * x338 + x157 * x354)
)
result[6, 14] = numpy.sum(
x106 * (x10 * x330 * x355 + x15 * x173 * x330 + x331 * x355)
)
result[7, 0] = numpy.sum(
x180 * (x214 * x249 * x335 + x214 * x251 * x333 + x216 * x249 * x333)
)
result[7, 1] = numpy.sum(
x134 * (x214 * x252 * x265 + x214 * x257 * x261 + x216 * x252 * x261)
)
result[7, 2] = numpy.sum(
x134 * (x220 * x249 * x257 + x220 * x251 * x252 + x221 * x249 * x252)
)
result[7, 3] = numpy.sum(
x196 * (x214 * x24 * x270 + x214 * x256 * x268 + x216 * x24 * x268)
)
result[7, 4] = numpy.sum(
x197 * (x220 * x24 * x265 + x220 * x256 * x261 + x221 * x24 * x261)
)
result[7, 5] = numpy.sum(
x196 * (x225 * x24 * x251 + x225 * x249 * x256 + x231 * x24 * x249)
)
result[7, 6] = numpy.sum(
x134 * (x101 * x282 * x348 + x16 * x216 * x276 + x20 * x214 * x276)
)
result[7, 7] = numpy.sum(
x197 * (x16 * x220 * x270 + x16 * x221 * x268 + x20 * x220 * x268)
)
result[7, 8] = numpy.sum(
x197 * (x16 * x225 * x265 + x16 * x231 * x261 + x20 * x225 * x261)
)
result[7, 9] = numpy.sum(
x134 * (x16 * x239 * x251 + x16 * x242 * x249 + x20 * x239 * x249)
)
result[7, 10] = numpy.sum(
x180 * (x101 * x286 * x352 + x101 * x289 + x15 * x216 * x286)
)
result[7, 11] = numpy.sum(
x134 * (x10 * x220 * x356 + x15 * x220 * x282 + x221 * x356)
)
result[7, 12] = numpy.sum(
x196 * (x10 * x268 * x357 + x15 * x231 * x268 + x270 * x357)
)
result[7, 13] = numpy.sum(
x134 * (x10 * x239 * x358 + x15 * x239 * x265 + x242 * x358)
)
result[7, 14] = numpy.sum(
x180 * (x10 * x249 * x359 + x15 * x247 * x249 + x251 * x359)
)
result[8, 0] = numpy.sum(
x180 * (x174 * x297 * x335 + x174 * x299 * x333 + x176 * x297 * x333)
)
result[8, 1] = numpy.sum(
x134 * (x183 * x252 * x299 + x183 * x257 * x297 + x184 * x252 * x297)
)
result[8, 2] = numpy.sum(
x134 * (x174 * x252 * x306 + x174 * x257 * x302 + x176 * x252 * x302)
)
result[8, 3] = numpy.sum(
x196 * (x188 * x24 * x299 + x188 * x256 * x297 + x194 * x24 * x297)
)
result[8, 4] = numpy.sum(
x197 * (x183 * x24 * x306 + x183 * x256 * x302 + x184 * x24 * x302)
)
result[8, 5] = numpy.sum(
x196 * (x174 * x24 * x311 + x174 * x256 * x309 + x176 * x24 * x309)
)
result[8, 6] = numpy.sum(
x134 * (x16 * x205 * x299 + x16 * x208 * x297 + x20 * x205 * x297)
)
result[8, 7] = numpy.sum(
x197 * (x16 * x188 * x306 + x16 * x194 * x302 + x188 * x20 * x302)
)
result[8, 8] = numpy.sum(
x197 * (x16 * x183 * x311 + x16 * x184 * x309 + x183 * x20 * x309)
)
result[8, 9] = numpy.sum(
x134 * (x16 * x176 * x317 + x174 * x20 * x317 + x323 * x360 * x6)
)
result[8, 10] = numpy.sum(
x180 * (x10 * x297 * x361 + x15 * x213 * x297 + x299 * x361)
)
result[8, 11] = numpy.sum(
x134 * (x10 * x205 * x362 + x15 * x205 * x306 + x208 * x362)
)
result[8, 12] = numpy.sum(
x196 * (x10 * x309 * x363 + x15 * x194 * x309 + x311 * x363)
)
result[8, 13] = numpy.sum(
x134 * (x10 * x183 * x364 + x15 * x183 * x323 + x184 * x364)
)
result[8, 14] = numpy.sum(x180 * (x10 * x327 * x360 + x15 * x176 * x327 + x329 * x96))
result[9, 0] = numpy.sum(
x106 * (x108 * x335 * x365 + x365 * x367 * x98 + x366 * x367)
)
result[9, 1] = numpy.sum(
x115 * (x109 * x252 * x366 + x109 * x257 * x365 + x111 * x252 * x365)
)
result[9, 2] = numpy.sum(
x115 * (x108 * x252 * x370 + x252 * x369 * x98 + x257 * x369)
)
result[9, 3] = numpy.sum(
x132 * (x124 * x24 * x366 + x124 * x256 * x365 + x128 * x24 * x365)
)
result[9, 4] = numpy.sum(
x134 * (x109 * x24 * x370 + x109 * x256 * x368 + x111 * x24 * x368)
)
result[9, 5] = numpy.sum(x132 * (x108 * x24 * x376 + x24 * x373 * x98 + x256 * x373))
result[9, 6] = numpy.sum(
x115 * (x146 * x16 * x366 + x146 * x20 * x365 + x147 * x16 * x365)
)
result[9, 7] = numpy.sum(
x134 * (x124 * x16 * x370 + x124 * x20 * x368 + x128 * x16 * x368)
)
result[9, 8] = numpy.sum(
x134 * (x107 * x376 * x377 + x109 * x20 * x372 + x111 * x16 * x372)
)
result[9, 9] = numpy.sum(x115 * (x108 * x20 * x378 + x377 * x378 * x98 + x380 * x6))
result[9, 10] = numpy.sum(
x106 * (x10 * x365 * x381 + x15 * x167 * x365 + x366 * x381)
)
result[9, 11] = numpy.sum(
x115 * (x10 * x146 * x382 + x146 * x15 * x370 + x147 * x382)
)
result[9, 12] = numpy.sum(
x132 * (x10 * x124 * x383 + x124 * x15 * x376 + x128 * x383)
)
result[9, 13] = numpy.sum(
x115 * (x10 * x107 * x294 * x378 + x107 * x380 + x111 * x15 * x378)
)
result[9, 14] = numpy.sum(
x106
* (
x10 * x386
+ x294
* (
-x11 * (-2.0 * bx * x385 + 3.0 * x315 + x384)
+ x116 * x379
+ 3.0 * x2 * (2.0 * x319 + x320 + x322 + x374 + x375)
)
+ x386 * x98
)
)
return result
[docs]
def kinetic3d_40(ax, da, A, bx, db, B):
"""Cartesian 3D (gs) kinetic energy integral.
Generated code; DO NOT modify by hand!"""
result = numpy.zeros((15, 1), dtype=float)
x0 = 2.0 * ax
x1 = (2.0 * bx + x0) ** (-1.0)
x2 = (ax + bx) ** (-1.0)
x3 = x2 * (ax * A[0] + bx * B[0]) - A[0]
x4 = -ax
x5 = x3**2
x6 = 2.0 * ax**2
x7 = -x4 - x6 * (x1 + x5)
x8 = bx * x2
x9 = ax * x8
x10 = numpy.exp(-x9 * (A[0] - B[0]) ** 2)
x11 = 1.772453850905516 * numpy.sqrt(x2)
x12 = x10 * x11
x13 = x12 * x3
x14 = x13 * x7
x15 = x0 * x8
x16 = x13 * x15 + x14
x17 = x16 * x3
x18 = x12 * x5
x19 = x1 * x12
x20 = x18 + x19
x21 = x8 * (x0 * x20 - x12)
x22 = x19 * x7
x23 = 4.0 * x9
x24 = x17 + x21 + x22
x25 = x3 * (2.0 * x19 + x20)
x26 = x1 * (x13 * x23 + 2.0 * x14) + x24 * x3 + x8 * (x0 * x25 - 2.0 * x13)
x27 = 3.0 * x18 + 3.0 * x19
x28 = x1 * x27 + x25 * x3
x29 = numpy.exp(-x9 * (A[1] - B[1]) ** 2)
x30 = numpy.exp(-x9 * (A[2] - B[2]) ** 2)
x31 = 3.141592653589793 * x2 * x30
x32 = x29 * x31
x33 = x2 * (ax * A[1] + bx * B[1]) - A[1]
x34 = x33**2
x35 = -x4 - x6 * (x1 + x34)
x36 = x28 * x32
x37 = x2 * (ax * A[2] + bx * B[2]) - A[2]
x38 = x37**2
x39 = -x4 - x6 * (x1 + x38)
x40 = da * db
x41 = 0.09759000729485332 * x40
x42 = x11 * x29
x43 = x33 * x42
x44 = x35 * x43
x45 = x15 * x43 + x44
x46 = x11 * x30
x47 = x45 * x46
x48 = x26 * x32
x49 = x25 * x32
x50 = 0.2581988897471611 * x40
x51 = x37 * x46
x52 = x39 * x51
x53 = x15 * x51 + x52
x54 = x33 * x45
x55 = x34 * x42
x56 = x1 * x42
x57 = x55 + x56
x58 = x8 * (x0 * x57 - x42)
x59 = x35 * x56
x60 = x54 + x58 + x59
x61 = x20 * x46
x62 = 0.3333333333333333 * x40
x63 = 1.732050807568877 * x62
x64 = x37 * x53
x65 = x38 * x46
x66 = x1 * x46
x67 = x65 + x66
x68 = x8 * (x0 * x67 - x46)
x69 = x39 * x66
x70 = x64 + x68 + x69
x71 = x20 * x42
x72 = x33 * (2.0 * x56 + x57)
x73 = x1 * (x23 * x43 + 2.0 * x44) + x33 * x60 + x8 * (x0 * x72 - 2.0 * x43)
x74 = x10 * x31
x75 = x73 * x74
x76 = x3 * x74
x77 = 3.141592653589793 * x10 * x2 * x29
x78 = x3 * x77
x79 = x37 * (2.0 * x66 + x67)
x80 = x1 * (x23 * x51 + 2.0 * x52) + x37 * x70 + x8 * (x0 * x79 - 2.0 * x51)
x81 = x77 * x80
x82 = 3.0 * x55 + 3.0 * x56
x83 = x1 * x82 + x33 * x72
x84 = x74 * x83
x85 = x12 * x57
x86 = 3.0 * x65 + 3.0 * x66
x87 = x1 * x86 + x37 * x79
x88 = x77 * x87
# 15 item(s)
result[0, 0] = numpy.sum(
x41
* (
x32 * (3.0 * x1 * (x17 + x21 + x22) + x26 * x3 + x8 * (2.0 * ax * x28 - x27))
+ x35 * x36
+ x36 * x39
)
)
result[1, 0] = numpy.sum(x50 * (x25 * x47 + x33 * x39 * x49 + x33 * x48))
result[2, 0] = numpy.sum(x50 * (x25 * x42 * x53 + x35 * x37 * x49 + x37 * x48))
result[3, 0] = numpy.sum(x62 * (x24 * x46 * x57 + x39 * x57 * x61 + x60 * x61))
result[4, 0] = numpy.sum(
x63 * (x20 * x37 * x47 + x20 * x43 * x53 + x24 * x32 * x33 * x37)
)
result[5, 0] = numpy.sum(x62 * (x24 * x42 * x67 + x35 * x67 * x71 + x70 * x71))
result[6, 0] = numpy.sum(x50 * (x16 * x46 * x72 + x3 * x75 + x39 * x72 * x76))
result[7, 0] = numpy.sum(x63 * (x13 * x53 * x57 + x16 * x51 * x57 + x37 * x60 * x76))
result[8, 0] = numpy.sum(x63 * (x13 * x45 * x67 + x16 * x43 * x67 + x33 * x70 * x78))
result[9, 0] = numpy.sum(x50 * (x16 * x42 * x79 + x3 * x81 + x35 * x78 * x79))
result[10, 0] = numpy.sum(
x41
* (
x39 * x84
+ x7 * x84
+ x74
* (3.0 * x1 * (x54 + x58 + x59) + x33 * x73 + x8 * (2.0 * ax * x83 - x82))
)
)
result[11, 0] = numpy.sum(x50 * (x12 * x53 * x72 + x37 * x7 * x72 * x74 + x37 * x75))
result[12, 0] = numpy.sum(x62 * (x12 * x60 * x67 + x67 * x7 * x85 + x70 * x85))
result[13, 0] = numpy.sum(x50 * (x12 * x45 * x79 + x33 * x7 * x77 * x79 + x33 * x81))
result[14, 0] = numpy.sum(
x41
* (
x35 * x88
+ x7 * x88
+ x77
* (3.0 * x1 * (x64 + x68 + x69) + x37 * x80 + x8 * (2.0 * ax * x87 - x86))
)
)
return result
[docs]
def kinetic3d_41(ax, da, A, bx, db, B):
"""Cartesian 3D (gp) kinetic energy integral.
Generated code; DO NOT modify by hand!"""
result = numpy.zeros((15, 3), dtype=float)
x0 = 2.0 * ax
x1 = (2.0 * bx + x0) ** (-1.0)
x2 = -ax
x3 = (ax + bx) ** (-1.0)
x4 = -x3 * (ax * A[0] + bx * B[0])
x5 = -x4 - A[0]
x6 = x5**2
x7 = 2.0 * ax**2
x8 = -x2 - x7 * (x1 + x6)
x9 = bx * x3
x10 = ax * x9
x11 = numpy.exp(-x10 * (A[0] - B[0]) ** 2)
x12 = 1.772453850905516 * numpy.sqrt(x3)
x13 = x11 * x12
x14 = x13 * x5
x15 = x14 * x8
x16 = x0 * x9
x17 = x14 * x16 + x15
x18 = -x4 - B[0]
x19 = x13 * x18
x20 = x19 * (x16 + x8)
x21 = x1 * (x17 + x20)
x22 = x20 * x5
x23 = x1 * x13
x24 = x14 * x18
x25 = x23 + x24
x26 = x23 * x8
x27 = x16 * x25 + x22 + x26
x28 = x27 * x5
x29 = x1 * (x14 + x19)
x30 = x25 * x5
x31 = x29 + x30
x32 = x9 * (x0 * x31 - x19)
x33 = 4.0 * x10
x34 = x17 * x5
x35 = x13 * x6
x36 = x23 + x35
x37 = x9 * (x0 * x36 - x13)
x38 = x34 + x37
x39 = x26 + x38
x40 = 2.0 * x23
x41 = x5 * (x36 + x40)
x42 = x1 * (x14 * x33 + 2.0 * x15) + x39 * x5 + x9 * (x0 * x41 - 2.0 * x14)
x43 = 3.0 * x26
x44 = x21 + x28 + x32
x45 = 3.0 * x23
x46 = 2.0 * x24
x47 = x1 * (x35 + x45 + x46) + x31 * x5
x48 = (
x1 * (2.0 * x22 + x25 * x33 + x38 + x43)
+ x44 * x5
- x9 * (-2.0 * ax * x47 + x40 + x46)
)
x49 = 3.0 * x29 + 3.0 * x30
x50 = x1 * (x41 + x49) + x47 * x5
x51 = numpy.exp(-x10 * (A[1] - B[1]) ** 2)
x52 = numpy.exp(-x10 * (A[2] - B[2]) ** 2)
x53 = 3.141592653589793 * x3 * x52
x54 = x51 * x53
x55 = -x3 * (ax * A[1] + bx * B[1])
x56 = -x55 - A[1]
x57 = x56**2
x58 = -x2 - x7 * (x1 + x57)
x59 = x50 * x54
x60 = -x3 * (ax * A[2] + bx * B[2])
x61 = -x60 - A[2]
x62 = x61**2
x63 = -x2 - x7 * (x1 + x62)
x64 = da * db
x65 = 0.09759000729485332 * x64
x66 = -x55 - B[1]
x67 = x12 * x51
x68 = x66 * x67
x69 = x68 * (x16 + x58)
x70 = 3.0 * x35 + x45
x71 = x1 * x70 + x41 * x5
x72 = x12 * x52
x73 = x54 * (
x1 * (3.0 * x34 + 3.0 * x37 + x43) + x42 * x5 + x9 * (2.0 * ax * x71 - x70)
)
x74 = x54 * x71
x75 = -x60 - B[2]
x76 = x72 * x75
x77 = x76 * (x16 + x63)
x78 = x56 * x67
x79 = x58 * x78
x80 = x16 * x78 + x79
x81 = x48 * x54
x82 = x54 * x56
x83 = 0.2581988897471611 * x64
x84 = x56 * x69
x85 = x1 * x67
x86 = x66 * x78
x87 = x85 + x86
x88 = x58 * x85
x89 = x16 * x87 + x84 + x88
x90 = x41 * x72
x91 = x61 * x72
x92 = x63 * x91
x93 = x16 * x91 + x92
x94 = x54 * x61
x95 = x61 * x77
x96 = x1 * x72
x97 = x75 * x91
x98 = x96 + x97
x99 = x63 * x96
x100 = x16 * x98 + x95 + x99
x101 = x41 * x67
x102 = x56 * x80
x103 = x57 * x67
x104 = x103 + x85
x105 = x9 * (x0 * x104 - x67)
x106 = x102 + x105
x107 = x106 + x88
x108 = x31 * x72
x109 = 0.3333333333333333 * x64
x110 = x1 * (x68 + x78)
x111 = x56 * x87
x112 = x110 + x111
x113 = x112 * x72
x114 = x1 * (x69 + x80)
x115 = x56 * x89
x116 = x9 * (x0 * x112 - x68)
x117 = x114 + x115 + x116
x118 = 1.732050807568877 * x109
x119 = x61 * x93
x120 = x62 * x72
x121 = x120 + x96
x122 = x9 * (x0 * x121 - x72)
x123 = x119 + x122
x124 = x123 + x99
x125 = x31 * x67
x126 = x1 * (x76 + x91)
x127 = x61 * x98
x128 = x126 + x127
x129 = x128 * x67
x130 = x1 * (x77 + x93)
x131 = x100 * x61
x132 = x9 * (x0 * x128 - x76)
x133 = x130 + x131 + x132
x134 = 2.0 * x85
x135 = x56 * (x104 + x134)
x136 = x135 * x72
x137 = x1 * (x33 * x78 + 2.0 * x79) + x107 * x56 + x9 * (x0 * x135 - 2.0 * x78)
x138 = 3.0 * x85
x139 = 2.0 * x86
x140 = x1 * (x103 + x138 + x139) + x112 * x56
x141 = 3.0 * x88
x142 = (
x1 * (x106 + x141 + x33 * x87 + 2.0 * x84)
+ x117 * x56
- x9 * (-2.0 * ax * x140 + x134 + x139)
)
x143 = x11 * x53
x144 = x142 * x143
x145 = x143 * x5
x146 = 3.141592653589793 * x11 * x3 * x51
x147 = x146 * x5
x148 = 2.0 * x96
x149 = x61 * (x121 + x148)
x150 = x149 * x67
x151 = x1 * (x33 * x91 + 2.0 * x92) + x124 * x61 + x9 * (x0 * x149 - 2.0 * x91)
x152 = 3.0 * x96
x153 = 2.0 * x97
x154 = x1 * (x120 + x152 + x153) + x128 * x61
x155 = 3.0 * x99
x156 = (
x1 * (x123 + x155 + x33 * x98 + 2.0 * x95)
+ x133 * x61
- x9 * (-2.0 * ax * x154 + x148 + x153)
)
x157 = x146 * x156
x158 = 3.0 * x103 + x138
x159 = x1 * x158 + x135 * x56
x160 = x143 * (
x1 * (3.0 * x102 + 3.0 * x105 + x141) + x137 * x56 + x9 * (2.0 * ax * x159 - x158)
)
x161 = x143 * x159
x162 = 3.0 * x110 + 3.0 * x111
x163 = x1 * (x135 + x162) + x140 * x56
x164 = x143 * x163
x165 = x143 * x61
x166 = x13 * x135
x167 = x112 * x13
x168 = x128 * x13
x169 = x146 * x56
x170 = x13 * x149
x171 = 3.0 * x120 + x152
x172 = x1 * x171 + x149 * x61
x173 = x146 * (
x1 * (3.0 * x119 + 3.0 * x122 + x155) + x151 * x61 + x9 * (2.0 * ax * x172 - x171)
)
x174 = x146 * x172
x175 = 3.0 * x126 + 3.0 * x127
x176 = x1 * (x149 + x175) + x154 * x61
x177 = x146 * x176
# 45 item(s)
result[0, 0] = numpy.sum(
x65
* (
x54
* (
x1 * (3.0 * x21 + 3.0 * x28 + 3.0 * x32 + x42)
+ x48 * x5
+ x9 * (2.0 * ax * x50 - x49)
)
+ x58 * x59
+ x59 * x63
)
)
result[0, 1] = numpy.sum(x65 * (x63 * x66 * x74 + x66 * x73 + x69 * x71 * x72))
result[0, 2] = numpy.sum(x65 * (x58 * x74 * x75 + x67 * x71 * x77 + x73 * x75))
result[1, 0] = numpy.sum(x83 * (x47 * x63 * x82 + x47 * x72 * x80 + x56 * x81))
result[1, 1] = numpy.sum(x83 * (x42 * x72 * x87 + x63 * x87 * x90 + x89 * x90))
result[1, 2] = numpy.sum(x83 * (x41 * x76 * x80 + x41 * x77 * x78 + x42 * x75 * x82))
result[2, 0] = numpy.sum(x83 * (x47 * x58 * x94 + x47 * x67 * x93 + x61 * x81))
result[2, 1] = numpy.sum(x83 * (x41 * x68 * x93 + x41 * x69 * x91 + x42 * x66 * x94))
result[2, 2] = numpy.sum(x83 * (x100 * x101 + x101 * x58 * x98 + x42 * x67 * x98))
result[3, 0] = numpy.sum(x109 * (x104 * x108 * x63 + x104 * x44 * x72 + x107 * x108))
result[3, 1] = numpy.sum(x109 * (x113 * x36 * x63 + x113 * x39 + x117 * x36 * x72))
result[3, 2] = numpy.sum(
x109 * (x104 * x36 * x77 + x104 * x39 * x76 + x107 * x36 * x76)
)
result[4, 0] = numpy.sum(x118 * (x31 * x78 * x93 + x31 * x80 * x91 + x44 * x61 * x82))
result[4, 1] = numpy.sum(x118 * (x36 * x87 * x93 + x36 * x89 * x91 + x39 * x87 * x91))
result[4, 2] = numpy.sum(
x118 * (x100 * x36 * x78 + x36 * x80 * x98 + x39 * x78 * x98)
)
result[5, 0] = numpy.sum(x109 * (x121 * x125 * x58 + x121 * x44 * x67 + x124 * x125))
result[5, 1] = numpy.sum(
x109 * (x121 * x36 * x69 + x121 * x39 * x68 + x124 * x36 * x68)
)
result[5, 2] = numpy.sum(x109 * (x129 * x36 * x58 + x129 * x39 + x133 * x36 * x67))
result[6, 0] = numpy.sum(x83 * (x136 * x25 * x63 + x136 * x27 + x137 * x25 * x72))
result[6, 1] = numpy.sum(x83 * (x140 * x145 * x63 + x140 * x17 * x72 + x144 * x5))
result[6, 2] = numpy.sum(
x83 * (x135 * x14 * x77 + x135 * x17 * x76 + x137 * x145 * x75)
)
result[7, 0] = numpy.sum(
x118 * (x104 * x25 * x93 + x104 * x27 * x91 + x107 * x25 * x91)
)
result[7, 1] = numpy.sum(
x118 * (x112 * x14 * x93 + x112 * x17 * x91 + x117 * x145 * x61)
)
result[7, 2] = numpy.sum(
x118 * (x100 * x104 * x14 + x104 * x17 * x98 + x107 * x14 * x98)
)
result[8, 0] = numpy.sum(
x118 * (x121 * x25 * x80 + x121 * x27 * x78 + x124 * x25 * x78)
)
result[8, 1] = numpy.sum(
x118 * (x121 * x14 * x89 + x121 * x17 * x87 + x124 * x14 * x87)
)
result[8, 2] = numpy.sum(
x118 * (x128 * x14 * x80 + x128 * x17 * x78 + x133 * x147 * x56)
)
result[9, 0] = numpy.sum(x83 * (x150 * x25 * x58 + x150 * x27 + x151 * x25 * x67))
result[9, 1] = numpy.sum(
x83 * (x14 * x149 * x69 + x147 * x151 * x66 + x149 * x17 * x68)
)
result[9, 2] = numpy.sum(x83 * (x147 * x154 * x58 + x154 * x17 * x67 + x157 * x5))
result[10, 0] = numpy.sum(x65 * (x159 * x20 * x72 + x160 * x18 + x161 * x18 * x63))
result[10, 1] = numpy.sum(
x65
* (
x143
* (
x1 * (3.0 * x114 + 3.0 * x115 + 3.0 * x116 + x137)
+ x142 * x56
+ x9 * (2.0 * ax * x163 - x162)
)
+ x164 * x63
+ x164 * x8
)
)
result[10, 2] = numpy.sum(x65 * (x13 * x159 * x77 + x160 * x75 + x161 * x75 * x8))
result[11, 0] = numpy.sum(
x83 * (x135 * x19 * x93 + x135 * x20 * x91 + x137 * x165 * x18)
)
result[11, 1] = numpy.sum(x83 * (x13 * x140 * x93 + x140 * x165 * x8 + x144 * x61))
result[11, 2] = numpy.sum(x83 * (x100 * x166 + x13 * x137 * x98 + x166 * x8 * x98))
result[12, 0] = numpy.sum(
x109 * (x104 * x121 * x20 + x104 * x124 * x19 + x107 * x121 * x19)
)
result[12, 1] = numpy.sum(x109 * (x117 * x121 * x13 + x121 * x167 * x8 + x124 * x167))
result[12, 2] = numpy.sum(x109 * (x104 * x13 * x133 + x104 * x168 * x8 + x107 * x168))
result[13, 0] = numpy.sum(
x83 * (x149 * x19 * x80 + x149 * x20 * x78 + x151 * x169 * x18)
)
result[13, 1] = numpy.sum(x83 * (x13 * x151 * x87 + x170 * x8 * x87 + x170 * x89))
result[13, 2] = numpy.sum(x83 * (x13 * x154 * x80 + x154 * x169 * x8 + x157 * x56))
result[14, 0] = numpy.sum(x65 * (x172 * x20 * x67 + x173 * x18 + x174 * x18 * x58))
result[14, 1] = numpy.sum(x65 * (x13 * x172 * x69 + x173 * x66 + x174 * x66 * x8))
result[14, 2] = numpy.sum(
x65
* (
x146
* (
x1 * (3.0 * x130 + 3.0 * x131 + 3.0 * x132 + x151)
+ x156 * x61
+ x9 * (2.0 * ax * x176 - x175)
)
+ x177 * x58
+ x177 * x8
)
)
return result
[docs]
def kinetic3d_42(ax, da, A, bx, db, B):
"""Cartesian 3D (gd) kinetic energy integral.
Generated code; DO NOT modify by hand!"""
result = numpy.zeros((15, 6), dtype=float)
x0 = 2.0 * ax
x1 = 2.0 * bx
x2 = (x0 + x1) ** (-1.0)
x3 = (ax + bx) ** (-1.0)
x4 = -x3 * (ax * A[0] + bx * B[0])
x5 = -x4 - A[0]
x6 = -ax
x7 = x5**2
x8 = 2.0 * ax**2
x9 = -x6 - x8 * (x2 + x7)
x10 = bx * x3
x11 = ax * x10
x12 = numpy.exp(-x11 * (A[0] - B[0]) ** 2)
x13 = 1.772453850905516 * numpy.sqrt(x3)
x14 = x12 * x13
x15 = x14 * x5
x16 = x15 * x9
x17 = x0 * x10
x18 = x15 * x17 + x16
x19 = x18 * x5
x20 = x14 * x7
x21 = x14 * x2
x22 = x20 + x21
x23 = -x14
x24 = x10 * (x0 * x22 + x23)
x25 = x19 + x24
x26 = x21 * x9
x27 = 3.0 * x26
x28 = -x4 - B[0]
x29 = x14 * x28
x30 = x29 * (x17 + x9)
x31 = x30 * x5
x32 = x15 * x28
x33 = x21 + x32
x34 = 4.0 * x11
x35 = x27 + 2.0 * x31 + x33 * x34
x36 = x2 * (x25 + x35)
x37 = x2 * (x18 + x30)
x38 = x17 * x33 + x26 + x31
x39 = x38 * x5
x40 = x2 * (x15 + x29)
x41 = x33 * x5
x42 = x40 + x41
x43 = x0 * x42 - x29
x44 = x10 * x43
x45 = x37 + x39 + x44
x46 = x45 * x5
x47 = x14 * x28**2
x48 = x21 + x47
x49 = ax * x3
x50 = x28 * x30 + x49 * (x1 * x48 + x23)
x51 = x2 * (x35 + x50)
x52 = x28 * x38
x53 = x28 * x33
x54 = x40 + x53
x55 = x1 * x54 - x15
x56 = x37 + x49 * x55 + x52
x57 = x5 * x56
x58 = 3.0 * x21
x59 = 2.0 * x32
x60 = x58 + x59
x61 = x2 * (x20 + x60)
x62 = x42 * x5
x63 = x61 + x62
x64 = 2.0 * x21
x65 = 2.0 * ax * x63 - x59 - x64
x66 = x1 * x3
x67 = x2 * (x47 + x60)
x68 = x5 * x54
x69 = x67 + x68
x70 = x10 * (2.0 * ax * x69 - x48)
x71 = x0 * x3
x72 = x51 + x57 + x70
x73 = 2.0 * x53
x74 = x2 * (4.0 * x40 + 2.0 * x41 + x73) + x5 * x69
x75 = (
-x10 * (-2.0 * ax * x74 + 2.0 * x40 + x73)
+ x2 * (4.0 * x37 + 2.0 * x39 + x43 * x66 + 2.0 * x52 + x55 * x71)
+ x5 * x72
)
x76 = 3.0 * x67 + 3.0 * x68
x77 = x2 * (2.0 * x61 + 2.0 * x62 + x76) + x5 * x74
x78 = numpy.exp(-x11 * (A[1] - B[1]) ** 2)
x79 = numpy.exp(-x11 * (A[2] - B[2]) ** 2)
x80 = 3.141592653589793 * x3 * x79
x81 = x78 * x80
x82 = -x3 * (ax * A[1] + bx * B[1])
x83 = -x82 - A[1]
x84 = x83**2
x85 = -x6 - x8 * (x2 + x84)
x86 = x77 * x81
x87 = -x3 * (ax * A[2] + bx * B[2])
x88 = -x87 - A[2]
x89 = x88**2
x90 = -x6 - x8 * (x2 + x89)
x91 = da * db
x92 = 0.009523809523809524 * x91
x93 = 5.916079783099616 * x92
x94 = -x82 - B[1]
x95 = x13 * x78
x96 = x94 * x95
x97 = x96 * (x17 + x85)
x98 = x5 * (x22 + x64)
x99 = 3.0 * x40 + 3.0 * x41
x100 = x2 * (x98 + x99) + x5 * x63
x101 = x13 * x79
x102 = x25 + x26
x103 = x10 * (x0 * x98 - 2.0 * x15) + x102 * x5 + x2 * (x15 * x34 + 2.0 * x16)
x104 = x10 * x65 + x36 + x46
x105 = x81 * (
x10 * (2.0 * ax * x100 - x99)
+ x104 * x5
+ x2 * (x103 + 3.0 * x37 + 3.0 * x39 + 3.0 * x44)
)
x106 = x100 * x81
x107 = 10.2469507659596 * x92
x108 = -x87 - B[2]
x109 = x101 * x108
x110 = x109 * (x17 + x90)
x111 = x2 * x95
x112 = x111 * x85
x113 = x94**2 * x95
x114 = x111 + x113
x115 = -x95
x116 = x49 * (x1 * x114 + x115) + x94 * x97
x117 = x112 + x116
x118 = 3.0 * x20 + x58
x119 = x118 * x2 + x5 * x98
x120 = x101 * x119
x121 = x10 * (2.0 * ax * x119 - x118) + x103 * x5 + x2 * (3.0 * x19 + 3.0 * x24 + x27)
x122 = x108 * x81
x123 = x101 * x2
x124 = x123 * x90
x125 = x101 * x108**2
x126 = x123 + x125
x127 = -x101
x128 = x108 * x110 + x49 * (x1 * x126 + x127)
x129 = x124 + x128
x130 = x119 * x95
x131 = x83 * x95
x132 = x131 * x85
x133 = x131 * x17 + x132
x134 = x75 * x81
x135 = x74 * x81
x136 = 0.06666666666666667 * x91
x137 = 2.23606797749979 * x136
x138 = x83 * x97
x139 = x131 * x94
x140 = x111 + x139
x141 = x112 + x138 + x140 * x17
x142 = x101 * x63
x143 = 3.872983346207417 * x136
x144 = x2 * (x131 + x96)
x145 = x140 * x94
x146 = x144 + x145
x147 = x101 * x146
x148 = x2 * (x133 + x97)
x149 = x141 * x94
x150 = x1 * x146 - x131
x151 = x148 + x149 + x150 * x49
x152 = x101 * x88
x153 = x152 * x90
x154 = x152 * x17 + x153
x155 = x81 * x88
x156 = x110 * x88
x157 = x108 * x152
x158 = x123 + x157
x159 = x124 + x156 + x158 * x17
x160 = x63 * x95
x161 = x2 * (x109 + x152)
x162 = x108 * x158
x163 = x161 + x162
x164 = x163 * x95
x165 = x2 * (x110 + x154)
x166 = x108 * x159
x167 = x1 * x163 - x152
x168 = x165 + x166 + x167 * x49
x169 = x133 * x83
x170 = x84 * x95
x171 = x111 + x170
x172 = x10 * (x0 * x171 + x115)
x173 = x169 + x172
x174 = x112 + x173
x175 = x101 * x69
x176 = 1.732050807568877
x177 = 0.1111111111111111 * x176 * x91
x178 = x141 * x83
x179 = x140 * x83
x180 = x144 + x179
x181 = x0 * x180 - x96
x182 = x10 * x181
x183 = x148 + x178 + x182
x184 = x101 * x42
x185 = 0.3333333333333333 * x91
x186 = 3.0 * x111
x187 = 2.0 * x139
x188 = x186 + x187
x189 = x2 * (x113 + x188)
x190 = x146 * x83
x191 = x189 + x190
x192 = x101 * x191
x193 = 3.0 * x112
x194 = 2.0 * x138 + x140 * x34 + x193
x195 = x2 * (x116 + x194)
x196 = x151 * x83
x197 = x10 * (2.0 * ax * x191 - x114)
x198 = x195 + x196 + x197
x199 = x176 * x185
x200 = x154 * x88
x201 = x101 * x89
x202 = x123 + x201
x203 = x10 * (x0 * x202 + x127)
x204 = x200 + x203
x205 = x124 + x204
x206 = x69 * x95
x207 = x159 * x88
x208 = x158 * x88
x209 = x161 + x208
x210 = x0 * x209 - x109
x211 = x10 * x210
x212 = x165 + x207 + x211
x213 = x42 * x95
x214 = 3.0 * x123
x215 = 2.0 * x157
x216 = x214 + x215
x217 = x2 * (x125 + x216)
x218 = x163 * x88
x219 = x217 + x218
x220 = x219 * x95
x221 = 3.0 * x124
x222 = 2.0 * x156 + x158 * x34 + x221
x223 = x2 * (x128 + x222)
x224 = x168 * x88
x225 = x10 * (2.0 * ax * x219 - x126)
x226 = x223 + x224 + x225
x227 = 2.0 * x111
x228 = x83 * (x171 + x227)
x229 = x10 * (x0 * x228 - 2.0 * x131) + x174 * x83 + x2 * (x131 * x34 + 2.0 * x132)
x230 = x101 * x54
x231 = x2 * (x170 + x188)
x232 = x180 * x83
x233 = x231 + x232
x234 = x101 * x233
x235 = x2 * (x173 + x194)
x236 = x183 * x83
x237 = 2.0 * ax * x233 - x187 - x227
x238 = x10 * x237 + x235 + x236
x239 = 2.0 * x145
x240 = x191 * x83 + x2 * (4.0 * x144 + 2.0 * x179 + x239)
x241 = (
-x10 * (-2.0 * ax * x240 + 2.0 * x144 + x239)
+ x198 * x83
+ x2 * (4.0 * x148 + 2.0 * x149 + x150 * x71 + 2.0 * x178 + x181 * x66)
)
x242 = x12 * x80
x243 = x241 * x242
x244 = x242 * x5
x245 = 3.141592653589793 * x12 * x3 * x78
x246 = x245 * x5
x247 = 2.0 * x123
x248 = x88 * (x202 + x247)
x249 = x10 * (x0 * x248 - 2.0 * x152) + x2 * (x152 * x34 + 2.0 * x153) + x205 * x88
x250 = x54 * x95
x251 = x2 * (x201 + x216)
x252 = x209 * x88
x253 = x251 + x252
x254 = x253 * x95
x255 = x2 * (x204 + x222)
x256 = x212 * x88
x257 = 2.0 * ax * x253 - x215 - x247
x258 = x10 * x257 + x255 + x256
x259 = 2.0 * x162
x260 = x2 * (4.0 * x161 + 2.0 * x208 + x259) + x219 * x88
x261 = (
-x10 * (-2.0 * ax * x260 + 2.0 * x161 + x259)
+ x2 * (4.0 * x165 + 2.0 * x166 + x167 * x71 + 2.0 * x207 + x210 * x66)
+ x226 * x88
)
x262 = x245 * x261
x263 = x26 + x50
x264 = 3.0 * x170 + x186
x265 = x2 * x264 + x228 * x83
x266 = x101 * x265
x267 = (
x10 * (2.0 * ax * x265 - x264)
+ x2 * (3.0 * x169 + 3.0 * x172 + x193)
+ x229 * x83
)
x268 = 3.0 * x144 + 3.0 * x179
x269 = x2 * (x228 + x268) + x233 * x83
x270 = x242 * (
x10 * (2.0 * ax * x269 - x268)
+ x2 * (3.0 * x148 + 3.0 * x178 + 3.0 * x182 + x229)
+ x238 * x83
)
x271 = x242 * x28
x272 = 3.0 * x189 + 3.0 * x190
x273 = x2 * (2.0 * x231 + 2.0 * x232 + x272) + x240 * x83
x274 = x242 * x273
x275 = x242 * x9
x276 = x14 * x265
x277 = x14 * x233
x278 = x14 * x163
x279 = x14 * x191
x280 = x14 * x180
x281 = x14 * x219
x282 = x245 * x83
x283 = x14 * x146
x284 = x14 * x253
x285 = 3.0 * x201 + x214
x286 = x2 * x285 + x248 * x88
x287 = x286 * x95
x288 = (
x10 * (2.0 * ax * x286 - x285)
+ x2 * (3.0 * x200 + 3.0 * x203 + x221)
+ x249 * x88
)
x289 = x245 * x28
x290 = 3.0 * x161 + 3.0 * x208
x291 = x2 * (x248 + x290) + x253 * x88
x292 = x245 * (
x10 * (2.0 * ax * x291 - x290)
+ x2 * (3.0 * x165 + 3.0 * x207 + 3.0 * x211 + x249)
+ x258 * x88
)
x293 = x14 * x286
x294 = 3.0 * x217 + 3.0 * x218
x295 = x2 * (2.0 * x251 + 2.0 * x252 + x294) + x260 * x88
x296 = x245 * x295
# 90 item(s)
result[0, 0] = numpy.sum(
x93
* (
x81
* (
x10 * (2.0 * ax * x77 - x76)
+ x2
* (2.0 * x36 + 2.0 * x46 + 3.0 * x51 + 3.0 * x57 + x65 * x66 + 3.0 * x70)
+ x5 * x75
)
+ x85 * x86
+ x86 * x90
)
)
result[0, 1] = numpy.sum(x107 * (x100 * x101 * x97 + x105 * x94 + x106 * x90 * x94))
result[0, 2] = numpy.sum(x107 * (x100 * x110 * x95 + x105 * x108 + x106 * x108 * x85))
result[0, 3] = numpy.sum(x93 * (x101 * x114 * x121 + x114 * x120 * x90 + x117 * x120))
result[0, 4] = numpy.sum(
x107 * (x109 * x119 * x97 + x110 * x119 * x96 + x121 * x122 * x94)
)
result[0, 5] = numpy.sum(x93 * (x121 * x126 * x95 + x126 * x130 * x85 + x129 * x130))
result[1, 0] = numpy.sum(x137 * (x101 * x133 * x74 + x134 * x83 + x135 * x83 * x90))
result[1, 1] = numpy.sum(
x143 * (x101 * x104 * x140 + x140 * x142 * x90 + x141 * x142)
)
result[1, 2] = numpy.sum(
x143 * (x104 * x122 * x83 + x109 * x133 * x63 + x110 * x131 * x63)
)
result[1, 3] = numpy.sum(x137 * (x101 * x151 * x98 + x103 * x147 + x147 * x90 * x98))
result[1, 4] = numpy.sum(
x143 * (x103 * x109 * x140 + x109 * x141 * x98 + x110 * x140 * x98)
)
result[1, 5] = numpy.sum(
x137 * (x103 * x126 * x131 + x126 * x133 * x98 + x129 * x131 * x98)
)
result[2, 0] = numpy.sum(x137 * (x134 * x88 + x135 * x85 * x88 + x154 * x74 * x95))
result[2, 1] = numpy.sum(
x143 * (x104 * x155 * x94 + x152 * x63 * x97 + x154 * x63 * x96)
)
result[2, 2] = numpy.sum(x143 * (x104 * x158 * x95 + x158 * x160 * x85 + x159 * x160))
result[2, 3] = numpy.sum(
x137 * (x103 * x114 * x152 + x114 * x154 * x98 + x117 * x152 * x98)
)
result[2, 4] = numpy.sum(
x143 * (x103 * x158 * x96 + x158 * x97 * x98 + x159 * x96 * x98)
)
result[2, 5] = numpy.sum(x137 * (x103 * x164 + x164 * x85 * x98 + x168 * x95 * x98))
result[3, 0] = numpy.sum(x177 * (x101 * x171 * x72 + x171 * x175 * x90 + x174 * x175))
result[3, 1] = numpy.sum(x185 * (x101 * x180 * x45 + x180 * x184 * x90 + x183 * x184))
result[3, 2] = numpy.sum(
x185 * (x109 * x171 * x45 + x109 * x174 * x42 + x110 * x171 * x42)
)
result[3, 3] = numpy.sum(x177 * (x101 * x198 * x22 + x102 * x192 + x192 * x22 * x90))
result[3, 4] = numpy.sum(
x185 * (x102 * x109 * x180 + x109 * x183 * x22 + x110 * x180 * x22)
)
result[3, 5] = numpy.sum(
x177 * (x102 * x126 * x171 + x126 * x174 * x22 + x129 * x171 * x22)
)
result[4, 0] = numpy.sum(
x185 * (x131 * x154 * x69 + x133 * x152 * x69 + x155 * x72 * x83)
)
result[4, 1] = numpy.sum(
x199 * (x140 * x152 * x45 + x140 * x154 * x42 + x141 * x152 * x42)
)
result[4, 2] = numpy.sum(
x199 * (x131 * x158 * x45 + x131 * x159 * x42 + x133 * x158 * x42)
)
result[4, 3] = numpy.sum(
x185 * (x102 * x146 * x152 + x146 * x154 * x22 + x151 * x152 * x22)
)
result[4, 4] = numpy.sum(
x199 * (x102 * x140 * x158 + x140 * x159 * x22 + x141 * x158 * x22)
)
result[4, 5] = numpy.sum(
x185 * (x102 * x131 * x163 + x131 * x168 * x22 + x133 * x163 * x22)
)
result[5, 0] = numpy.sum(x177 * (x202 * x206 * x85 + x202 * x72 * x95 + x205 * x206))
result[5, 1] = numpy.sum(
x185 * (x202 * x42 * x97 + x202 * x45 * x96 + x205 * x42 * x96)
)
result[5, 2] = numpy.sum(x185 * (x209 * x213 * x85 + x209 * x45 * x95 + x212 * x213))
result[5, 3] = numpy.sum(
x177 * (x102 * x114 * x202 + x114 * x205 * x22 + x117 * x202 * x22)
)
result[5, 4] = numpy.sum(
x185 * (x102 * x209 * x96 + x209 * x22 * x97 + x212 * x22 * x96)
)
result[5, 5] = numpy.sum(x177 * (x102 * x220 + x22 * x220 * x85 + x22 * x226 * x95))
result[6, 0] = numpy.sum(x137 * (x101 * x228 * x56 + x228 * x230 * x90 + x229 * x230))
result[6, 1] = numpy.sum(x143 * (x101 * x238 * x33 + x234 * x33 * x90 + x234 * x38))
result[6, 2] = numpy.sum(
x143 * (x109 * x228 * x38 + x109 * x229 * x33 + x110 * x228 * x33)
)
result[6, 3] = numpy.sum(x137 * (x101 * x18 * x240 + x240 * x244 * x90 + x243 * x5))
result[6, 4] = numpy.sum(
x143 * (x108 * x238 * x244 + x109 * x18 * x233 + x110 * x15 * x233)
)
result[6, 5] = numpy.sum(
x137 * (x126 * x15 * x229 + x126 * x18 * x228 + x129 * x15 * x228)
)
result[7, 0] = numpy.sum(
x185 * (x152 * x171 * x56 + x152 * x174 * x54 + x154 * x171 * x54)
)
result[7, 1] = numpy.sum(
x199 * (x152 * x180 * x38 + x152 * x183 * x33 + x154 * x180 * x33)
)
result[7, 2] = numpy.sum(
x199 * (x158 * x171 * x38 + x158 * x174 * x33 + x159 * x171 * x33)
)
result[7, 3] = numpy.sum(
x185 * (x15 * x154 * x191 + x152 * x18 * x191 + x198 * x244 * x88)
)
result[7, 4] = numpy.sum(
x199 * (x15 * x158 * x183 + x15 * x159 * x180 + x158 * x18 * x180)
)
result[7, 5] = numpy.sum(
x185 * (x15 * x163 * x174 + x15 * x168 * x171 + x163 * x171 * x18)
)
result[8, 0] = numpy.sum(
x185 * (x131 * x202 * x56 + x131 * x205 * x54 + x133 * x202 * x54)
)
result[8, 1] = numpy.sum(
x199 * (x140 * x202 * x38 + x140 * x205 * x33 + x141 * x202 * x33)
)
result[8, 2] = numpy.sum(
x199 * (x131 * x209 * x38 + x131 * x212 * x33 + x133 * x209 * x33)
)
result[8, 3] = numpy.sum(
x185 * (x146 * x15 * x205 + x146 * x18 * x202 + x15 * x151 * x202)
)
result[8, 4] = numpy.sum(
x199 * (x140 * x15 * x212 + x140 * x18 * x209 + x141 * x15 * x209)
)
result[8, 5] = numpy.sum(
x185 * (x131 * x18 * x219 + x133 * x15 * x219 + x226 * x246 * x83)
)
result[9, 0] = numpy.sum(x137 * (x248 * x250 * x85 + x248 * x56 * x95 + x249 * x250))
result[9, 1] = numpy.sum(
x143 * (x248 * x33 * x97 + x248 * x38 * x96 + x249 * x33 * x96)
)
result[9, 2] = numpy.sum(x143 * (x254 * x33 * x85 + x254 * x38 + x258 * x33 * x95))
result[9, 3] = numpy.sum(
x137 * (x114 * x15 * x249 + x114 * x18 * x248 + x117 * x15 * x248)
)
result[9, 4] = numpy.sum(
x143 * (x15 * x253 * x97 + x18 * x253 * x96 + x246 * x258 * x94)
)
result[9, 5] = numpy.sum(x137 * (x18 * x260 * x95 + x246 * x260 * x85 + x262 * x5))
result[10, 0] = numpy.sum(x93 * (x101 * x267 * x48 + x263 * x266 + x266 * x48 * x90))
result[10, 1] = numpy.sum(x107 * (x101 * x269 * x30 + x269 * x271 * x90 + x270 * x28))
result[10, 2] = numpy.sum(
x107 * (x108 * x267 * x271 + x109 * x265 * x30 + x110 * x265 * x29)
)
result[10, 3] = numpy.sum(
x93
* (
x242
* (
x10 * (2.0 * ax * x273 - x272)
+ x2
* (
3.0 * x195
+ 3.0 * x196
+ 3.0 * x197
+ 2.0 * x235
+ 2.0 * x236
+ x237 * x66
)
+ x241 * x83
)
+ x274 * x9
+ x274 * x90
)
)
result[10, 4] = numpy.sum(
x107 * (x108 * x269 * x275 + x108 * x270 + x110 * x14 * x269)
)
result[10, 5] = numpy.sum(x93 * (x126 * x14 * x267 + x126 * x276 * x9 + x129 * x276))
result[11, 0] = numpy.sum(
x137 * (x152 * x228 * x263 + x152 * x229 * x48 + x154 * x228 * x48)
)
result[11, 1] = numpy.sum(
x143 * (x152 * x233 * x30 + x154 * x233 * x29 + x238 * x271 * x88)
)
result[11, 2] = numpy.sum(
x143 * (x158 * x228 * x30 + x158 * x229 * x29 + x159 * x228 * x29)
)
result[11, 3] = numpy.sum(x137 * (x14 * x154 * x240 + x240 * x275 * x88 + x243 * x88))
result[11, 4] = numpy.sum(x143 * (x14 * x158 * x238 + x158 * x277 * x9 + x159 * x277))
result[11, 5] = numpy.sum(x137 * (x14 * x168 * x228 + x228 * x278 * x9 + x229 * x278))
result[12, 0] = numpy.sum(
x177 * (x171 * x202 * x263 + x171 * x205 * x48 + x174 * x202 * x48)
)
result[12, 1] = numpy.sum(
x185 * (x180 * x202 * x30 + x180 * x205 * x29 + x183 * x202 * x29)
)
result[12, 2] = numpy.sum(
x185 * (x171 * x209 * x30 + x171 * x212 * x29 + x174 * x209 * x29)
)
result[12, 3] = numpy.sum(x177 * (x14 * x198 * x202 + x202 * x279 * x9 + x205 * x279))
result[12, 4] = numpy.sum(x185 * (x14 * x183 * x209 + x209 * x280 * x9 + x212 * x280))
result[12, 5] = numpy.sum(x177 * (x14 * x171 * x226 + x171 * x281 * x9 + x174 * x281))
result[13, 0] = numpy.sum(
x137 * (x131 * x248 * x263 + x131 * x249 * x48 + x133 * x248 * x48)
)
result[13, 1] = numpy.sum(
x143 * (x140 * x248 * x30 + x140 * x249 * x29 + x141 * x248 * x29)
)
result[13, 2] = numpy.sum(
x143 * (x131 * x253 * x30 + x133 * x253 * x29 + x258 * x28 * x282)
)
result[13, 3] = numpy.sum(x137 * (x14 * x151 * x248 + x248 * x283 * x9 + x249 * x283))
result[13, 4] = numpy.sum(x143 * (x14 * x140 * x258 + x140 * x284 * x9 + x141 * x284))
result[13, 5] = numpy.sum(x137 * (x133 * x14 * x260 + x260 * x282 * x9 + x262 * x83))
result[14, 0] = numpy.sum(x93 * (x263 * x287 + x287 * x48 * x85 + x288 * x48 * x95))
result[14, 1] = numpy.sum(
x107 * (x286 * x29 * x97 + x286 * x30 * x96 + x288 * x289 * x94)
)
result[14, 2] = numpy.sum(x107 * (x28 * x292 + x289 * x291 * x85 + x291 * x30 * x95))
result[14, 3] = numpy.sum(x93 * (x114 * x14 * x288 + x114 * x293 * x9 + x117 * x293))
result[14, 4] = numpy.sum(
x107 * (x14 * x291 * x97 + x245 * x291 * x9 * x94 + x292 * x94)
)
result[14, 5] = numpy.sum(
x93
* (
x245
* (
x10 * (2.0 * ax * x295 - x294)
+ x2
* (
3.0 * x223
+ 3.0 * x224
+ 3.0 * x225
+ 2.0 * x255
+ 2.0 * x256
+ x257 * x66
)
+ x261 * x88
)
+ x296 * x85
+ x296 * x9
)
)
return result
[docs]
def kinetic3d_43(ax, da, A, bx, db, B):
"""Cartesian 3D (gf) kinetic energy integral.
Generated code; DO NOT modify by hand!"""
result = numpy.zeros((15, 10), dtype=float)
x0 = 2.0 * ax
x1 = 2.0 * bx
x2 = (x0 + x1) ** (-1.0)
x3 = (ax + bx) ** (-1.0)
x4 = -x3 * (ax * A[0] + bx * B[0])
x5 = -x4 - A[0]
x6 = -x4 - B[0]
x7 = -ax
x8 = x5**2
x9 = 2.0 * ax**2
x10 = -x7 - x9 * (x2 + x8)
x11 = ax * x3
x12 = bx * x11
x13 = numpy.exp(-x12 * (A[0] - B[0]) ** 2)
x14 = 1.772453850905516 * numpy.sqrt(x3)
x15 = x13 * x14
x16 = x15 * x6
x17 = x10 * x16
x18 = bx * x3
x19 = x0 * x18
x20 = x16 * x19 + x17
x21 = x15 * x6**2
x22 = x15 * x2
x23 = x21 + x22
x24 = -x15
x25 = x11 * (x1 * x23 + x24) + x20 * x6
x26 = x10 * x22
x27 = 3.0 * x26
x28 = x20 * x5
x29 = x15 * x5
x30 = x29 * x6
x31 = x22 + x30
x32 = 4.0 * x12
x33 = x27 + 2.0 * x28 + x31 * x32
x34 = x2 * (x25 + x33)
x35 = x10 * x29
x36 = x19 * x29 + x35
x37 = x2 * (x20 + x36)
x38 = x19 * x31 + x26 + x28
x39 = x38 * x6
x40 = x2 * (x16 + x29)
x41 = x31 * x6
x42 = x40 + x41
x43 = x1 * x42 - x29
x44 = x11 * x43 + x37 + x39
x45 = x44 * x5
x46 = 3.0 * x22
x47 = 2.0 * x30
x48 = x46 + x47
x49 = x2 * (x21 + x48)
x50 = x42 * x5
x51 = x49 + x50
x52 = x18 * (2.0 * ax * x51 - x23)
x53 = x34 + x45 + x52
x54 = x5 * x53
x55 = x53 * x6
x56 = x38 * x5
x57 = x0 * x3
x58 = x31 * x5
x59 = x40 + x58
x60 = x0 * x59 - x16
x61 = x1 * x3
x62 = x2 * (4.0 * x37 + 2.0 * x39 + x43 * x57 + 2.0 * x56 + x60 * x61)
x63 = 2.0 * x58
x64 = 2.0 * x41
x65 = x2 * (4.0 * x40 + x63 + x64)
x66 = x51 * x6
x67 = x65 + x66
x68 = 2.0 * x40
x69 = x11 * (2.0 * bx * x67 - x63 - x68)
x70 = x5 * x51
x71 = x65 + x70
x72 = x18 * (2.0 * ax * x71 - x64 - x68)
x73 = x44 * x6
x74 = x42 * x6
x75 = x49 + x74
x76 = 2.0 * x22
x77 = x47 + x76
x78 = 2.0 * bx * x75 - x77
x79 = 3.0 * x45 + 3.0 * x52
x80 = x55 + x62 + x69
x81 = 2.0 * x74
x82 = 3.0 * x50
x83 = x2 * (5.0 * x49 + x81 + x82) + x5 * x67
x84 = (
-x18 * (-2.0 * ax * x83 + 2.0 * x49 + x81)
+ x2 * (5.0 * x34 + x57 * x78 + 2.0 * x73 + x79)
+ x5 * x80
)
x85 = 3.0 * x66
x86 = x2 * (6.0 * x65 + 3.0 * x70 + x85) + x5 * x83
x87 = numpy.exp(-x12 * (A[1] - B[1]) ** 2)
x88 = numpy.exp(-x12 * (A[2] - B[2]) ** 2)
x89 = 3.141592653589793 * x3 * x88
x90 = x87 * x89
x91 = -x3 * (ax * A[1] + bx * B[1])
x92 = -x91 - A[1]
x93 = x92**2
x94 = -x7 - x9 * (x2 + x93)
x95 = x86 * x90
x96 = -x3 * (ax * A[2] + bx * B[2])
x97 = -x96 - A[2]
x98 = x97**2
x99 = -x7 - x9 * (x2 + x98)
x100 = da * db
x101 = 0.009523809523809524 * x100
x102 = 2.645751311064591 * x101
x103 = -x91 - B[1]
x104 = x14 * x87
x105 = x103 * x104
x106 = x105 * x94
x107 = x105 * x19 + x106
x108 = x15 * x8
x109 = x2 * (x108 + x48)
x110 = x5 * x59
x111 = 3.0 * x49 + x82
x112 = x2 * (2.0 * x109 + 2.0 * x110 + x111) + x5 * x71
x113 = x14 * x88
x114 = x36 * x5
x115 = x108 + x22
x116 = x18 * (x0 * x115 + x24)
x117 = x114 + x116
x118 = x2 * (x117 + x33)
x119 = x18 * x60
x120 = x119 + x37 + x56
x121 = x120 * x5
x122 = x109 + x110
x123 = 2.0 * ax * x122 - x77
x124 = x54 + x62 + x72
x125 = x90 * (
x124 * x5
+ x18 * (2.0 * ax * x112 - x111)
+ x2 * (2.0 * x118 + 2.0 * x121 + x123 * x61 + 3.0 * x34 + x79)
)
x126 = x112 * x90
x127 = 5.916079783099616 * x101
x128 = -x96 - B[2]
x129 = x113 * x128
x130 = x129 * x99
x131 = x129 * x19 + x130
x132 = x104 * x2
x133 = x132 * x94
x134 = x103**2 * x104
x135 = x132 + x134
x136 = -x104
x137 = x103 * x107 + x11 * (x1 * x135 + x136)
x138 = x133 + x137
x139 = x5 * (x115 + x76)
x140 = 3.0 * x40 + 3.0 * x58
x141 = x122 * x5 + x2 * (x139 + x140)
x142 = x113 * x141
x143 = x117 + x26
x144 = x143 * x5 + x18 * (x0 * x139 - 2.0 * x29) + x2 * (x29 * x32 + 2.0 * x35)
x145 = x118 + x121 + x123 * x18
x146 = (
x145 * x5
+ x18 * (2.0 * ax * x141 - x140)
+ x2 * (3.0 * x119 + x144 + 3.0 * x37 + 3.0 * x56)
)
x147 = x128 * x90
x148 = 10.2469507659596 * x101
x149 = x113 * x2
x150 = x149 * x99
x151 = x113 * x128**2
x152 = x149 + x151
x153 = -x113
x154 = x11 * (x1 * x152 + x153) + x128 * x131
x155 = x150 + x154
x156 = x104 * x141
x157 = 2.0 * x132
x158 = x103 * (x135 + x157)
x159 = x103 * x138 + x11 * (x1 * x158 - 2.0 * x105) + x2 * (x105 * x32 + 2.0 * x106)
x160 = 3.0 * x108 + x46
x161 = x139 * x5 + x160 * x2
x162 = x113 * x161
x163 = (
x144 * x5 + x18 * (2.0 * ax * x161 - x160) + x2 * (3.0 * x114 + 3.0 * x116 + x27)
)
x164 = 2.0 * x149
x165 = x128 * (x152 + x164)
x166 = x11 * (x1 * x165 - 2.0 * x129) + x128 * x155 + x2 * (x129 * x32 + 2.0 * x130)
x167 = x104 * x161
x168 = x104 * x92
x169 = x168 * x94
x170 = x168 * x19 + x169
x171 = x84 * x90
x172 = x83 * x90
x173 = 0.06666666666666667 * x100
x174 = x107 * x92
x175 = x103 * x168
x176 = x132 + x175
x177 = x133 + x174 + x176 * x19
x178 = x113 * x71
x179 = 2.23606797749979 * x173
x180 = x2 * (x105 + x168)
x181 = x103 * x176
x182 = x180 + x181
x183 = x113 * x182
x184 = x2 * (x107 + x170)
x185 = x103 * x177
x186 = x1 * x182 - x168
x187 = x11 * x186 + x184 + x185
x188 = 3.872983346207417
x189 = x173 * x188
x190 = 3.0 * x132
x191 = 2.0 * x175
x192 = x190 + x191
x193 = x2 * (x134 + x192)
x194 = x103 * x182
x195 = x193 + x194
x196 = x113 * x195
x197 = 3.0 * x133
x198 = 2.0 * x174 + x176 * x32 + x197
x199 = x2 * (x137 + x198)
x200 = x103 * x187
x201 = x157 + x191
x202 = 2.0 * bx * x195 - x201
x203 = x11 * x202 + x199 + x200
x204 = x113 * x97
x205 = x204 * x99
x206 = x19 * x204 + x205
x207 = x90 * x97
x208 = x131 * x97
x209 = x128 * x204
x210 = x149 + x209
x211 = x150 + x19 * x210 + x208
x212 = x104 * x71
x213 = x2 * (x129 + x204)
x214 = x128 * x210
x215 = x213 + x214
x216 = x104 * x215
x217 = x2 * (x131 + x206)
x218 = x128 * x211
x219 = x1 * x215 - x204
x220 = x11 * x219 + x217 + x218
x221 = 3.0 * x149
x222 = 2.0 * x209
x223 = x221 + x222
x224 = x2 * (x151 + x223)
x225 = x128 * x215
x226 = x224 + x225
x227 = x104 * x226
x228 = 3.0 * x150
x229 = 2.0 * x208 + x210 * x32 + x228
x230 = x2 * (x154 + x229)
x231 = x128 * x220
x232 = x164 + x222
x233 = 2.0 * bx * x226 - x232
x234 = x11 * x233 + x230 + x231
x235 = x170 * x92
x236 = x104 * x93
x237 = x132 + x236
x238 = x18 * (x0 * x237 + x136)
x239 = x235 + x238
x240 = x133 + x239
x241 = x113 * x67
x242 = 0.02222222222222222 * x100 * x188
x243 = x176 * x92
x244 = x180 + x243
x245 = x113 * x244
x246 = x177 * x92
x247 = x0 * x244 - x105
x248 = x18 * x247
x249 = x184 + x246 + x248
x250 = 1.732050807568877
x251 = 0.1111111111111111 * x100 * x250
x252 = x187 * x92
x253 = x182 * x92
x254 = x193 + x253
x255 = x18 * (2.0 * ax * x254 - x135)
x256 = x199 + x252 + x255
x257 = x113 * x59
x258 = 0.3333333333333333 * x100
x259 = 2.0 * x243
x260 = 2.0 * x181
x261 = x2 * (4.0 * x180 + x259 + x260)
x262 = x103 * x254
x263 = x261 + x262
x264 = x113 * x263
x265 = x2 * (4.0 * x184 + 2.0 * x185 + x186 * x57 + 2.0 * x246 + x247 * x61)
x266 = x103 * x256
x267 = 2.0 * x180
x268 = x11 * (2.0 * bx * x263 - x259 - x267)
x269 = x265 + x266 + x268
x270 = x250 * x258
x271 = x206 * x97
x272 = x113 * x98
x273 = x149 + x272
x274 = x18 * (x0 * x273 + x153)
x275 = x271 + x274
x276 = x150 + x275
x277 = x104 * x67
x278 = x210 * x97
x279 = x213 + x278
x280 = x104 * x279
x281 = x211 * x97
x282 = x0 * x279 - x129
x283 = x18 * x282
x284 = x217 + x281 + x283
x285 = x220 * x97
x286 = x215 * x97
x287 = x224 + x286
x288 = x18 * (2.0 * ax * x287 - x152)
x289 = x230 + x285 + x288
x290 = x104 * x59
x291 = 2.0 * x278
x292 = 2.0 * x214
x293 = x2 * (4.0 * x213 + x291 + x292)
x294 = x128 * x287
x295 = x293 + x294
x296 = x104 * x295
x297 = x2 * (4.0 * x217 + 2.0 * x218 + x219 * x57 + 2.0 * x281 + x282 * x61)
x298 = x128 * x289
x299 = 2.0 * x213
x300 = x11 * (2.0 * bx * x295 - x291 - x299)
x301 = x297 + x298 + x300
x302 = x92 * (x157 + x237)
x303 = x18 * (x0 * x302 - 2.0 * x168) + x2 * (x168 * x32 + 2.0 * x169) + x240 * x92
x304 = x113 * x75
x305 = x11 * x78 + x34 + x73
x306 = x2 * (x198 + x239)
x307 = x249 * x92
x308 = x2 * (x192 + x236)
x309 = x244 * x92
x310 = x308 + x309
x311 = 2.0 * ax * x310 - x201
x312 = x18 * x311 + x306 + x307
x313 = x113 * x42
x314 = x254 * x92
x315 = x261 + x314
x316 = x113 * x315
x317 = x256 * x92
x318 = x18 * (2.0 * ax * x315 - x260 - x267)
x319 = x265 + x317 + x318
x320 = 2.0 * x194
x321 = 3.0 * x253
x322 = x2 * (5.0 * x193 + x320 + x321) + x263 * x92
x323 = 3.0 * x252 + 3.0 * x255
x324 = (
-x18 * (-2.0 * ax * x322 + 2.0 * x193 + x320)
+ x2 * (5.0 * x199 + 2.0 * x200 + x202 * x57 + x323)
+ x269 * x92
)
x325 = x13 * x89
x326 = x324 * x325
x327 = x325 * x5
x328 = 3.141592653589793 * x13 * x3 * x87
x329 = x328 * x5
x330 = x97 * (x164 + x273)
x331 = x18 * (x0 * x330 - 2.0 * x204) + x2 * (x204 * x32 + 2.0 * x205) + x276 * x97
x332 = x104 * x75
x333 = x2 * (x229 + x275)
x334 = x284 * x97
x335 = x2 * (x223 + x272)
x336 = x279 * x97
x337 = x335 + x336
x338 = 2.0 * ax * x337 - x232
x339 = x18 * x338 + x333 + x334
x340 = x104 * x42
x341 = x287 * x97
x342 = x293 + x341
x343 = x104 * x342
x344 = x289 * x97
x345 = x18 * (2.0 * ax * x342 - x292 - x299)
x346 = x297 + x344 + x345
x347 = 2.0 * x225
x348 = 3.0 * x286
x349 = x2 * (5.0 * x224 + x347 + x348) + x295 * x97
x350 = 3.0 * x285 + 3.0 * x288
x351 = (
-x18 * (-2.0 * ax * x349 + 2.0 * x224 + x347)
+ x2 * (5.0 * x230 + 2.0 * x231 + x233 * x57 + x350)
+ x301 * x97
)
x352 = x328 * x351
x353 = x25 + x26
x354 = x6 * (x23 + x76)
x355 = x11 * (x1 * x354 - 2.0 * x16) + x2 * (x16 * x32 + 2.0 * x17) + x353 * x6
x356 = x190 + 3.0 * x236
x357 = x2 * x356 + x302 * x92
x358 = x113 * x357
x359 = (
x18 * (2.0 * ax * x357 - x356)
+ x2 * (x197 + 3.0 * x235 + 3.0 * x238)
+ x303 * x92
)
x360 = 3.0 * x180 + 3.0 * x243
x361 = x2 * (x302 + x360) + x310 * x92
x362 = x113 * x361
x363 = (
x18 * (2.0 * ax * x361 - x360)
+ x2 * (3.0 * x184 + 3.0 * x246 + 3.0 * x248 + x303)
+ x312 * x92
)
x364 = 3.0 * x193 + x321
x365 = x2 * (2.0 * x308 + 2.0 * x309 + x364) + x315 * x92
x366 = x325 * (
x18 * (2.0 * ax * x365 - x364)
+ x2 * (3.0 * x199 + 2.0 * x306 + 2.0 * x307 + x311 * x61 + x323)
+ x319 * x92
)
x367 = x325 * x6
x368 = 3.0 * x262
x369 = x2 * (6.0 * x261 + 3.0 * x314 + x368) + x322 * x92
x370 = x325 * x369
x371 = x10 * x325
x372 = x15 * x361
x373 = x15 * x357
x374 = x15 * x315
x375 = x15 * x215
x376 = x15 * x226
x377 = x15 * x263
x378 = x15 * x279
x379 = x15 * x244
x380 = x15 * x295
x381 = x328 * x92
x382 = x15 * x195
x383 = x15 * x182
x384 = x15 * x342
x385 = x221 + 3.0 * x272
x386 = x2 * x385 + x330 * x97
x387 = x104 * x386
x388 = (
x18 * (2.0 * ax * x386 - x385)
+ x2 * (x228 + 3.0 * x271 + 3.0 * x274)
+ x331 * x97
)
x389 = 3.0 * x213 + 3.0 * x278
x390 = x2 * (x330 + x389) + x337 * x97
x391 = x104 * x390
x392 = (
x18 * (2.0 * ax * x390 - x389)
+ x2 * (3.0 * x217 + 3.0 * x281 + 3.0 * x283 + x331)
+ x339 * x97
)
x393 = x328 * x6
x394 = 3.0 * x224 + x348
x395 = x2 * (2.0 * x335 + 2.0 * x336 + x394) + x342 * x97
x396 = x328 * (
x18 * (2.0 * ax * x395 - x394)
+ x2 * (3.0 * x230 + 2.0 * x333 + 2.0 * x334 + x338 * x61 + x350)
+ x346 * x97
)
x397 = x15 * x386
x398 = x15 * x390
x399 = 3.0 * x294
x400 = x2 * (6.0 * x293 + 3.0 * x341 + x399) + x349 * x97
x401 = x328 * x400
# 150 item(s)
result[0, 0] = numpy.sum(
x102
* (
x90
* (
-x18 * (-2.0 * ax * x86 + 3.0 * x65 + x85)
+ 3.0 * x2 * (x54 + x55 + 2.0 * x62 + x69 + x72)
+ x5 * x84
)
+ x94 * x95
+ x95 * x99
)
)
result[0, 1] = numpy.sum(
x127 * (x103 * x125 + x103 * x126 * x99 + x107 * x112 * x113)
)
result[0, 2] = numpy.sum(
x127 * (x104 * x112 * x131 + x125 * x128 + x126 * x128 * x94)
)
result[0, 3] = numpy.sum(
x127 * (x113 * x135 * x146 + x135 * x142 * x99 + x138 * x142)
)
result[0, 4] = numpy.sum(
x148 * (x103 * x146 * x147 + x105 * x131 * x141 + x107 * x129 * x141)
)
result[0, 5] = numpy.sum(
x127 * (x104 * x146 * x152 + x152 * x156 * x94 + x155 * x156)
)
result[0, 6] = numpy.sum(
x102 * (x113 * x158 * x163 + x158 * x162 * x99 + x159 * x162)
)
result[0, 7] = numpy.sum(
x127 * (x129 * x135 * x163 + x129 * x138 * x161 + x131 * x135 * x161)
)
result[0, 8] = numpy.sum(
x127 * (x105 * x152 * x163 + x105 * x155 * x161 + x107 * x152 * x161)
)
result[0, 9] = numpy.sum(
x102 * (x104 * x163 * x165 + x165 * x167 * x94 + x166 * x167)
)
result[1, 0] = numpy.sum(x173 * (x113 * x170 * x83 + x171 * x92 + x172 * x92 * x99))
result[1, 1] = numpy.sum(
x179 * (x113 * x124 * x176 + x176 * x178 * x99 + x177 * x178)
)
result[1, 2] = numpy.sum(
x179 * (x124 * x147 * x92 + x129 * x170 * x71 + x131 * x168 * x71)
)
result[1, 3] = numpy.sum(
x179 * (x113 * x122 * x187 + x122 * x183 * x99 + x145 * x183)
)
result[1, 4] = numpy.sum(
x189 * (x122 * x129 * x177 + x122 * x131 * x176 + x129 * x145 * x176)
)
result[1, 5] = numpy.sum(
x179 * (x122 * x152 * x170 + x122 * x155 * x168 + x145 * x152 * x168)
)
result[1, 6] = numpy.sum(
x173 * (x113 * x139 * x203 + x139 * x196 * x99 + x144 * x196)
)
result[1, 7] = numpy.sum(
x179 * (x129 * x139 * x187 + x129 * x144 * x182 + x131 * x139 * x182)
)
result[1, 8] = numpy.sum(
x179 * (x139 * x152 * x177 + x139 * x155 * x176 + x144 * x152 * x176)
)
result[1, 9] = numpy.sum(
x173 * (x139 * x165 * x170 + x139 * x166 * x168 + x144 * x165 * x168)
)
result[2, 0] = numpy.sum(x173 * (x104 * x206 * x83 + x171 * x97 + x172 * x94 * x97))
result[2, 1] = numpy.sum(
x179 * (x103 * x124 * x207 + x105 * x206 * x71 + x107 * x204 * x71)
)
result[2, 2] = numpy.sum(
x179 * (x104 * x124 * x210 + x210 * x212 * x94 + x211 * x212)
)
result[2, 3] = numpy.sum(
x179 * (x122 * x135 * x206 + x122 * x138 * x204 + x135 * x145 * x204)
)
result[2, 4] = numpy.sum(
x189 * (x105 * x122 * x211 + x105 * x145 * x210 + x107 * x122 * x210)
)
result[2, 5] = numpy.sum(
x179 * (x104 * x122 * x220 + x122 * x216 * x94 + x145 * x216)
)
result[2, 6] = numpy.sum(
x173 * (x139 * x158 * x206 + x139 * x159 * x204 + x144 * x158 * x204)
)
result[2, 7] = numpy.sum(
x179 * (x135 * x139 * x211 + x135 * x144 * x210 + x138 * x139 * x210)
)
result[2, 8] = numpy.sum(
x179 * (x105 * x139 * x220 + x105 * x144 * x215 + x107 * x139 * x215)
)
result[2, 9] = numpy.sum(
x173 * (x104 * x139 * x234 + x139 * x227 * x94 + x144 * x227)
)
result[3, 0] = numpy.sum(x242 * (x113 * x237 * x80 + x237 * x241 * x99 + x240 * x241))
result[3, 1] = numpy.sum(x251 * (x113 * x249 * x51 + x245 * x51 * x99 + x245 * x53))
result[3, 2] = numpy.sum(
x251 * (x129 * x237 * x53 + x129 * x240 * x51 + x131 * x237 * x51)
)
result[3, 3] = numpy.sum(
x251 * (x113 * x120 * x254 + x254 * x257 * x99 + x256 * x257)
)
result[3, 4] = numpy.sum(
x258 * (x120 * x129 * x244 + x129 * x249 * x59 + x131 * x244 * x59)
)
result[3, 5] = numpy.sum(
x251 * (x120 * x152 * x237 + x152 * x240 * x59 + x155 * x237 * x59)
)
result[3, 6] = numpy.sum(
x242 * (x113 * x115 * x269 + x115 * x264 * x99 + x143 * x264)
)
result[3, 7] = numpy.sum(
x251 * (x115 * x129 * x256 + x115 * x131 * x254 + x129 * x143 * x254)
)
result[3, 8] = numpy.sum(
x251 * (x115 * x152 * x249 + x115 * x155 * x244 + x143 * x152 * x244)
)
result[3, 9] = numpy.sum(
x242 * (x115 * x165 * x240 + x115 * x166 * x237 + x143 * x165 * x237)
)
result[4, 0] = numpy.sum(
x179 * (x168 * x206 * x67 + x170 * x204 * x67 + x207 * x80 * x92)
)
result[4, 1] = numpy.sum(
x258 * (x176 * x204 * x53 + x176 * x206 * x51 + x177 * x204 * x51)
)
result[4, 2] = numpy.sum(
x258 * (x168 * x210 * x53 + x168 * x211 * x51 + x170 * x210 * x51)
)
result[4, 3] = numpy.sum(
x258 * (x120 * x182 * x204 + x182 * x206 * x59 + x187 * x204 * x59)
)
result[4, 4] = numpy.sum(
x270 * (x120 * x176 * x210 + x176 * x211 * x59 + x177 * x210 * x59)
)
result[4, 5] = numpy.sum(
x258 * (x120 * x168 * x215 + x168 * x220 * x59 + x170 * x215 * x59)
)
result[4, 6] = numpy.sum(
x179 * (x115 * x195 * x206 + x115 * x203 * x204 + x143 * x195 * x204)
)
result[4, 7] = numpy.sum(
x258 * (x115 * x182 * x211 + x115 * x187 * x210 + x143 * x182 * x210)
)
result[4, 8] = numpy.sum(
x258 * (x115 * x176 * x220 + x115 * x177 * x215 + x143 * x176 * x215)
)
result[4, 9] = numpy.sum(
x179 * (x115 * x168 * x234 + x115 * x170 * x226 + x143 * x168 * x226)
)
result[5, 0] = numpy.sum(x242 * (x104 * x273 * x80 + x273 * x277 * x94 + x276 * x277))
result[5, 1] = numpy.sum(
x251 * (x105 * x273 * x53 + x105 * x276 * x51 + x107 * x273 * x51)
)
result[5, 2] = numpy.sum(x251 * (x104 * x284 * x51 + x280 * x51 * x94 + x280 * x53))
result[5, 3] = numpy.sum(
x251 * (x120 * x135 * x273 + x135 * x276 * x59 + x138 * x273 * x59)
)
result[5, 4] = numpy.sum(
x258 * (x105 * x120 * x279 + x105 * x284 * x59 + x107 * x279 * x59)
)
result[5, 5] = numpy.sum(
x251 * (x104 * x120 * x287 + x287 * x290 * x94 + x289 * x290)
)
result[5, 6] = numpy.sum(
x242 * (x115 * x158 * x276 + x115 * x159 * x273 + x143 * x158 * x273)
)
result[5, 7] = numpy.sum(
x251 * (x115 * x135 * x284 + x115 * x138 * x279 + x135 * x143 * x279)
)
result[5, 8] = numpy.sum(
x251 * (x105 * x115 * x289 + x105 * x143 * x287 + x107 * x115 * x287)
)
result[5, 9] = numpy.sum(
x242 * (x104 * x115 * x301 + x115 * x296 * x94 + x143 * x296)
)
result[6, 0] = numpy.sum(
x173 * (x113 * x302 * x305 + x302 * x304 * x99 + x303 * x304)
)
result[6, 1] = numpy.sum(x179 * (x113 * x310 * x44 + x310 * x313 * x99 + x312 * x313))
result[6, 2] = numpy.sum(
x179 * (x129 * x302 * x44 + x129 * x303 * x42 + x131 * x302 * x42)
)
result[6, 3] = numpy.sum(x179 * (x113 * x31 * x319 + x31 * x316 * x99 + x316 * x38))
result[6, 4] = numpy.sum(
x189 * (x129 * x31 * x312 + x129 * x310 * x38 + x131 * x31 * x310)
)
result[6, 5] = numpy.sum(
x179 * (x152 * x302 * x38 + x152 * x303 * x31 + x155 * x302 * x31)
)
result[6, 6] = numpy.sum(x173 * (x113 * x322 * x36 + x322 * x327 * x99 + x326 * x5))
result[6, 7] = numpy.sum(
x179 * (x128 * x319 * x327 + x129 * x315 * x36 + x131 * x29 * x315)
)
result[6, 8] = numpy.sum(
x179 * (x152 * x29 * x312 + x152 * x310 * x36 + x155 * x29 * x310)
)
result[6, 9] = numpy.sum(
x173 * (x165 * x29 * x303 + x165 * x302 * x36 + x166 * x29 * x302)
)
result[7, 0] = numpy.sum(
x179 * (x204 * x237 * x305 + x204 * x240 * x75 + x206 * x237 * x75)
)
result[7, 1] = numpy.sum(
x258 * (x204 * x244 * x44 + x204 * x249 * x42 + x206 * x244 * x42)
)
result[7, 2] = numpy.sum(
x258 * (x210 * x237 * x44 + x210 * x240 * x42 + x211 * x237 * x42)
)
result[7, 3] = numpy.sum(
x258 * (x204 * x254 * x38 + x204 * x256 * x31 + x206 * x254 * x31)
)
result[7, 4] = numpy.sum(
x270 * (x210 * x244 * x38 + x210 * x249 * x31 + x211 * x244 * x31)
)
result[7, 5] = numpy.sum(
x258 * (x215 * x237 * x38 + x215 * x240 * x31 + x220 * x237 * x31)
)
result[7, 6] = numpy.sum(
x179 * (x204 * x263 * x36 + x206 * x263 * x29 + x269 * x327 * x97)
)
result[7, 7] = numpy.sum(
x258 * (x210 * x254 * x36 + x210 * x256 * x29 + x211 * x254 * x29)
)
result[7, 8] = numpy.sum(
x258 * (x215 * x244 * x36 + x215 * x249 * x29 + x220 * x244 * x29)
)
result[7, 9] = numpy.sum(
x179 * (x226 * x237 * x36 + x226 * x240 * x29 + x234 * x237 * x29)
)
result[8, 0] = numpy.sum(
x179 * (x168 * x273 * x305 + x168 * x276 * x75 + x170 * x273 * x75)
)
result[8, 1] = numpy.sum(
x258 * (x176 * x273 * x44 + x176 * x276 * x42 + x177 * x273 * x42)
)
result[8, 2] = numpy.sum(
x258 * (x168 * x279 * x44 + x168 * x284 * x42 + x170 * x279 * x42)
)
result[8, 3] = numpy.sum(
x258 * (x182 * x273 * x38 + x182 * x276 * x31 + x187 * x273 * x31)
)
result[8, 4] = numpy.sum(
x270 * (x176 * x279 * x38 + x176 * x284 * x31 + x177 * x279 * x31)
)
result[8, 5] = numpy.sum(
x258 * (x168 * x287 * x38 + x168 * x289 * x31 + x170 * x287 * x31)
)
result[8, 6] = numpy.sum(
x179 * (x195 * x273 * x36 + x195 * x276 * x29 + x203 * x273 * x29)
)
result[8, 7] = numpy.sum(
x258 * (x182 * x279 * x36 + x182 * x284 * x29 + x187 * x279 * x29)
)
result[8, 8] = numpy.sum(
x258 * (x176 * x287 * x36 + x176 * x289 * x29 + x177 * x287 * x29)
)
result[8, 9] = numpy.sum(
x179 * (x168 * x295 * x36 + x170 * x29 * x295 + x301 * x329 * x92)
)
result[9, 0] = numpy.sum(
x173 * (x104 * x305 * x330 + x330 * x332 * x94 + x331 * x332)
)
result[9, 1] = numpy.sum(
x179 * (x105 * x330 * x44 + x105 * x331 * x42 + x107 * x330 * x42)
)
result[9, 2] = numpy.sum(x179 * (x104 * x337 * x44 + x337 * x340 * x94 + x339 * x340))
result[9, 3] = numpy.sum(
x179 * (x135 * x31 * x331 + x135 * x330 * x38 + x138 * x31 * x330)
)
result[9, 4] = numpy.sum(
x189 * (x105 * x31 * x339 + x105 * x337 * x38 + x107 * x31 * x337)
)
result[9, 5] = numpy.sum(x179 * (x104 * x31 * x346 + x31 * x343 * x94 + x343 * x38))
result[9, 6] = numpy.sum(
x173 * (x158 * x29 * x331 + x158 * x330 * x36 + x159 * x29 * x330)
)
result[9, 7] = numpy.sum(
x179 * (x135 * x29 * x339 + x135 * x337 * x36 + x138 * x29 * x337)
)
result[9, 8] = numpy.sum(
x179 * (x103 * x329 * x346 + x105 * x342 * x36 + x107 * x29 * x342)
)
result[9, 9] = numpy.sum(x173 * (x104 * x349 * x36 + x329 * x349 * x94 + x352 * x5))
result[10, 0] = numpy.sum(
x102 * (x113 * x354 * x359 + x354 * x358 * x99 + x355 * x358)
)
result[10, 1] = numpy.sum(x127 * (x113 * x23 * x363 + x23 * x362 * x99 + x353 * x362))
result[10, 2] = numpy.sum(
x127 * (x129 * x23 * x359 + x129 * x353 * x357 + x131 * x23 * x357)
)
result[10, 3] = numpy.sum(x127 * (x113 * x20 * x365 + x365 * x367 * x99 + x366 * x6))
result[10, 4] = numpy.sum(
x148 * (x128 * x363 * x367 + x129 * x20 * x361 + x131 * x16 * x361)
)
result[10, 5] = numpy.sum(
x127 * (x152 * x16 * x359 + x152 * x20 * x357 + x155 * x16 * x357)
)
result[10, 6] = numpy.sum(
x102
* (
x10 * x370
+ x325
* (
-x18 * (-2.0 * ax * x369 + 3.0 * x261 + x368)
+ 3.0 * x2 * (2.0 * x265 + x266 + x268 + x317 + x318)
+ x324 * x92
)
+ x370 * x99
)
)
result[10, 7] = numpy.sum(
x127 * (x128 * x365 * x371 + x128 * x366 + x131 * x15 * x365)
)
result[10, 8] = numpy.sum(
x127 * (x10 * x152 * x372 + x15 * x152 * x363 + x155 * x372)
)
result[10, 9] = numpy.sum(
x102 * (x10 * x165 * x373 + x15 * x165 * x359 + x166 * x373)
)
result[11, 0] = numpy.sum(
x173 * (x204 * x302 * x355 + x204 * x303 * x354 + x206 * x302 * x354)
)
result[11, 1] = numpy.sum(
x179 * (x204 * x23 * x312 + x204 * x310 * x353 + x206 * x23 * x310)
)
result[11, 2] = numpy.sum(
x179 * (x210 * x23 * x303 + x210 * x302 * x353 + x211 * x23 * x302)
)
result[11, 3] = numpy.sum(
x179 * (x16 * x206 * x315 + x20 * x204 * x315 + x319 * x367 * x97)
)
result[11, 4] = numpy.sum(
x189 * (x16 * x210 * x312 + x16 * x211 * x310 + x20 * x210 * x310)
)
result[11, 5] = numpy.sum(
x179 * (x16 * x215 * x303 + x16 * x220 * x302 + x20 * x215 * x302)
)
result[11, 6] = numpy.sum(x173 * (x15 * x206 * x322 + x322 * x371 * x97 + x326 * x97))
result[11, 7] = numpy.sum(
x179 * (x10 * x210 * x374 + x15 * x210 * x319 + x211 * x374)
)
result[11, 8] = numpy.sum(
x179 * (x10 * x310 * x375 + x15 * x220 * x310 + x312 * x375)
)
result[11, 9] = numpy.sum(
x173 * (x10 * x302 * x376 + x15 * x234 * x302 + x303 * x376)
)
result[12, 0] = numpy.sum(
x242 * (x237 * x273 * x355 + x237 * x276 * x354 + x240 * x273 * x354)
)
result[12, 1] = numpy.sum(
x251 * (x23 * x244 * x276 + x23 * x249 * x273 + x244 * x273 * x353)
)
result[12, 2] = numpy.sum(
x251 * (x23 * x237 * x284 + x23 * x240 * x279 + x237 * x279 * x353)
)
result[12, 3] = numpy.sum(
x251 * (x16 * x254 * x276 + x16 * x256 * x273 + x20 * x254 * x273)
)
result[12, 4] = numpy.sum(
x258 * (x16 * x244 * x284 + x16 * x249 * x279 + x20 * x244 * x279)
)
result[12, 5] = numpy.sum(
x251 * (x16 * x237 * x289 + x16 * x240 * x287 + x20 * x237 * x287)
)
result[12, 6] = numpy.sum(
x242 * (x10 * x273 * x377 + x15 * x269 * x273 + x276 * x377)
)
result[12, 7] = numpy.sum(
x251 * (x10 * x254 * x378 + x15 * x254 * x284 + x256 * x378)
)
result[12, 8] = numpy.sum(
x251 * (x10 * x287 * x379 + x15 * x249 * x287 + x289 * x379)
)
result[12, 9] = numpy.sum(
x242 * (x10 * x237 * x380 + x15 * x237 * x301 + x240 * x380)
)
result[13, 0] = numpy.sum(
x173 * (x168 * x330 * x355 + x168 * x331 * x354 + x170 * x330 * x354)
)
result[13, 1] = numpy.sum(
x179 * (x176 * x23 * x331 + x176 * x330 * x353 + x177 * x23 * x330)
)
result[13, 2] = numpy.sum(
x179 * (x168 * x23 * x339 + x168 * x337 * x353 + x170 * x23 * x337)
)
result[13, 3] = numpy.sum(
x179 * (x16 * x182 * x331 + x16 * x187 * x330 + x182 * x20 * x330)
)
result[13, 4] = numpy.sum(
x189 * (x16 * x176 * x339 + x16 * x177 * x337 + x176 * x20 * x337)
)
result[13, 5] = numpy.sum(
x179 * (x16 * x170 * x342 + x168 * x20 * x342 + x346 * x381 * x6)
)
result[13, 6] = numpy.sum(
x173 * (x10 * x330 * x382 + x15 * x203 * x330 + x331 * x382)
)
result[13, 7] = numpy.sum(
x179 * (x10 * x337 * x383 + x15 * x187 * x337 + x339 * x383)
)
result[13, 8] = numpy.sum(
x179 * (x10 * x176 * x384 + x15 * x176 * x346 + x177 * x384)
)
result[13, 9] = numpy.sum(x173 * (x10 * x349 * x381 + x15 * x170 * x349 + x352 * x92))
result[14, 0] = numpy.sum(
x102 * (x104 * x354 * x388 + x354 * x387 * x94 + x355 * x387)
)
result[14, 1] = numpy.sum(
x127 * (x105 * x23 * x388 + x105 * x353 * x386 + x107 * x23 * x386)
)
result[14, 2] = numpy.sum(x127 * (x104 * x23 * x392 + x23 * x391 * x94 + x353 * x391))
result[14, 3] = numpy.sum(
x127 * (x135 * x16 * x388 + x135 * x20 * x386 + x138 * x16 * x386)
)
result[14, 4] = numpy.sum(
x148 * (x103 * x392 * x393 + x105 * x20 * x390 + x107 * x16 * x390)
)
result[14, 5] = numpy.sum(x127 * (x104 * x20 * x395 + x393 * x395 * x94 + x396 * x6))
result[14, 6] = numpy.sum(
x102 * (x10 * x158 * x397 + x15 * x158 * x388 + x159 * x397)
)
result[14, 7] = numpy.sum(
x127 * (x10 * x135 * x398 + x135 * x15 * x392 + x138 * x398)
)
result[14, 8] = numpy.sum(
x127 * (x10 * x103 * x328 * x395 + x103 * x396 + x107 * x15 * x395)
)
result[14, 9] = numpy.sum(
x102
* (
x10 * x401
+ x328
* (
-x18 * (-2.0 * ax * x400 + 3.0 * x293 + x399)
+ 3.0 * x2 * (2.0 * x297 + x298 + x300 + x344 + x345)
+ x351 * x97
)
+ x401 * x94
)
)
return result
[docs]
def kinetic3d_44(ax, da, A, bx, db, B):
"""Cartesian 3D (gg) kinetic energy integral.
Generated code; DO NOT modify by hand!"""
result = numpy.zeros((15, 15), dtype=float)
x0 = 2.0 * ax
x1 = 2.0 * bx
x2 = (x0 + x1) ** (-1.0)
x3 = (ax + bx) ** (-1.0)
x4 = -x3 * (ax * A[0] + bx * B[0])
x5 = -x4 - B[0]
x6 = -x4 - A[0]
x7 = -ax
x8 = x6**2
x9 = 2.0 * ax**2
x10 = -x7 - x9 * (x2 + x8)
x11 = ax * x3
x12 = bx * x11
x13 = numpy.exp(-x12 * (A[0] - B[0]) ** 2)
x14 = 1.772453850905516 * numpy.sqrt(x3)
x15 = x13 * x14
x16 = x15 * x5
x17 = x10 * x16
x18 = bx * x3
x19 = x0 * x18
x20 = x16 * x19 + x17
x21 = x20 * x6
x22 = x15 * x2
x23 = x15 * x6
x24 = x23 * x5
x25 = x22 + x24
x26 = x10 * x22
x27 = x19 * x25 + x21 + x26
x28 = x27 * x6
x29 = x27 * x5
x30 = x10 * x23
x31 = x19 * x23 + x30
x32 = x2 * (x20 + x31)
x33 = x2 * (x16 + x23)
x34 = x25 * x5
x35 = x33 + x34
x36 = x1 * x35 - x23
x37 = x0 * x3
x38 = x25 * x6
x39 = x33 + x38
x40 = x0 * x39 - x16
x41 = x1 * x3
x42 = x2 * (2.0 * x28 + 2.0 * x29 + 4.0 * x32 + x36 * x37 + x40 * x41)
x43 = x20 * x5
x44 = x15 * x5**2
x45 = x22 + x44
x46 = -x15
x47 = x11 * (x1 * x45 + x46)
x48 = x43 + x47
x49 = 3.0 * x26
x50 = 4.0 * x12
x51 = 2.0 * x21 + x25 * x50 + x49
x52 = x2 * (x48 + x51)
x53 = x11 * x36
x54 = x29 + x32 + x53
x55 = x54 * x6
x56 = 3.0 * x22
x57 = 2.0 * x24
x58 = x56 + x57
x59 = x2 * (x44 + x58)
x60 = x35 * x6
x61 = x59 + x60
x62 = x18 * (2.0 * ax * x61 - x45)
x63 = x52 + x55 + x62
x64 = x5 * x63
x65 = 2.0 * x38
x66 = 2.0 * x34
x67 = x2 * (4.0 * x33 + x65 + x66)
x68 = x5 * x61
x69 = x67 + x68
x70 = 2.0 * x33
x71 = x11 * (2.0 * bx * x69 - x65 - x70)
x72 = x42 + x64 + x71
x73 = x5 * x72
x74 = x6 * x72
x75 = x5 * x54
x76 = x35 * x5
x77 = x59 + x76
x78 = 2.0 * x22
x79 = x57 + x78
x80 = 2.0 * bx * x77 - x79
x81 = 3.0 * x55 + 3.0 * x62
x82 = x2 * (x37 * x80 + 5.0 * x52 + 2.0 * x75 + x81)
x83 = 2.0 * x76
x84 = 3.0 * x60
x85 = x2 * (5.0 * x59 + x83 + x84)
x86 = x5 * x69
x87 = x85 + x86
x88 = 3.0 * x59 + x84
x89 = x11 * (2.0 * bx * x87 - x88)
x90 = x6 * x69
x91 = x85 + x90
x92 = x18 * (2.0 * ax * x91 - 2.0 * x59 - x83)
x93 = x6 * x63
x94 = x6 * x61
x95 = x67 + x94
x96 = x18 * (2.0 * ax * x95 - x66 - x70)
x97 = 3.0 * x2 * (2.0 * x42 + x64 + x71 + x93 + x96)
x98 = x74 + x82 + x92
x99 = 3.0 * x94
x100 = 3.0 * x68
x101 = x2 * (x100 + 6.0 * x67 + x99)
x102 = x101 + x5 * x91
x103 = 3.0 * x67
x104 = -x11 * (-2.0 * bx * x102 + x103 + x99) + x5 * x98 + x97
x105 = 3.0 * x86
x106 = x102 * x6 + x2 * (x105 + 7.0 * x85 + 4.0 * x90)
x107 = numpy.exp(-x12 * (A[1] - B[1]) ** 2)
x108 = numpy.exp(-x12 * (A[2] - B[2]) ** 2)
x109 = 3.141592653589793 * x108 * x3
x110 = x107 * x109
x111 = -x3 * (ax * A[1] + bx * B[1])
x112 = -x111 - A[1]
x113 = x112**2
x114 = -x7 - x9 * (x113 + x2)
x115 = x106 * x110
x116 = -x3 * (ax * A[2] + bx * B[2])
x117 = -x116 - A[2]
x118 = x117**2
x119 = -x7 - x9 * (x118 + x2)
x120 = da * db
x121 = 0.009523809523809524 * x120
x122 = -x111 - B[1]
x123 = x107 * x14
x124 = x122 * x123
x125 = x114 * x124
x126 = x124 * x19 + x125
x127 = x101 + x6 * x91
x128 = x108 * x14
x129 = x110 * (-x18 * (-2.0 * ax * x127 + x100 + x103) + x6 * x98 + x97)
x130 = x110 * x127
x131 = 2.645751311064591 * x121
x132 = -x116 - B[2]
x133 = x128 * x132
x134 = x119 * x133
x135 = x133 * x19 + x134
x136 = x123 * x2
x137 = x114 * x136
x138 = x122 * x126
x139 = x122**2 * x123
x140 = x136 + x139
x141 = -x123
x142 = x11 * (x1 * x140 + x141)
x143 = x138 + x142
x144 = x137 + x143
x145 = x15 * x8
x146 = x2 * (x145 + x58)
x147 = x39 * x6
x148 = x2 * (2.0 * x146 + 2.0 * x147 + x88) + x6 * x95
x149 = x128 * x148
x150 = x31 * x6
x151 = x145 + x22
x152 = x18 * (x0 * x151 + x46)
x153 = x150 + x152
x154 = x2 * (x153 + x51)
x155 = x18 * x40
x156 = x155 + x28 + x32
x157 = x156 * x6
x158 = x146 + x147
x159 = 2.0 * ax * x158 - x79
x160 = x42 + x93 + x96
x161 = (
x160 * x6
+ x18 * (2.0 * ax * x148 - x88)
+ x2 * (2.0 * x154 + 2.0 * x157 + x159 * x41 + 3.0 * x52 + x81)
)
x162 = 0.03253000243161777 * x120
x163 = x110 * x132
x164 = 5.916079783099616 * x121
x165 = x128 * x2
x166 = x119 * x165
x167 = x132 * x135
x168 = x128 * x132**2
x169 = x165 + x168
x170 = -x128
x171 = x11 * (x1 * x169 + x170)
x172 = x167 + x171
x173 = x166 + x172
x174 = x123 * x148
x175 = 2.0 * x136
x176 = x122 * (x140 + x175)
x177 = x11 * (x1 * x176 - 2.0 * x124) + x122 * x144 + x2 * (x124 * x50 + 2.0 * x125)
x178 = x6 * (x151 + x78)
x179 = 3.0 * x33
x180 = x179 + 3.0 * x38
x181 = x158 * x6 + x2 * (x178 + x180)
x182 = x128 * x181
x183 = 3.0 * x32
x184 = x153 + x26
x185 = x18 * (x0 * x178 - 2.0 * x23) + x184 * x6 + x2 * (x23 * x50 + 2.0 * x30)
x186 = x154 + x157 + x159 * x18
x187 = (
x18 * (2.0 * ax * x181 - x180)
+ x186 * x6
+ x2 * (3.0 * x155 + x183 + x185 + 3.0 * x28)
)
x188 = 2.0 * x165
x189 = x132 * (x169 + x188)
x190 = x11 * (x1 * x189 - 2.0 * x133) + x132 * x173 + x2 * (x133 * x50 + 2.0 * x134)
x191 = x123 * x181
x192 = 3.0 * x137
x193 = 3.0 * x136
x194 = 3.0 * x139 + x193
x195 = x122 * x176 + x194 * x2
x196 = (
x11 * (2.0 * bx * x195 - x194)
+ x122 * x177
+ x2 * (3.0 * x138 + 3.0 * x142 + x192)
)
x197 = 3.0 * x145 + x56
x198 = x178 * x6 + x197 * x2
x199 = x128 * x198
x200 = (
x18 * (2.0 * ax * x198 - x197) + x185 * x6 + x2 * (3.0 * x150 + 3.0 * x152 + x49)
)
x201 = 3.0 * x166
x202 = 3.0 * x165
x203 = 3.0 * x168 + x202
x204 = x132 * x189 + x2 * x203
x205 = (
x11 * (2.0 * bx * x204 - x203)
+ x132 * x190
+ x2 * (3.0 * x167 + 3.0 * x171 + x201)
)
x206 = x123 * x198
x207 = x112 * x123
x208 = x114 * x207
x209 = x19 * x207 + x208
x210 = x104 * x110
x211 = x102 * x110
x212 = x112 * x126
x213 = x122 * x207
x214 = x136 + x213
x215 = x137 + x19 * x214 + x212
x216 = x128 * x91
x217 = 0.06666666666666667 * x120
x218 = x2 * (x124 + x207)
x219 = x122 * x214
x220 = x218 + x219
x221 = x128 * x220
x222 = x2 * (x126 + x209)
x223 = x122 * x215
x224 = x1 * x220 - x207
x225 = x11 * x224
x226 = x222 + x223 + x225
x227 = 0.08606629658238704 * x120
x228 = 2.23606797749979 * x217
x229 = x192 + 2.0 * x212 + x214 * x50
x230 = x2 * (x143 + x229)
x231 = x122 * x226
x232 = 2.0 * x213
x233 = x193 + x232
x234 = x2 * (x139 + x233)
x235 = x122 * x220
x236 = x234 + x235
x237 = x175 + x232
x238 = 2.0 * bx * x236 - x237
x239 = x11 * x238 + x230 + x231
x240 = x128 * x158
x241 = 3.0 * x218
x242 = 3.0 * x219 + x241
x243 = x122 * x236 + x2 * (x176 + x242)
x244 = x128 * x243
x245 = 3.0 * x222
x246 = (
x11 * (2.0 * bx * x243 - x242)
+ x122 * x239
+ x2 * (x177 + 3.0 * x223 + 3.0 * x225 + x245)
)
x247 = x117 * x128
x248 = x119 * x247
x249 = x19 * x247 + x248
x250 = x110 * x117
x251 = x117 * x135
x252 = x132 * x247
x253 = x165 + x252
x254 = x166 + x19 * x253 + x251
x255 = x123 * x91
x256 = x2 * (x133 + x247)
x257 = x132 * x253
x258 = x256 + x257
x259 = x123 * x258
x260 = x2 * (x135 + x249)
x261 = x132 * x254
x262 = x1 * x258 - x247
x263 = x11 * x262
x264 = x260 + x261 + x263
x265 = x201 + 2.0 * x251 + x253 * x50
x266 = x2 * (x172 + x265)
x267 = x132 * x264
x268 = 2.0 * x252
x269 = x202 + x268
x270 = x2 * (x168 + x269)
x271 = x132 * x258
x272 = x270 + x271
x273 = x188 + x268
x274 = 2.0 * bx * x272 - x273
x275 = x11 * x274 + x266 + x267
x276 = x123 * x158
x277 = 3.0 * x256
x278 = 3.0 * x257 + x277
x279 = x132 * x272 + x2 * (x189 + x278)
x280 = x123 * x279
x281 = 3.0 * x260
x282 = (
x11 * (2.0 * bx * x279 - x278)
+ x132 * x275
+ x2 * (x190 + 3.0 * x261 + 3.0 * x263 + x281)
)
x283 = x112 * x209
x284 = x113 * x123
x285 = x136 + x284
x286 = x18 * (x0 * x285 + x141)
x287 = x283 + x286
x288 = x137 + x287
x289 = x128 * x87
x290 = x73 + x82 + x89
x291 = x112 * x214
x292 = x218 + x291
x293 = x128 * x292
x294 = x112 * x215
x295 = x0 * x292 - x124
x296 = x18 * x295
x297 = x222 + x294 + x296
x298 = x112 * x226
x299 = x112 * x220
x300 = x234 + x299
x301 = x18 * (2.0 * ax * x300 - x140)
x302 = x230 + x298 + x301
x303 = x128 * x61
x304 = 0.1111111111111111 * x120
x305 = 1.732050807568877 * x304
x306 = x2 * (4.0 * x222 + 2.0 * x223 + x224 * x37 + 2.0 * x294 + x295 * x41)
x307 = x122 * x302
x308 = 2.0 * x291
x309 = 2.0 * x219
x310 = x2 * (4.0 * x218 + x308 + x309)
x311 = x122 * x300
x312 = x310 + x311
x313 = 2.0 * x218
x314 = x11 * (2.0 * bx * x312 - x308 - x313)
x315 = x306 + x307 + x314
x316 = x128 * x39
x317 = 2.0 * x235
x318 = 3.0 * x299
x319 = x2 * (5.0 * x234 + x317 + x318)
x320 = x122 * x312
x321 = x319 + x320
x322 = x128 * x321
x323 = 3.0 * x298 + 3.0 * x301
x324 = x2 * (5.0 * x230 + 2.0 * x231 + x238 * x37 + x323)
x325 = x122 * x315
x326 = 3.0 * x234 + x318
x327 = x11 * (2.0 * bx * x321 - x326)
x328 = x324 + x325 + x327
x329 = 0.3333333333333333 * x120
x330 = x117 * x249
x331 = x118 * x128
x332 = x165 + x331
x333 = x18 * (x0 * x332 + x170)
x334 = x330 + x333
x335 = x166 + x334
x336 = x123 * x87
x337 = x117 * x253
x338 = x256 + x337
x339 = x123 * x338
x340 = x117 * x254
x341 = x0 * x338 - x133
x342 = x18 * x341
x343 = x260 + x340 + x342
x344 = x117 * x264
x345 = x117 * x258
x346 = x270 + x345
x347 = x18 * (2.0 * ax * x346 - x169)
x348 = x266 + x344 + x347
x349 = x123 * x61
x350 = x2 * (4.0 * x260 + 2.0 * x261 + x262 * x37 + 2.0 * x340 + x341 * x41)
x351 = x132 * x348
x352 = 2.0 * x337
x353 = 2.0 * x257
x354 = x2 * (4.0 * x256 + x352 + x353)
x355 = x132 * x346
x356 = x354 + x355
x357 = 2.0 * x256
x358 = x11 * (2.0 * bx * x356 - x352 - x357)
x359 = x350 + x351 + x358
x360 = x123 * x39
x361 = 2.0 * x271
x362 = 3.0 * x345
x363 = x2 * (5.0 * x270 + x361 + x362)
x364 = x132 * x356
x365 = x363 + x364
x366 = x123 * x365
x367 = 3.0 * x344 + 3.0 * x347
x368 = x2 * (5.0 * x266 + 2.0 * x267 + x274 * x37 + x367)
x369 = x132 * x359
x370 = 3.0 * x270 + x362
x371 = x11 * (2.0 * bx * x365 - x370)
x372 = x368 + x369 + x371
x373 = x112 * (x175 + x285)
x374 = x112 * x288 + x18 * (x0 * x373 - 2.0 * x207) + x2 * (x207 * x50 + 2.0 * x208)
x375 = x5 * (x45 + x78)
x376 = x179 + 3.0 * x34
x377 = x2 * (x375 + x376) + x5 * x77
x378 = x128 * x377
x379 = x26 + x48
x380 = x11 * (x1 * x375 - 2.0 * x16) + x2 * (x16 * x50 + 2.0 * x17) + x379 * x5
x381 = x11 * x80 + x52 + x75
x382 = (
x11 * (2.0 * bx * x377 - x376)
+ x2 * (x183 + 3.0 * x29 + x380 + 3.0 * x53)
+ x381 * x5
)
x383 = x2 * (x233 + x284)
x384 = x112 * x292
x385 = x383 + x384
x386 = x128 * x385
x387 = x2 * (x229 + x287)
x388 = x112 * x297
x389 = 2.0 * ax * x385 - x237
x390 = x18 * x389 + x387 + x388
x391 = x112 * x302
x392 = x112 * x300
x393 = x310 + x392
x394 = x18 * (2.0 * ax * x393 - x309 - x313)
x395 = x306 + x391 + x394
x396 = x128 * x35
x397 = x112 * x312
x398 = x319 + x397
x399 = x128 * x398
x400 = x112 * x315
x401 = x18 * (2.0 * ax * x398 - 2.0 * x234 - x317)
x402 = x324 + x400 + x401
x403 = 3.0 * x392
x404 = 3.0 * x311
x405 = x2 * (6.0 * x310 + x403 + x404)
x406 = x122 * x398 + x405
x407 = 3.0 * x2 * (2.0 * x306 + x307 + x314 + x391 + x394)
x408 = 3.0 * x310
x409 = -x11 * (-2.0 * bx * x406 + x403 + x408) + x122 * x402 + x407
x410 = x109 * x13
x411 = x409 * x410
x412 = x410 * x6
x413 = 3.141592653589793 * x107 * x13 * x3
x414 = x413 * x6
x415 = x117 * (x188 + x332)
x416 = x117 * x335 + x18 * (x0 * x415 - 2.0 * x247) + x2 * (x247 * x50 + 2.0 * x248)
x417 = x123 * x377
x418 = x2 * (x269 + x331)
x419 = x117 * x338
x420 = x418 + x419
x421 = x123 * x420
x422 = x2 * (x265 + x334)
x423 = x117 * x343
x424 = 2.0 * ax * x420 - x273
x425 = x18 * x424 + x422 + x423
x426 = x117 * x348
x427 = x117 * x346
x428 = x354 + x427
x429 = x18 * (2.0 * ax * x428 - x353 - x357)
x430 = x350 + x426 + x429
x431 = x123 * x35
x432 = x117 * x356
x433 = x363 + x432
x434 = x123 * x433
x435 = x117 * x359
x436 = x18 * (2.0 * ax * x433 - 2.0 * x270 - x361)
x437 = x368 + x435 + x436
x438 = 3.0 * x427
x439 = 3.0 * x355
x440 = x2 * (6.0 * x354 + x438 + x439)
x441 = x132 * x433 + x440
x442 = 3.0 * x2 * (2.0 * x350 + x351 + x358 + x426 + x429)
x443 = 3.0 * x354
x444 = -x11 * (-2.0 * bx * x441 + x438 + x443) + x132 * x437 + x442
x445 = x413 * x444
x446 = 3.0 * x44 + x56
x447 = x2 * x446 + x375 * x5
x448 = x11 * (2.0 * bx * x447 - x446) + x2 * (3.0 * x43 + 3.0 * x47 + x49) + x380 * x5
x449 = x193 + 3.0 * x284
x450 = x112 * x373 + x2 * x449
x451 = x128 * x450
x452 = (
x112 * x374
+ x18 * (2.0 * ax * x450 - x449)
+ x2 * (x192 + 3.0 * x283 + 3.0 * x286)
)
x453 = x241 + 3.0 * x291
x454 = x112 * x385 + x2 * (x373 + x453)
x455 = x128 * x454
x456 = (
x112 * x390
+ x18 * (2.0 * ax * x454 - x453)
+ x2 * (x245 + 3.0 * x294 + 3.0 * x296 + x374)
)
x457 = x112 * x393 + x2 * (x326 + 2.0 * x383 + 2.0 * x384)
x458 = x128 * x457
x459 = (
x112 * x395
+ x18 * (2.0 * ax * x457 - x326)
+ x2 * (3.0 * x230 + x323 + 2.0 * x387 + 2.0 * x388 + x389 * x41)
)
x460 = x112 * x398 + x405
x461 = x410 * (x112 * x402 - x18 * (-2.0 * ax * x460 + x404 + x408) + x407)
x462 = x410 * x5
x463 = 3.0 * x320
x464 = x112 * x406 + x2 * (7.0 * x319 + 4.0 * x397 + x463)
x465 = x410 * x464
x466 = x10 * x410
x467 = x15 * x457
x468 = x15 * x454
x469 = x15 * x450
x470 = x15 * x398
x471 = x15 * x258
x472 = x15 * x385
x473 = x15 * x279
x474 = x15 * x321
x475 = x15 * x338
x476 = x15 * x300
x477 = x15 * x292
x478 = x15 * x365
x479 = x112 * x413
x480 = x15 * x243
x481 = x15 * x420
x482 = x15 * x220
x483 = x15 * x433
x484 = x202 + 3.0 * x331
x485 = x117 * x415 + x2 * x484
x486 = x123 * x485
x487 = (
x117 * x416
+ x18 * (2.0 * ax * x485 - x484)
+ x2 * (x201 + 3.0 * x330 + 3.0 * x333)
)
x488 = x277 + 3.0 * x337
x489 = x117 * x420 + x2 * (x415 + x488)
x490 = x123 * x489
x491 = (
x117 * x425
+ x18 * (2.0 * ax * x489 - x488)
+ x2 * (x281 + 3.0 * x340 + 3.0 * x342 + x416)
)
x492 = x117 * x428 + x2 * (x370 + 2.0 * x418 + 2.0 * x419)
x493 = x123 * x492
x494 = (
x117 * x430
+ x18 * (2.0 * ax * x492 - x370)
+ x2 * (3.0 * x266 + x367 + x41 * x424 + 2.0 * x422 + 2.0 * x423)
)
x495 = x413 * x5
x496 = x117 * x433 + x440
x497 = x413 * (x117 * x437 - x18 * (-2.0 * ax * x496 + x439 + x443) + x442)
x498 = x15 * x485
x499 = x15 * x489
x500 = x15 * x492
x501 = 3.0 * x364
x502 = x117 * x441 + x2 * (7.0 * x363 + 4.0 * x432 + x501)
x503 = x413 * x502
# 225 item(s)
result[0, 0] = numpy.sum(
x121
* (
x110
* (
x104 * x6
- x18 * (-2.0 * ax * x106 + x105 + 3.0 * x85)
+ x2 * (3.0 * x73 + 4.0 * x74 + 7.0 * x82 + 3.0 * x89 + 4.0 * x92)
)
+ x114 * x115
+ x115 * x119
)
)
result[0, 1] = numpy.sum(
x131 * (x119 * x122 * x130 + x122 * x129 + x126 * x127 * x128)
)
result[0, 2] = numpy.sum(
x131 * (x114 * x130 * x132 + x123 * x127 * x135 + x129 * x132)
)
result[0, 3] = numpy.sum(
x162 * (x119 * x140 * x149 + x128 * x140 * x161 + x144 * x149)
)
result[0, 4] = numpy.sum(
x164 * (x122 * x161 * x163 + x124 * x135 * x148 + x126 * x133 * x148)
)
result[0, 5] = numpy.sum(
x162 * (x114 * x169 * x174 + x123 * x161 * x169 + x173 * x174)
)
result[0, 6] = numpy.sum(
x131 * (x119 * x176 * x182 + x128 * x176 * x187 + x177 * x182)
)
result[0, 7] = numpy.sum(
x164 * (x133 * x140 * x187 + x133 * x144 * x181 + x135 * x140 * x181)
)
result[0, 8] = numpy.sum(
x164 * (x124 * x169 * x187 + x124 * x173 * x181 + x126 * x169 * x181)
)
result[0, 9] = numpy.sum(
x131 * (x114 * x189 * x191 + x123 * x187 * x189 + x190 * x191)
)
result[0, 10] = numpy.sum(
x121 * (x119 * x195 * x199 + x128 * x195 * x200 + x196 * x199)
)
result[0, 11] = numpy.sum(
x131 * (x133 * x176 * x200 + x133 * x177 * x198 + x135 * x176 * x198)
)
result[0, 12] = numpy.sum(
x162 * (x140 * x169 * x200 + x140 * x173 * x198 + x144 * x169 * x198)
)
result[0, 13] = numpy.sum(
x131 * (x124 * x189 * x200 + x124 * x190 * x198 + x126 * x189 * x198)
)
result[0, 14] = numpy.sum(
x121 * (x114 * x204 * x206 + x123 * x200 * x204 + x205 * x206)
)
result[1, 0] = numpy.sum(
x131 * (x102 * x128 * x209 + x112 * x119 * x211 + x112 * x210)
)
result[1, 1] = numpy.sum(
x217 * (x119 * x214 * x216 + x128 * x214 * x98 + x215 * x216)
)
result[1, 2] = numpy.sum(
x217 * (x112 * x163 * x98 + x133 * x209 * x91 + x135 * x207 * x91)
)
result[1, 3] = numpy.sum(x227 * (x119 * x221 * x95 + x128 * x226 * x95 + x160 * x221))
result[1, 4] = numpy.sum(
x228 * (x133 * x160 * x214 + x133 * x215 * x95 + x135 * x214 * x95)
)
result[1, 5] = numpy.sum(
x227 * (x160 * x169 * x207 + x169 * x209 * x95 + x173 * x207 * x95)
)
result[1, 6] = numpy.sum(
x217 * (x119 * x236 * x240 + x128 * x186 * x236 + x239 * x240)
)
result[1, 7] = numpy.sum(
x228 * (x133 * x158 * x226 + x133 * x186 * x220 + x135 * x158 * x220)
)
result[1, 8] = numpy.sum(
x228 * (x158 * x169 * x215 + x158 * x173 * x214 + x169 * x186 * x214)
)
result[1, 9] = numpy.sum(
x217 * (x158 * x189 * x209 + x158 * x190 * x207 + x186 * x189 * x207)
)
result[1, 10] = numpy.sum(
x131 * (x119 * x178 * x244 + x128 * x178 * x246 + x185 * x244)
)
result[1, 11] = numpy.sum(
x217 * (x133 * x178 * x239 + x133 * x185 * x236 + x135 * x178 * x236)
)
result[1, 12] = numpy.sum(
x227 * (x169 * x178 * x226 + x169 * x185 * x220 + x173 * x178 * x220)
)
result[1, 13] = numpy.sum(
x217 * (x178 * x189 * x215 + x178 * x190 * x214 + x185 * x189 * x214)
)
result[1, 14] = numpy.sum(
x131 * (x178 * x204 * x209 + x178 * x205 * x207 + x185 * x204 * x207)
)
result[2, 0] = numpy.sum(
x131 * (x102 * x123 * x249 + x114 * x117 * x211 + x117 * x210)
)
result[2, 1] = numpy.sum(
x217 * (x122 * x250 * x98 + x124 * x249 * x91 + x126 * x247 * x91)
)
result[2, 2] = numpy.sum(
x217 * (x114 * x253 * x255 + x123 * x253 * x98 + x254 * x255)
)
result[2, 3] = numpy.sum(
x227 * (x140 * x160 * x247 + x140 * x249 * x95 + x144 * x247 * x95)
)
result[2, 4] = numpy.sum(
x228 * (x124 * x160 * x253 + x124 * x254 * x95 + x126 * x253 * x95)
)
result[2, 5] = numpy.sum(x227 * (x114 * x259 * x95 + x123 * x264 * x95 + x160 * x259))
result[2, 6] = numpy.sum(
x217 * (x158 * x176 * x249 + x158 * x177 * x247 + x176 * x186 * x247)
)
result[2, 7] = numpy.sum(
x228 * (x140 * x158 * x254 + x140 * x186 * x253 + x144 * x158 * x253)
)
result[2, 8] = numpy.sum(
x228 * (x124 * x158 * x264 + x124 * x186 * x258 + x126 * x158 * x258)
)
result[2, 9] = numpy.sum(
x217 * (x114 * x272 * x276 + x123 * x186 * x272 + x275 * x276)
)
result[2, 10] = numpy.sum(
x131 * (x178 * x195 * x249 + x178 * x196 * x247 + x185 * x195 * x247)
)
result[2, 11] = numpy.sum(
x217 * (x176 * x178 * x254 + x176 * x185 * x253 + x177 * x178 * x253)
)
result[2, 12] = numpy.sum(
x227 * (x140 * x178 * x264 + x140 * x185 * x258 + x144 * x178 * x258)
)
result[2, 13] = numpy.sum(
x217 * (x124 * x178 * x275 + x124 * x185 * x272 + x126 * x178 * x272)
)
result[2, 14] = numpy.sum(
x131 * (x114 * x178 * x280 + x123 * x178 * x282 + x185 * x280)
)
result[3, 0] = numpy.sum(
x162 * (x119 * x285 * x289 + x128 * x285 * x290 + x288 * x289)
)
result[3, 1] = numpy.sum(x227 * (x119 * x293 * x69 + x128 * x297 * x69 + x293 * x72))
result[3, 2] = numpy.sum(
x227 * (x133 * x285 * x72 + x133 * x288 * x69 + x135 * x285 * x69)
)
result[3, 3] = numpy.sum(
x304 * (x119 * x300 * x303 + x128 * x300 * x63 + x302 * x303)
)
result[3, 4] = numpy.sum(
x305 * (x133 * x292 * x63 + x133 * x297 * x61 + x135 * x292 * x61)
)
result[3, 5] = numpy.sum(
x304 * (x169 * x285 * x63 + x169 * x288 * x61 + x173 * x285 * x61)
)
result[3, 6] = numpy.sum(
x227 * (x119 * x312 * x316 + x128 * x156 * x312 + x315 * x316)
)
result[3, 7] = numpy.sum(
x305 * (x133 * x156 * x300 + x133 * x302 * x39 + x135 * x300 * x39)
)
result[3, 8] = numpy.sum(
x305 * (x156 * x169 * x292 + x169 * x297 * x39 + x173 * x292 * x39)
)
result[3, 9] = numpy.sum(
x227 * (x156 * x189 * x285 + x189 * x288 * x39 + x190 * x285 * x39)
)
result[3, 10] = numpy.sum(
x162 * (x119 * x151 * x322 + x128 * x151 * x328 + x184 * x322)
)
result[3, 11] = numpy.sum(
x227 * (x133 * x151 * x315 + x133 * x184 * x312 + x135 * x151 * x312)
)
result[3, 12] = numpy.sum(
x304 * (x151 * x169 * x302 + x151 * x173 * x300 + x169 * x184 * x300)
)
result[3, 13] = numpy.sum(
x227 * (x151 * x189 * x297 + x151 * x190 * x292 + x184 * x189 * x292)
)
result[3, 14] = numpy.sum(
x162 * (x151 * x204 * x288 + x151 * x205 * x285 + x184 * x204 * x285)
)
result[4, 0] = numpy.sum(
x164 * (x112 * x250 * x290 + x207 * x249 * x87 + x209 * x247 * x87)
)
result[4, 1] = numpy.sum(
x228 * (x214 * x247 * x72 + x214 * x249 * x69 + x215 * x247 * x69)
)
result[4, 2] = numpy.sum(
x228 * (x207 * x253 * x72 + x207 * x254 * x69 + x209 * x253 * x69)
)
result[4, 3] = numpy.sum(
x305 * (x220 * x247 * x63 + x220 * x249 * x61 + x226 * x247 * x61)
)
result[4, 4] = numpy.sum(
x329 * (x214 * x253 * x63 + x214 * x254 * x61 + x215 * x253 * x61)
)
result[4, 5] = numpy.sum(
x305 * (x207 * x258 * x63 + x207 * x264 * x61 + x209 * x258 * x61)
)
result[4, 6] = numpy.sum(
x228 * (x156 * x236 * x247 + x236 * x249 * x39 + x239 * x247 * x39)
)
result[4, 7] = numpy.sum(
x329 * (x156 * x220 * x253 + x220 * x254 * x39 + x226 * x253 * x39)
)
result[4, 8] = numpy.sum(
x329 * (x156 * x214 * x258 + x214 * x264 * x39 + x215 * x258 * x39)
)
result[4, 9] = numpy.sum(
x228 * (x156 * x207 * x272 + x207 * x275 * x39 + x209 * x272 * x39)
)
result[4, 10] = numpy.sum(
x164 * (x151 * x243 * x249 + x151 * x246 * x247 + x184 * x243 * x247)
)
result[4, 11] = numpy.sum(
x228 * (x151 * x236 * x254 + x151 * x239 * x253 + x184 * x236 * x253)
)
result[4, 12] = numpy.sum(
x305 * (x151 * x220 * x264 + x151 * x226 * x258 + x184 * x220 * x258)
)
result[4, 13] = numpy.sum(
x228 * (x151 * x214 * x275 + x151 * x215 * x272 + x184 * x214 * x272)
)
result[4, 14] = numpy.sum(
x164 * (x151 * x207 * x282 + x151 * x209 * x279 + x184 * x207 * x279)
)
result[5, 0] = numpy.sum(
x162 * (x114 * x332 * x336 + x123 * x290 * x332 + x335 * x336)
)
result[5, 1] = numpy.sum(
x227 * (x124 * x332 * x72 + x124 * x335 * x69 + x126 * x332 * x69)
)
result[5, 2] = numpy.sum(x227 * (x114 * x339 * x69 + x123 * x343 * x69 + x339 * x72))
result[5, 3] = numpy.sum(
x304 * (x140 * x332 * x63 + x140 * x335 * x61 + x144 * x332 * x61)
)
result[5, 4] = numpy.sum(
x305 * (x124 * x338 * x63 + x124 * x343 * x61 + x126 * x338 * x61)
)
result[5, 5] = numpy.sum(
x304 * (x114 * x346 * x349 + x123 * x346 * x63 + x348 * x349)
)
result[5, 6] = numpy.sum(
x227 * (x156 * x176 * x332 + x176 * x335 * x39 + x177 * x332 * x39)
)
result[5, 7] = numpy.sum(
x305 * (x140 * x156 * x338 + x140 * x343 * x39 + x144 * x338 * x39)
)
result[5, 8] = numpy.sum(
x305 * (x124 * x156 * x346 + x124 * x348 * x39 + x126 * x346 * x39)
)
result[5, 9] = numpy.sum(
x227 * (x114 * x356 * x360 + x123 * x156 * x356 + x359 * x360)
)
result[5, 10] = numpy.sum(
x162 * (x151 * x195 * x335 + x151 * x196 * x332 + x184 * x195 * x332)
)
result[5, 11] = numpy.sum(
x227 * (x151 * x176 * x343 + x151 * x177 * x338 + x176 * x184 * x338)
)
result[5, 12] = numpy.sum(
x304 * (x140 * x151 * x348 + x140 * x184 * x346 + x144 * x151 * x346)
)
result[5, 13] = numpy.sum(
x227 * (x124 * x151 * x359 + x124 * x184 * x356 + x126 * x151 * x356)
)
result[5, 14] = numpy.sum(
x162 * (x114 * x151 * x366 + x123 * x151 * x372 + x184 * x366)
)
result[6, 0] = numpy.sum(
x131 * (x119 * x373 * x378 + x128 * x373 * x382 + x374 * x378)
)
result[6, 1] = numpy.sum(x217 * (x119 * x386 * x77 + x128 * x390 * x77 + x381 * x386))
result[6, 2] = numpy.sum(
x217 * (x133 * x373 * x381 + x133 * x374 * x77 + x135 * x373 * x77)
)
result[6, 3] = numpy.sum(
x227 * (x119 * x393 * x396 + x128 * x393 * x54 + x395 * x396)
)
result[6, 4] = numpy.sum(
x228 * (x133 * x35 * x390 + x133 * x385 * x54 + x135 * x35 * x385)
)
result[6, 5] = numpy.sum(
x227 * (x169 * x35 * x374 + x169 * x373 * x54 + x173 * x35 * x373)
)
result[6, 6] = numpy.sum(x217 * (x119 * x25 * x399 + x128 * x25 * x402 + x27 * x399))
result[6, 7] = numpy.sum(
x228 * (x133 * x25 * x395 + x133 * x27 * x393 + x135 * x25 * x393)
)
result[6, 8] = numpy.sum(
x228 * (x169 * x25 * x390 + x169 * x27 * x385 + x173 * x25 * x385)
)
result[6, 9] = numpy.sum(
x217 * (x189 * x25 * x374 + x189 * x27 * x373 + x190 * x25 * x373)
)
result[6, 10] = numpy.sum(x131 * (x119 * x406 * x412 + x128 * x31 * x406 + x411 * x6))
result[6, 11] = numpy.sum(
x217 * (x132 * x402 * x412 + x133 * x31 * x398 + x135 * x23 * x398)
)
result[6, 12] = numpy.sum(
x227 * (x169 * x23 * x395 + x169 * x31 * x393 + x173 * x23 * x393)
)
result[6, 13] = numpy.sum(
x217 * (x189 * x23 * x390 + x189 * x31 * x385 + x190 * x23 * x385)
)
result[6, 14] = numpy.sum(
x131 * (x204 * x23 * x374 + x204 * x31 * x373 + x205 * x23 * x373)
)
result[7, 0] = numpy.sum(
x164 * (x247 * x285 * x382 + x247 * x288 * x377 + x249 * x285 * x377)
)
result[7, 1] = numpy.sum(
x228 * (x247 * x292 * x381 + x247 * x297 * x77 + x249 * x292 * x77)
)
result[7, 2] = numpy.sum(
x228 * (x253 * x285 * x381 + x253 * x288 * x77 + x254 * x285 * x77)
)
result[7, 3] = numpy.sum(
x305 * (x247 * x300 * x54 + x247 * x302 * x35 + x249 * x300 * x35)
)
result[7, 4] = numpy.sum(
x329 * (x253 * x292 * x54 + x253 * x297 * x35 + x254 * x292 * x35)
)
result[7, 5] = numpy.sum(
x305 * (x258 * x285 * x54 + x258 * x288 * x35 + x264 * x285 * x35)
)
result[7, 6] = numpy.sum(
x228 * (x247 * x25 * x315 + x247 * x27 * x312 + x249 * x25 * x312)
)
result[7, 7] = numpy.sum(
x329 * (x25 * x253 * x302 + x25 * x254 * x300 + x253 * x27 * x300)
)
result[7, 8] = numpy.sum(
x329 * (x25 * x258 * x297 + x25 * x264 * x292 + x258 * x27 * x292)
)
result[7, 9] = numpy.sum(
x228 * (x25 * x272 * x288 + x25 * x275 * x285 + x27 * x272 * x285)
)
result[7, 10] = numpy.sum(
x164 * (x117 * x328 * x412 + x23 * x249 * x321 + x247 * x31 * x321)
)
result[7, 11] = numpy.sum(
x228 * (x23 * x253 * x315 + x23 * x254 * x312 + x253 * x31 * x312)
)
result[7, 12] = numpy.sum(
x305 * (x23 * x258 * x302 + x23 * x264 * x300 + x258 * x300 * x31)
)
result[7, 13] = numpy.sum(
x228 * (x23 * x272 * x297 + x23 * x275 * x292 + x272 * x292 * x31)
)
result[7, 14] = numpy.sum(
x164 * (x23 * x279 * x288 + x23 * x282 * x285 + x279 * x285 * x31)
)
result[8, 0] = numpy.sum(
x164 * (x207 * x332 * x382 + x207 * x335 * x377 + x209 * x332 * x377)
)
result[8, 1] = numpy.sum(
x228 * (x214 * x332 * x381 + x214 * x335 * x77 + x215 * x332 * x77)
)
result[8, 2] = numpy.sum(
x228 * (x207 * x338 * x381 + x207 * x343 * x77 + x209 * x338 * x77)
)
result[8, 3] = numpy.sum(
x305 * (x220 * x332 * x54 + x220 * x335 * x35 + x226 * x332 * x35)
)
result[8, 4] = numpy.sum(
x329 * (x214 * x338 * x54 + x214 * x343 * x35 + x215 * x338 * x35)
)
result[8, 5] = numpy.sum(
x305 * (x207 * x346 * x54 + x207 * x348 * x35 + x209 * x346 * x35)
)
result[8, 6] = numpy.sum(
x228 * (x236 * x25 * x335 + x236 * x27 * x332 + x239 * x25 * x332)
)
result[8, 7] = numpy.sum(
x329 * (x220 * x25 * x343 + x220 * x27 * x338 + x226 * x25 * x338)
)
result[8, 8] = numpy.sum(
x329 * (x214 * x25 * x348 + x214 * x27 * x346 + x215 * x25 * x346)
)
result[8, 9] = numpy.sum(
x228 * (x207 * x25 * x359 + x207 * x27 * x356 + x209 * x25 * x356)
)
result[8, 10] = numpy.sum(
x164 * (x23 * x243 * x335 + x23 * x246 * x332 + x243 * x31 * x332)
)
result[8, 11] = numpy.sum(
x228 * (x23 * x236 * x343 + x23 * x239 * x338 + x236 * x31 * x338)
)
result[8, 12] = numpy.sum(
x305 * (x220 * x23 * x348 + x220 * x31 * x346 + x226 * x23 * x346)
)
result[8, 13] = numpy.sum(
x228 * (x214 * x23 * x359 + x214 * x31 * x356 + x215 * x23 * x356)
)
result[8, 14] = numpy.sum(
x164 * (x112 * x372 * x414 + x207 * x31 * x365 + x209 * x23 * x365)
)
result[9, 0] = numpy.sum(
x131 * (x114 * x415 * x417 + x123 * x382 * x415 + x416 * x417)
)
result[9, 1] = numpy.sum(
x217 * (x124 * x381 * x415 + x124 * x416 * x77 + x126 * x415 * x77)
)
result[9, 2] = numpy.sum(x217 * (x114 * x421 * x77 + x123 * x425 * x77 + x381 * x421))
result[9, 3] = numpy.sum(
x227 * (x140 * x35 * x416 + x140 * x415 * x54 + x144 * x35 * x415)
)
result[9, 4] = numpy.sum(
x228 * (x124 * x35 * x425 + x124 * x420 * x54 + x126 * x35 * x420)
)
result[9, 5] = numpy.sum(
x227 * (x114 * x428 * x431 + x123 * x428 * x54 + x430 * x431)
)
result[9, 6] = numpy.sum(
x217 * (x176 * x25 * x416 + x176 * x27 * x415 + x177 * x25 * x415)
)
result[9, 7] = numpy.sum(
x228 * (x140 * x25 * x425 + x140 * x27 * x420 + x144 * x25 * x420)
)
result[9, 8] = numpy.sum(
x228 * (x124 * x25 * x430 + x124 * x27 * x428 + x126 * x25 * x428)
)
result[9, 9] = numpy.sum(x217 * (x114 * x25 * x434 + x123 * x25 * x437 + x27 * x434))
result[9, 10] = numpy.sum(
x131 * (x195 * x23 * x416 + x195 * x31 * x415 + x196 * x23 * x415)
)
result[9, 11] = numpy.sum(
x217 * (x176 * x23 * x425 + x176 * x31 * x420 + x177 * x23 * x420)
)
result[9, 12] = numpy.sum(
x227 * (x140 * x23 * x430 + x140 * x31 * x428 + x144 * x23 * x428)
)
result[9, 13] = numpy.sum(
x217 * (x122 * x414 * x437 + x124 * x31 * x433 + x126 * x23 * x433)
)
result[9, 14] = numpy.sum(x131 * (x114 * x414 * x441 + x123 * x31 * x441 + x445 * x6))
result[10, 0] = numpy.sum(
x121 * (x119 * x447 * x451 + x128 * x447 * x452 + x448 * x451)
)
result[10, 1] = numpy.sum(
x131 * (x119 * x375 * x455 + x128 * x375 * x456 + x380 * x455)
)
result[10, 2] = numpy.sum(
x131 * (x133 * x375 * x452 + x133 * x380 * x450 + x135 * x375 * x450)
)
result[10, 3] = numpy.sum(
x162 * (x119 * x45 * x458 + x128 * x45 * x459 + x379 * x458)
)
result[10, 4] = numpy.sum(
x164 * (x133 * x379 * x454 + x133 * x45 * x456 + x135 * x45 * x454)
)
result[10, 5] = numpy.sum(
x162 * (x169 * x379 * x450 + x169 * x45 * x452 + x173 * x45 * x450)
)
result[10, 6] = numpy.sum(x131 * (x119 * x460 * x462 + x128 * x20 * x460 + x461 * x5))
result[10, 7] = numpy.sum(
x164 * (x132 * x459 * x462 + x133 * x20 * x457 + x135 * x16 * x457)
)
result[10, 8] = numpy.sum(
x164 * (x16 * x169 * x456 + x16 * x173 * x454 + x169 * x20 * x454)
)
result[10, 9] = numpy.sum(
x131 * (x16 * x189 * x452 + x16 * x190 * x450 + x189 * x20 * x450)
)
result[10, 10] = numpy.sum(
x121
* (
x10 * x465
+ x119 * x465
+ x410
* (
x112 * x409
- x18 * (-2.0 * ax * x464 + 3.0 * x319 + x463)
+ x2 * (7.0 * x324 + 3.0 * x325 + 3.0 * x327 + 4.0 * x400 + 4.0 * x401)
)
)
)
result[10, 11] = numpy.sum(
x131 * (x132 * x460 * x466 + x132 * x461 + x135 * x15 * x460)
)
result[10, 12] = numpy.sum(
x162 * (x10 * x169 * x467 + x15 * x169 * x459 + x173 * x467)
)
result[10, 13] = numpy.sum(
x131 * (x10 * x189 * x468 + x15 * x189 * x456 + x190 * x468)
)
result[10, 14] = numpy.sum(
x121 * (x10 * x204 * x469 + x15 * x204 * x452 + x205 * x469)
)
result[11, 0] = numpy.sum(
x131 * (x247 * x373 * x448 + x247 * x374 * x447 + x249 * x373 * x447)
)
result[11, 1] = numpy.sum(
x217 * (x247 * x375 * x390 + x247 * x380 * x385 + x249 * x375 * x385)
)
result[11, 2] = numpy.sum(
x217 * (x253 * x373 * x380 + x253 * x374 * x375 + x254 * x373 * x375)
)
result[11, 3] = numpy.sum(
x227 * (x247 * x379 * x393 + x247 * x395 * x45 + x249 * x393 * x45)
)
result[11, 4] = numpy.sum(
x228 * (x253 * x379 * x385 + x253 * x390 * x45 + x254 * x385 * x45)
)
result[11, 5] = numpy.sum(
x227 * (x258 * x373 * x379 + x258 * x374 * x45 + x264 * x373 * x45)
)
result[11, 6] = numpy.sum(
x217 * (x117 * x402 * x462 + x16 * x249 * x398 + x20 * x247 * x398)
)
result[11, 7] = numpy.sum(
x228 * (x16 * x253 * x395 + x16 * x254 * x393 + x20 * x253 * x393)
)
result[11, 8] = numpy.sum(
x228 * (x16 * x258 * x390 + x16 * x264 * x385 + x20 * x258 * x385)
)
result[11, 9] = numpy.sum(
x217 * (x16 * x272 * x374 + x16 * x275 * x373 + x20 * x272 * x373)
)
result[11, 10] = numpy.sum(
x131 * (x117 * x406 * x466 + x117 * x411 + x15 * x249 * x406)
)
result[11, 11] = numpy.sum(
x217 * (x10 * x253 * x470 + x15 * x253 * x402 + x254 * x470)
)
result[11, 12] = numpy.sum(
x227 * (x10 * x393 * x471 + x15 * x264 * x393 + x395 * x471)
)
result[11, 13] = numpy.sum(
x217 * (x10 * x272 * x472 + x15 * x272 * x390 + x275 * x472)
)
result[11, 14] = numpy.sum(
x131 * (x10 * x373 * x473 + x15 * x282 * x373 + x374 * x473)
)
result[12, 0] = numpy.sum(
x162 * (x285 * x332 * x448 + x285 * x335 * x447 + x288 * x332 * x447)
)
result[12, 1] = numpy.sum(
x227 * (x292 * x332 * x380 + x292 * x335 * x375 + x297 * x332 * x375)
)
result[12, 2] = numpy.sum(
x227 * (x285 * x338 * x380 + x285 * x343 * x375 + x288 * x338 * x375)
)
result[12, 3] = numpy.sum(
x304 * (x300 * x332 * x379 + x300 * x335 * x45 + x302 * x332 * x45)
)
result[12, 4] = numpy.sum(
x305 * (x292 * x338 * x379 + x292 * x343 * x45 + x297 * x338 * x45)
)
result[12, 5] = numpy.sum(
x304 * (x285 * x346 * x379 + x285 * x348 * x45 + x288 * x346 * x45)
)
result[12, 6] = numpy.sum(
x227 * (x16 * x312 * x335 + x16 * x315 * x332 + x20 * x312 * x332)
)
result[12, 7] = numpy.sum(
x305 * (x16 * x300 * x343 + x16 * x302 * x338 + x20 * x300 * x338)
)
result[12, 8] = numpy.sum(
x305 * (x16 * x292 * x348 + x16 * x297 * x346 + x20 * x292 * x346)
)
result[12, 9] = numpy.sum(
x227 * (x16 * x285 * x359 + x16 * x288 * x356 + x20 * x285 * x356)
)
result[12, 10] = numpy.sum(
x162 * (x10 * x332 * x474 + x15 * x328 * x332 + x335 * x474)
)
result[12, 11] = numpy.sum(
x227 * (x10 * x312 * x475 + x15 * x312 * x343 + x315 * x475)
)
result[12, 12] = numpy.sum(
x304 * (x10 * x346 * x476 + x15 * x302 * x346 + x348 * x476)
)
result[12, 13] = numpy.sum(
x227 * (x10 * x356 * x477 + x15 * x297 * x356 + x359 * x477)
)
result[12, 14] = numpy.sum(
x162 * (x10 * x285 * x478 + x15 * x285 * x372 + x288 * x478)
)
result[13, 0] = numpy.sum(
x131 * (x207 * x415 * x448 + x207 * x416 * x447 + x209 * x415 * x447)
)
result[13, 1] = numpy.sum(
x217 * (x214 * x375 * x416 + x214 * x380 * x415 + x215 * x375 * x415)
)
result[13, 2] = numpy.sum(
x217 * (x207 * x375 * x425 + x207 * x380 * x420 + x209 * x375 * x420)
)
result[13, 3] = numpy.sum(
x227 * (x220 * x379 * x415 + x220 * x416 * x45 + x226 * x415 * x45)
)
result[13, 4] = numpy.sum(
x228 * (x214 * x379 * x420 + x214 * x425 * x45 + x215 * x420 * x45)
)
result[13, 5] = numpy.sum(
x227 * (x207 * x379 * x428 + x207 * x430 * x45 + x209 * x428 * x45)
)
result[13, 6] = numpy.sum(
x217 * (x16 * x236 * x416 + x16 * x239 * x415 + x20 * x236 * x415)
)
result[13, 7] = numpy.sum(
x228 * (x16 * x220 * x425 + x16 * x226 * x420 + x20 * x220 * x420)
)
result[13, 8] = numpy.sum(
x228 * (x16 * x214 * x430 + x16 * x215 * x428 + x20 * x214 * x428)
)
result[13, 9] = numpy.sum(
x217 * (x16 * x209 * x433 + x20 * x207 * x433 + x437 * x479 * x5)
)
result[13, 10] = numpy.sum(
x131 * (x10 * x415 * x480 + x15 * x246 * x415 + x416 * x480)
)
result[13, 11] = numpy.sum(
x217 * (x10 * x236 * x481 + x15 * x236 * x425 + x239 * x481)
)
result[13, 12] = numpy.sum(
x227 * (x10 * x428 * x482 + x15 * x226 * x428 + x430 * x482)
)
result[13, 13] = numpy.sum(
x217 * (x10 * x214 * x483 + x15 * x214 * x437 + x215 * x483)
)
result[13, 14] = numpy.sum(
x131 * (x10 * x441 * x479 + x112 * x445 + x15 * x209 * x441)
)
result[14, 0] = numpy.sum(
x121 * (x114 * x447 * x486 + x123 * x447 * x487 + x448 * x486)
)
result[14, 1] = numpy.sum(
x131 * (x124 * x375 * x487 + x124 * x380 * x485 + x126 * x375 * x485)
)
result[14, 2] = numpy.sum(
x131 * (x114 * x375 * x490 + x123 * x375 * x491 + x380 * x490)
)
result[14, 3] = numpy.sum(
x162 * (x140 * x379 * x485 + x140 * x45 * x487 + x144 * x45 * x485)
)
result[14, 4] = numpy.sum(
x164 * (x124 * x379 * x489 + x124 * x45 * x491 + x126 * x45 * x489)
)
result[14, 5] = numpy.sum(
x162 * (x114 * x45 * x493 + x123 * x45 * x494 + x379 * x493)
)
result[14, 6] = numpy.sum(
x131 * (x16 * x176 * x487 + x16 * x177 * x485 + x176 * x20 * x485)
)
result[14, 7] = numpy.sum(
x164 * (x140 * x16 * x491 + x140 * x20 * x489 + x144 * x16 * x489)
)
result[14, 8] = numpy.sum(
x164 * (x122 * x494 * x495 + x124 * x20 * x492 + x126 * x16 * x492)
)
result[14, 9] = numpy.sum(x131 * (x114 * x495 * x496 + x123 * x20 * x496 + x497 * x5))
result[14, 10] = numpy.sum(
x121 * (x10 * x195 * x498 + x15 * x195 * x487 + x196 * x498)
)
result[14, 11] = numpy.sum(
x131 * (x10 * x176 * x499 + x15 * x176 * x491 + x177 * x499)
)
result[14, 12] = numpy.sum(
x162 * (x10 * x140 * x500 + x140 * x15 * x494 + x144 * x500)
)
result[14, 13] = numpy.sum(
x131 * (x10 * x122 * x413 * x496 + x122 * x497 + x126 * x15 * x496)
)
result[14, 14] = numpy.sum(
x121
* (
x10 * x503
+ x114 * x503
+ x413
* (
x117 * x444
- x18 * (-2.0 * ax * x502 + 3.0 * x363 + x501)
+ x2 * (7.0 * x368 + 3.0 * x369 + 3.0 * x371 + 4.0 * x435 + 4.0 * x436)
)
)
)
return result
kinetic3d = {
(0, 0): kinetic3d_00,
(0, 1): kinetic3d_01,
(0, 2): kinetic3d_02,
(0, 3): kinetic3d_03,
(0, 4): kinetic3d_04,
(1, 0): kinetic3d_10,
(1, 1): kinetic3d_11,
(1, 2): kinetic3d_12,
(1, 3): kinetic3d_13,
(1, 4): kinetic3d_14,
(2, 0): kinetic3d_20,
(2, 1): kinetic3d_21,
(2, 2): kinetic3d_22,
(2, 3): kinetic3d_23,
(2, 4): kinetic3d_24,
(3, 0): kinetic3d_30,
(3, 1): kinetic3d_31,
(3, 2): kinetic3d_32,
(3, 3): kinetic3d_33,
(3, 4): kinetic3d_34,
(4, 0): kinetic3d_40,
(4, 1): kinetic3d_41,
(4, 2): kinetic3d_42,
(4, 3): kinetic3d_43,
(4, 4): kinetic3d_44,
}