def test_ellipsoid_contains():
"""Test Elipsoid.contains()"""
eps = 1.e-7
for n in range(1, NMAX + 1):
ell = nestle.Ellipsoid(np.zeros(n), np.identity(n)) # unit n-sphere
# point just outside unit n-sphere:
pt = (1. / np.sqrt(n) + eps) * np.ones(n)
assert not ell.contains(pt)
# point just inside unit n-sphere:
pt = (1. / np.sqrt(n) - eps) * np.ones(n)
assert ell.contains(pt)
# non-equal axes ellipsoid, still aligned on axes:
a = np.diag(np.random.rand(n))
ell = nestle.Ellipsoid(np.zeros(n), a)
# check points on axes
for i in range(0, n):
axlen = 1. / np.sqrt(a[i, i]) # length of this axis
pt = np.zeros(n)
pt[i] = axlen + eps
assert not ell.contains(pt)
pt[i] = axlen - eps
assert ell.contains(pt)
def test_ellipsoid_sphere():
"""Test that Ellipsoid works like a sphere when ``a`` is proportional to
the identity matrix."""
scale = 5.
for n in range(1, NMAX + 1):
ctr = 2.0 * scale * np.ones(n) # arbitrary non-zero center
a = 1.0 / scale**2 * np.identity(n)
ell = nestle.Ellipsoid(ctr, a)
assert_allclose(ell.vol, nestle.vol_prefactor(n) * scale**n)
assert_allclose(ell.axlens, scale * np.ones(n))
assert_allclose(ell.axes, scale * np.identity(n))
def test_ellipsoid_vol_scaling():
"""Test that scaling an ellipse works as expected."""
scale = 1.5 # linear scale
for n in range(1, NMAX + 1):
# ellipsoid centered at origin with principle axes aligned with
# coordinate axes, but random sizes.
ctr = np.zeros(n)
a = np.diag(np.random.rand(n))
ell = nestle.Ellipsoid(ctr, a)
# second ellipsoid with axes scaled.
ell2 = nestle.Ellipsoid(ctr, 1. / scale**2 * a)
# scale volume of first ellipse to match the second.
ell.scale_to_vol(ell.vol * scale**n)
# check that the ellipses are the same.
assert_allclose(ell.vol, ell2.vol)
assert_allclose(ell.a, ell2.a)
assert_allclose(ell.axes, ell2.axes)
assert_allclose(ell.axlens, ell2.axlens)
def random_ellipsoid(n):
"""Return a random `n`-d ellipsoid centered at the origin
This is a helper function for other tests.
"""
# `a` in the ellipsoid must be positive definite, so we have to construct
# a positive definite matrix. For any real, non-singular matrix A,
# `A^T A` will be positive definite.
det = 0.
while abs(det) < 1.e-10: # ensure a non-singular matrix
A = np.random.rand(n, n)
det = np.linalg.det(A)
return nestle.Ellipsoid(np.zeros(n), np.dot(A.T, A))
def test_ellipsoid_repr():
ell = nestle.Ellipsoid([0., 0.], [[1., 0.], [0., 1.]])
assert repr(ell) == "Ellipsoid(ctr=[0.0, 0.0])"
ax.set_aspect('equal')
fig.tight_layout()
plt.show()
###############################################################################
#
# Single ellipsoid
# ----------------
#
# Nestle correctly identifies a cloud of points as belonging to a single
# ellipsoid.
# Generate samples drawn from a single ellipsoid
npoints = 100
A = np.array([[0.25, 1., 0.5], [1., 0.25, 0.5], [0.5, 1., 0.25]])
ell_gen = nestle.Ellipsoid([0., 0., 0.], np.dot(A.T, A))
points = ell_gen.samples(npoints)
pointvol = ell_gen.vol / npoints
# Find bounding ellipsoid(s)
ells = nestle.bounding_ellipsoids(points, pointvol)
# plot
fig = plt.figure(figsize=(10., 10.))
ax = fig.add_subplot(111, projection='3d')
ax.scatter(points[:, 0], points[:, 1], points[:, 2], c='k', marker='.')
for ell in ells:
plot_ellipsoid_3d(ell, ax)
fig.tight_layout()
plt.show()
