def test_scheme(scheme):
assert scheme.points.dtype in [np.float64, np.int64], scheme.name
assert scheme.weights.dtype in [np.float64, np.int64], scheme.name
print(scheme)
w3 = np.array(
[
[[0.0, 0.0, -1.0], [1.0, 0.0, -1.0], [0.0, 1.0, -1.0]],
[[0.0, 0.0, +1.0], [1.0, 0.0, +1.0], [0.0, 1.0, +1.0]],
]
)
degree, err = check_degree(
lambda poly: scheme.integrate(poly, w3),
# lambda k: _integrate_exact(k, w3),
_integrate_monomial_over_unit_w3,
3,
scheme.degree + 1,
tol=scheme.test_tolerance,
)
assert (
degree >= scheme.degree
), "{} -- observed: {}, expected: {} (max err: {:.3e})".format(
scheme.name, degree, scheme.degree, err
)
def test_scheme(scheme):
degree = check_degree(
lambda poly: quadpy.circle.integrate(poly, [0.0, 0.0], 1.0, scheme),
integrate_monomial_over_unit_nsphere,
lambda n: quadpy.helpers.partition(n, 2), scheme.degree + 1)
assert degree == scheme.degree
return
def test_scheme(scheme):
print(scheme)
scheme = scheme()
assert scheme.points.dtype in [numpy.float64, numpy.int64], scheme.name
assert scheme.weights.dtype in [numpy.float64, numpy.int64], scheme.name
print(scheme)
# Test integration until we get to a polynomial degree `d` that can no
# longer be integrated exactly. The scheme's degree is `d-1`.
t3 = numpy.array([[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0],
[0.0, 0.0, 1.0]])
degree, err = check_degree(
lambda poly: scheme.integrate(poly, t3),
integrate_monomial_over_unit_simplex,
3,
scheme.degree + 1,
scheme.test_tolerance * 1.1,
)
assert (degree >= scheme.degree
), "{} -- observed: {}, expected: {} (max err: {:.3e})".format(
scheme.name, degree, scheme.degree, err)
def test_scheme(scheme, tol):
degree = check_degree(lambda poly: quadpy.e3r2.integrate(poly, scheme),
integrate_monomial_over_enr2,
lambda n: quadpy.helpers.partition(n, 3),
scheme.degree + 1,
tol=tol)
assert degree == scheme.degree, \
'Observed: {} expected: {}'.format(degree, scheme.degree)
return
def test_scheme(scheme):
assert scheme.points.dtype == numpy.float64, scheme.name
assert scheme.weights.dtype == numpy.float64, scheme.name
degree = check_degree(
lambda poly: quadpy.circle.integrate(poly, [0.0, 0.0], 1.0, scheme),
integrate_monomial_over_unit_nsphere, 2, scheme.degree + 1)
assert degree == scheme.degree
return
def test_scheme(scheme, tol):
degree = check_degree(
lambda poly: quadpy.e1r.integrate(poly, scheme),
lambda k: math.factorial(k[0]),
lambda k: quadpy.helpers.partition(k, 1),
scheme.degree + 1,
tol=tol
)
assert degree == scheme.degree, \
'Observed: {} expected: {}'.format(degree, scheme.degree)
return
def test_scheme(scheme, tol):
assert scheme.points.dtype == numpy.float64, scheme.name
assert scheme.weights.dtype == numpy.float64, scheme.name
degree = check_degree(lambda poly: quadpy.e1r.integrate(poly, scheme),
lambda k: math.factorial(k[0]),
1,
scheme.degree + 1,
tol=tol)
assert degree == scheme.degree, \
'Observed: {} expected: {}'.format(degree, scheme.degree)
return
def test_scheme(scheme):
n = scheme.dim
simplex = numpy.zeros((n + 1, n))
for k in range(n):
simplex[k + 1, k] = 1.0
degree = check_degree(
lambda poly: quadpy.nsimplex.integrate(poly, simplex, scheme),
integrate_monomial_over_standard_simplex,
lambda k: quadpy.helpers.partition(k, n), scheme.degree + 1)
assert degree >= scheme.degree, \
'Observed: {}, expected: {}'.format(degree, scheme.degree)
return
def test_scheme(scheme, tol):
assert scheme.points.dtype == numpy.float64, scheme.name
assert scheme.weights.dtype == numpy.float64, scheme.name
degree = check_degree(lambda poly: quadpy.e2r2.integrate(poly, scheme),
integrate_monomial_over_enr2,
2,
scheme.degree + 1,
tol=tol)
assert degree == scheme.degree, \
'Observed: {} expected: {}'.format(degree, scheme.degree)
return
def test_scheme(scheme, tol):
degree = check_degree(
lambda poly: quadpy.disk.integrate(
poly, [0.0, 0.0], 1.0, scheme
),
integrate_monomial_over_unit_nball,
lambda n: quadpy.helpers.partition(n, 2),
scheme.degree + 1,
tol=tol
)
assert degree == scheme.degree, \
'Observed: {} expected: {}'.format(degree, scheme.degree)
return
def test_scheme(scheme, tol):
n = scheme.dim
ncube_limits = [[0.0, 1.0]] * n
ncube = quadpy.ncube.ncube_points(*ncube_limits)
degree = check_degree(
lambda poly: quadpy.ncube.integrate(poly, ncube, scheme),
lambda exp: integrate_monomial_over_ncube(ncube_limits, exp),
lambda k: quadpy.helpers.partition(k, n),
scheme.degree + 1,
tol=tol)
assert degree >= scheme.degree, \
'observed: {}, expected: {}'.format(degree, scheme.degree)
return
def test_scheme(scheme, tol=1.0e-14):
assert scheme.points.dtype == numpy.float64, scheme.name
assert scheme.weights.dtype == numpy.float64, scheme.name
degree = check_degree(
lambda poly: scheme.integrate(poly, dot=accupy.fdot),
integrate_monomial_over_enr,
3,
scheme.degree + 1,
tol=tol,
)
assert degree == scheme.degree, "Observed: {} expected: {}".format(
degree, scheme.degree)
return
def test_scheme(scheme):
assert scheme.points.dtype in [numpy.float64, numpy.int64], scheme.name
assert scheme.weights.dtype in [numpy.float64, numpy.int64], scheme.name
n = scheme.dim
simplex = numpy.zeros((n + 1, n))
for k in range(n):
simplex[k + 1, k] = 1.0
degree = check_degree(
lambda poly: quadpy.nsimplex.integrate(poly, simplex, scheme),
integrate_monomial_over_unit_simplex, n, scheme.degree + 1)
assert degree >= scheme.degree, \
'Observed: {}, expected: {}'.format(degree, scheme.degree)
return
def test_scheme(scheme, tol=1.0e-14):
n = scheme.dim
center = numpy.zeros(n)
rad = 1.0
degree = check_degree(
lambda poly: quadpy.nsphere.integrate(poly, center, rad, scheme),
integrate_monomial_over_unit_nsphere,
lambda k: quadpy.helpers.partition(k, n),
scheme.degree + 1,
tol=tol
)
assert degree >= scheme.degree, \
'observed: {}, expected: {}'.format(degree, scheme.degree)
return
def test_scheme(scheme, tol):
assert scheme.points.dtype == numpy.float64, scheme.name
assert scheme.weights.dtype == numpy.float64, scheme.name
degree = check_degree(
lambda poly: quadpy.ball.integrate(poly, [0.0, 0.0, 0.0], 1.0, scheme),
integrate_monomial_over_unit_nball,
3,
scheme.degree + 1,
tol=tol,
)
assert degree == scheme.degree, "Observed: {} expected: {}".format(
degree, scheme.degree)
return
def test_scheme(scheme):
assert scheme.points.dtype == np.float64, scheme.name
assert scheme.weights.dtype == np.float64, scheme.name
n = scheme.dim
degree, err = check_degree(
lambda poly: scheme.integrate(poly, center=np.zeros(n), radius=1),
ndim.nball.integrate_monomial,
n,
scheme.degree + 1,
tol=scheme.test_tolerance,
)
assert degree >= scheme.degree, (
f"{scheme.name} -- observed: {degree}, expected: {scheme.degree} "
f"(max err: {err:.3e})")
def test_scheme(scheme):
assert scheme.points.dtype == numpy.float64, scheme.name
assert scheme.weights.dtype == numpy.float64, scheme.name
print(scheme)
degree, err = check_degree(
lambda poly: scheme.integrate(poly, dot=accupy.fdot),
integrate_monomial_over_enr,
2,
scheme.degree + 1,
tol=scheme.test_tolerance,
)
assert (degree >= scheme.degree
), "{} -- observed: {}, expected: {} (max err: {:.3e})".format(
scheme.name, degree, scheme.degree, err)
def test_scheme(scheme):
assert scheme.points.dtype == numpy.float64, scheme.name
assert scheme.weights.dtype == numpy.float64, scheme.name
n = scheme.dim
degree, err = check_degree(
lambda poly: scheme.integrate(poly, center=numpy.zeros(n), radius=1),
integrate_monomial_over_nball,
n,
scheme.degree + 1,
tol=scheme.test_tolerance,
)
assert (
degree >= scheme.degree
), "{} (dim={}) -- Observed: {}, expected: {} (max err: {:.3e})".format(
scheme.name, n, degree, scheme.degree, err)
def test_scheme(scheme):
assert scheme.points.dtype in [numpy.float64, numpy.int64], scheme.name
assert scheme.weights.dtype in [numpy.float64, numpy.int64], scheme.name
# Test integration until we get to a polynomial degree `d` that can no longer be
# integrated exactly. The scheme's degree is `d-1`.
pyra = numpy.array([[-1, -1, -1], [+1, -1, -1], [+1, +1, -1], [-1, +1, -1],
[0, 0, 1]])
degree = check_degree(
lambda poly: scheme.integrate(poly, pyra),
lambda k: _integrate_exact(k, pyra),
3,
scheme.degree + 1,
)
assert degree == scheme.degree
return
def test_scheme(scheme, tol):
triangle = numpy.array([
[0.0, 0.0],
[1.0, 0.0],
[0.0, 1.0]
])
degree = check_degree(
lambda poly: quadpy.triangle.integrate(poly, triangle, scheme),
integrate_monomial_over_standard_simplex,
lambda n: quadpy.helpers.partition(n, 2),
scheme.degree + 1,
tol=tol
)
assert degree >= scheme.degree, \
'Observed: {}, expected: {}'.format(degree, scheme.degree)
return
def test_scheme(scheme, tol, print_degree=False):
x = [-1.0, +1.0]
y = [-1.0, +1.0]
z = [-1.0, +1.0]
hexa = quadpy.hexahedron.cube_points(x, y, z)
degree = check_degree(
lambda poly: quadpy.hexahedron.integrate(poly, hexa, scheme),
lambda k: _integrate_exact2(k, x[0], x[1], y[0], y[1], z[0], z[1]),
lambda n: quadpy.helpers.partition(n, 3),
scheme.degree + 1,
tol=tol)
if print_degree:
print('Detected degree {}, scheme degree {}.'.format(
degree, scheme.degree))
assert degree == scheme.degree
return
def test_scheme(scheme):
assert scheme.points.dtype == np.float64, scheme.name
assert scheme.weights.dtype == np.float64, scheme.name
print(scheme)
degree, err = check_degree(
lambda poly: scheme.integrate(poly, [0.0, 0.0], 1.0),
ndim.nsphere.integrate_monomial,
2,
scheme.degree + 1,
tol=scheme.test_tolerance,
)
assert (degree >= scheme.degree
), "{} -- observed: {}, expected: {} (max err: {:.3e})".format(
scheme.name, degree, scheme.degree, err)
def test_scheme(scheme, tol=1.0e-14):
assert scheme.points.dtype in [numpy.int64, numpy.float64], scheme.name
assert scheme.weights.dtype in [numpy.int64, numpy.float64], scheme.name
n = scheme.dim
center = numpy.zeros(n)
rad = 1.0
degree = check_degree(
lambda poly: quadpy.nsphere.integrate(poly, center, rad, scheme),
integrate_monomial_over_unit_nsphere,
n,
scheme.degree + 1,
tol=tol)
assert degree >= scheme.degree, \
'observed: {}, expected: {}'.format(degree, scheme.degree)
return
def test_scheme(scheme):
assert scheme.points.dtype in [numpy.float64, numpy.int64], scheme.name
assert scheme.weights.dtype in [numpy.float64, numpy.int64], scheme.name
# Test integration until we get to a polynomial degree `d` that can no
# longer be integrated exactly. The scheme's degree is `d-1`.
tetrahedron = numpy.array([[0.0, 0.0, 0.0], [1.0, 0.0, 0.0],
[0.0, 1.0, 0.0], [0.0, 0.0, 1.0]])
degree = check_degree(
lambda poly: quadpy.tetrahedron.integrate(poly, tetrahedron, scheme),
integrate_monomial_over_unit_simplex,
3,
scheme.degree + 1,
)
assert degree == scheme.degree, "Observed: {}, expected: {}".format(
degree, scheme.degree)
return
def test_scheme(scheme):
wedge = numpy.array([
[[0.0, 0.0, -1.0], [1.0, 0.0, -1.0], [0.0, 1.0, -1.0]],
[[0.0, 0.0, +1.0], [1.0, 0.0, +1.0], [0.0, 1.0, +1.0]],
])
degree = check_degree(
lambda poly: quadpy.wedge.integrate(
poly, wedge, scheme
),
# lambda k: _integrate_exact(k, wedge),
_integrate_monomial_over_unit_wedge,
lambda n: quadpy.helpers.partition(n, 3),
scheme.degree + 1
)
assert degree == scheme.degree
return
def test_scheme(scheme):
assert scheme.points.dtype in [np.int64, np.float64], scheme.name
assert scheme.weights.dtype in [np.int64, np.float64], scheme.name
print(scheme)
n = scheme.dim
degree, err = check_degree(
lambda poly: scheme.integrate(poly, center=np.zeros(n), radius=1),
ndim.nsphere.integrate_monomial,
n,
scheme.degree + 1,
tol=scheme.test_tolerance * 1.1,
)
assert degree >= scheme.degree, (
f"{scheme.name} (dim={n}) -- "
f"observed: {degree}, expected: {scheme.degree} (max err: {err:.3e})")
def test_scheme(scheme, tol):
assert scheme.points.dtype in [numpy.float64, numpy.int64], scheme.name
assert scheme.weights.dtype in [numpy.float64, numpy.int64], scheme.name
n = scheme.dim
ncube_limits = [[0.0, 1.0]] * n
ncube = quadpy.ncube.ncube_points(*ncube_limits)
degree = check_degree(
lambda poly: quadpy.ncube.integrate(poly, ncube, scheme),
lambda exp: integrate_monomial_over_ncube(ncube_limits, exp),
n,
scheme.degree + 1,
tol=tol
)
assert degree >= scheme.degree, \
'observed: {}, expected: {}'.format(degree, scheme.degree)
return
def test_scheme(scheme):
assert scheme.points.dtype in [numpy.float64, numpy.int64], scheme.name
assert scheme.weights.dtype in [numpy.float64, numpy.int64], scheme.name
wedge = numpy.array([
[[0.0, 0.0, -1.0], [1.0, 0.0, -1.0], [0.0, 1.0, -1.0]],
[[0.0, 0.0, +1.0], [1.0, 0.0, +1.0], [0.0, 1.0, +1.0]],
])
degree = check_degree(
lambda poly: quadpy.wedge.integrate(poly, wedge, scheme),
# lambda k: _integrate_exact(k, wedge),
_integrate_monomial_over_unit_wedge,
3,
scheme.degree + 1)
assert degree == scheme.degree
return
def test_scheme(scheme):
assert scheme.points.dtype == numpy.float64, scheme.name
assert scheme.weights.dtype == numpy.float64, scheme.name
tol = 1.0e-14
n = scheme.dim
center = numpy.zeros(n)
radius = 1
degree = check_degree(
lambda poly: quadpy.nball.integrate(poly, center, radius, scheme),
integrate_monomial_over_unit_nball,
n,
scheme.degree + 1,
tol=tol
)
assert degree >= scheme.degree, \
'observed: {}, expected: {}'.format(degree, scheme.degree)
return
def test_scheme(scheme):
# Test integration until we get to a polynomial degree `d` that can no
# longer be integrated exactly. The scheme's degree is `d-1`.
tetrahedron = numpy.array([
[0.0, 0.0, 0.0],
[1.0, 0.0, 0.0],
[0.0, 1.0, 0.0],
[0.0, 0.0, 1.0],
])
degree = check_degree(
lambda poly: quadpy.tetrahedron.integrate(poly, tetrahedron, scheme),
integrate_monomial_over_standard_simplex,
lambda n: quadpy.helpers.partition(n, 3),
scheme.degree + 1,
)
assert degree == scheme.degree, \
'Observed: {}, expected: {}'.format(degree, scheme.degree)
return
