def test_intrinsic_and_extrinsic_coords_vectorization(self): """ Test that the composition of intrinsic_to_extrinsic_coords and extrinsic_to_intrinsic_coords gives the identity. """ point_int = gs.array([ [0.1, 0.0, 0.0, 0.1, 0.0, 0.0], [0.1, 0.1, 0.1, 0.4, 0.1, 0.0], [0.1, 0.3, 0.0, 0.1, 0.0, 0.0], [-0.1, 0.1, -0.4, 0.1, -0.01, 0.0], [0.0, 0.0, 0.1, 0.1, -0.08, -0.1], [0.1, 0.1, 0.1, 0.1, 0.0, -0.5], ]) point_ext = self.space.from_coordinates(point_int, "intrinsic") result = self.space.to_coordinates(point_ext, "intrinsic") expected = point_int expected = helper.to_vector(expected) self.assertAllClose(result, expected) point_ext = gs.array([ [2.0, 1.0, 1.0, 1.0], [4.0, 1.0, 3.0, math.sqrt(5.0)], [3.0, 2.0, 0.0, 2.0], ]) point_int = self.space.to_coordinates(point_ext, "intrinsic") result = self.space.from_coordinates(point_int, "intrinsic") expected = point_ext expected = helper.to_vector(expected) self.assertAllClose(result, expected)
def test_intrinsic_and_extrinsic_coords(self): """ Test that the composition of intrinsic_to_extrinsic_coords and extrinsic_to_intrinsic_coords gives the identity. """ point_int = tf.convert_to_tensor([.1, 0., 0., .1]) point_ext = self.space.intrinsic_to_extrinsic_coords(point_int) result = self.space.extrinsic_to_intrinsic_coords(point_ext) expected = point_int expected = helper.to_vector(expected) with self.test_session(): self.assertAllClose(gs.eval(result), gs.eval(expected)) # TODO(nina): Fix that the test fails if point_ext generated # with tf.random_uniform point_ext = (1. / (gs.sqrt(6.)) * tf.convert_to_tensor([1., 0., 0., 1., 2.])) point_int = self.space.extrinsic_to_intrinsic_coords(point_ext) result = self.space.intrinsic_to_extrinsic_coords(point_int) expected = point_ext expected = helper.to_vector(expected) with self.test_session(): self.assertAllClose(gs.eval(result), gs.eval(expected))
def test_intrinsic_and_extrinsic_coords_vectorization(self): """ Test that the composition of intrinsic_to_extrinsic_coords and extrinsic_to_intrinsic_coords gives the identity. """ point_int = tf.convert_to_tensor([[.1, 0., 0., .1], [.1, .1, .1, .4], [.1, .3, 0., .1], [-0.1, .1, -.4, .1], [0., 0., .1, .1], [.1, .1, .1, .1]]) point_ext = self.space.intrinsic_to_extrinsic_coords(point_int) result = self.space.extrinsic_to_intrinsic_coords(point_ext) expected = point_int expected = helper.to_vector(expected) with self.test_session(): self.assertAllClose(gs.eval(result), gs.eval(expected)) sqrt_3 = np.sqrt(3.) point_ext = tf.convert_to_tensor( [[1. / sqrt_3, 0., 0., 1. / sqrt_3, 1. / sqrt_3], [1. / sqrt_3, 1. / sqrt_3, 1. / sqrt_3, 0., 0.], [0., 0., 1. / sqrt_3, 1. / sqrt_3, 1. / sqrt_3]], dtype=np.float64) point_int = self.space.extrinsic_to_intrinsic_coords(point_ext) result = self.space.intrinsic_to_extrinsic_coords(point_int) expected = point_ext expected = helper.to_vector(expected) with self.test_session(): self.assertAllClose(gs.eval(result), gs.eval(expected))
def test_intrinsic_and_extrinsic_coords_vectorization(self): """ Test that the composition of intrinsic_to_extrinsic_coords and extrinsic_to_intrinsic_coords gives the identity. """ point_int = gs.array([[.1, 0., 0., .1, 0., 0.], [.1, .1, .1, .4, .1, 0.], [.1, .3, 0., .1, 0., 0.], [-0.1, .1, -.4, .1, -.01, 0.], [0., 0., .1, .1, -0.08, -0.1], [.1, .1, .1, .1, 0., -0.5]]) point_ext = self.space.intrinsic_to_extrinsic_coords(point_int) result = self.space.extrinsic_to_intrinsic_coords(point_ext) expected = point_int expected = helper.to_vector(expected) self.assertAllClose(result, expected) point_ext = gs.array([[2., 1., 1., 1.], [4., 1., 3., math.sqrt(5.)], [3., 2., 0., 2.]]) point_int = self.space.extrinsic_to_intrinsic_coords(point_ext) result = self.space.intrinsic_to_extrinsic_coords(point_int) expected = point_ext expected = helper.to_vector(expected) self.assertAllClose(result, expected)
def test_intrinsic_and_extrinsic_coords_vectorization(self): """ Test that the composition of intrinsic_to_extrinsic_coords and extrinsic_to_intrinsic_coords gives the identity. """ point_int = gs.array([[.1, 0., 0., .1], [.1, .1, .1, .4], [.1, .3, 0., .1], [-0.1, .1, -.4, .1], [0., 0., .1, .1], [.1, .1, .1, .1]]) point_ext = self.space.intrinsic_to_extrinsic_coords(point_int) result = self.space.extrinsic_to_intrinsic_coords(point_ext) expected = point_int expected = helper.to_vector(expected) gs.testing.assert_allclose(result, expected) n_samples = self.n_samples point_ext = self.space.random_uniform(n_samples=n_samples) point_int = self.space.extrinsic_to_intrinsic_coords(point_ext) result = self.space.intrinsic_to_extrinsic_coords(point_int) expected = point_ext expected = helper.to_vector(expected) gs.testing.assert_allclose(result, expected)
def test_intrinsic_and_extrinsic_coords_vectorization(self): """ Test that the composition of intrinsic_to_extrinsic_coords and extrinsic_to_intrinsic_coords gives the identity. """ point_int = gs.array([[.1, 0., 0., .1, 0., 0.], [.1, .1, .1, .4, .1, 0.], [.1, .3, 0., .1, 0., 0.], [-0.1, .1, -.4, .1, -.01, 0.], [0., 0., .1, .1, -0.08, -0.1], [.1, .1, .1, .1, 0., -0.5]]) point_ext = self.space.intrinsic_to_extrinsic_coords(point_int) result = self.space.extrinsic_to_intrinsic_coords(point_ext) expected = point_int expected = helper.to_vector(expected) with self.test_session(): self.assertAllClose(gs.eval(result), gs.eval(expected)) point_ext = tf.convert_to_tensor([[2.0, 1.0, 1.0, 1.0], [4.0, 1., 3.0, math.sqrt(5)], [3.0, 2.0, 0.0, 2.0]]) point_int = self.space.extrinsic_to_intrinsic_coords(point_ext) result = self.space.intrinsic_to_extrinsic_coords(point_int) # TODO(nina): Make sure this holds for (x, y, z, ..) AND (-x, y,z) expected = point_ext expected = helper.to_vector(expected) with self.test_session(): self.assertAllClose(gs.eval(result), gs.eval(expected))
def test_exp_vectorization(self): n_samples = 3 dim = self.dimension + 1 one_vec = gs.array([2.0, 1.0, 1.0, 1.0]) one_base_point = gs.array([4.0, 3., 1.0, math.sqrt(5)]) n_vecs = gs.array([[2., 1., 1., 1.], [4., 1., 3., math.sqrt(5.)], [3., 2., 0., 2.]]) n_base_points = gs.array( [[2.0, 0.0, 1.0, math.sqrt(2)], [5.0, math.sqrt(8), math.sqrt(8), math.sqrt(8)], [1.0, 0.0, 0.0, 0.0]]) one_tangent_vec = self.space.projection_to_tangent_space( one_vec, base_point=one_base_point) result = self.metric.exp(one_tangent_vec, one_base_point) self.assertAllClose(gs.shape(result), (1, dim)) n_tangent_vecs = self.space.projection_to_tangent_space( n_vecs, base_point=one_base_point) result = self.metric.exp(n_tangent_vecs, one_base_point) self.assertAllClose(gs.shape(result), (n_samples, dim)) expected = np.zeros((n_samples, dim)) with self.session(): for i in range(n_samples): expected[i] = gs.eval( self.metric.exp(n_tangent_vecs[i], one_base_point)) expected = helper.to_vector(gs.array(expected)) self.assertAllClose(result, expected) one_tangent_vec = self.space.projection_to_tangent_space( one_vec, base_point=n_base_points) result = self.metric.exp(one_tangent_vec, n_base_points) self.assertAllClose(gs.shape(result), (n_samples, dim)) expected = np.zeros((n_samples, dim)) with self.session(): for i in range(n_samples): expected[i] = gs.eval( self.metric.exp(one_tangent_vec[i], n_base_points[i])) expected = helper.to_vector(gs.array(expected)) self.assertAllClose(result, expected) n_tangent_vecs = self.space.projection_to_tangent_space( n_vecs, base_point=n_base_points) result = self.metric.exp(n_tangent_vecs, n_base_points) self.assertAllClose(gs.shape(result), (n_samples, dim)) expected = np.zeros((n_samples, dim)) with self.session(): for i in range(n_samples): expected[i] = gs.eval( self.metric.exp(n_tangent_vecs[i], n_base_points[i])) expected = helper.to_vector(gs.array(expected)) self.assertAllClose(result, expected)
def test_exp_vectorization(self): n_samples = 3 dim = self.dimension + 1 one_vec = gs.array([2.0, 1.0, 1.0, 1.0]) one_base_point = gs.array([4.0, 3.0, 1.0, math.sqrt(5)]) n_vecs = gs.array( [ [2.0, 1.0, 1.0, 1.0], [4.0, 1.0, 3.0, math.sqrt(5.0)], [3.0, 2.0, 0.0, 2.0], ] ) n_base_points = gs.array( [ [2.0, 0.0, 1.0, math.sqrt(2)], [5.0, math.sqrt(8), math.sqrt(8), math.sqrt(8)], [1.0, 0.0, 0.0, 0.0], ] ) one_tangent_vec = self.space.to_tangent(one_vec, base_point=one_base_point) result = self.metric.exp(one_tangent_vec, one_base_point) self.assertAllClose(gs.shape(result), (dim,)) n_tangent_vecs = self.space.to_tangent(n_vecs, base_point=one_base_point) result = self.metric.exp(n_tangent_vecs, one_base_point) self.assertAllClose(gs.shape(result), (n_samples, dim)) expected = [] for i in range(n_samples): expected.append(self.metric.exp(n_tangent_vecs[i], one_base_point)) expected = gs.stack(expected, axis=0) expected = helper.to_vector(gs.array(expected)) self.assertAllClose(result, expected, atol=1e-2) one_tangent_vec = self.space.to_tangent(one_vec, base_point=n_base_points) result = self.metric.exp(one_tangent_vec, n_base_points) self.assertAllClose(gs.shape(result), (n_samples, dim)) expected = [] for i in range(n_samples): expected.append(self.metric.exp(one_tangent_vec[i], n_base_points[i])) expected = gs.stack(expected, axis=0) expected = helper.to_vector(gs.array(expected)) self.assertAllClose(result, expected) n_tangent_vecs = self.space.to_tangent(n_vecs, base_point=n_base_points) result = self.metric.exp(n_tangent_vecs, n_base_points) self.assertAllClose(gs.shape(result), (n_samples, dim)) expected = [] for i in range(n_samples): expected.append(self.metric.exp(n_tangent_vecs[i], n_base_points[i])) expected = gs.stack(expected, axis=0) expected = helper.to_vector(gs.array(expected)) self.assertAllClose(result, expected)
def test_mean(self): point = gs.array([1, 4]) result = self.metric.mean(points=[point, point, point]) expected = point expected = helper.to_vector(expected) gs.testing.assert_allclose(result, expected) points = gs.array([[1, 2], [2, 3], [3, 4], [4, 5]]) weights = gs.array([1, 2, 1, 2]) result = self.metric.mean(points, weights) expected = gs.array([16., 22.]) / 6. expected = helper.to_vector(expected) gs.testing.assert_allclose(result, expected)
def test_log_vectorization(self): dim = self.dimension n_samples = 3 one_point = gs.array([[-1., 0.]]) one_base_point = gs.array([[1.0, 0.]]) n_points = gs.array([ [-1., 0.], [1., 0.], [2., math.sqrt(3)]]) n_base_points = gs.array([ [2., -math.sqrt(3)], [4.0, math.sqrt(15)], [-4.0, math.sqrt(15)]]) result = self.metric.log(one_point, one_base_point) expected = one_point - one_base_point expected = helper.to_vector(expected) self.assertAllClose(result, expected) result = self.metric.log(n_points, one_base_point) self.assertAllClose(gs.shape(result), (n_samples, dim)) result = self.metric.log(one_point, n_base_points) self.assertAllClose(gs.shape(result), (n_samples, dim)) result = self.metric.log(n_points, n_base_points) self.assertAllClose(gs.shape(result), (n_samples, dim))
def test_mean(self): point = gs.array([[1., 4.]]) result = self.metric.mean(points=[point, point, point]) expected = point expected = helper.to_vector(expected) self.assertAllClose(result, expected) points = gs.array([[1., 2.], [2., 3.], [3., 4.], [4., 5.]]) weights = gs.array([1., 2., 1., 2.]) result = self.metric.mean(points, weights) expected = gs.array([16. / 6., 22. / 6.]) expected = helper.to_vector(expected) self.assertAllClose(result, expected)
def test_exp_and_log_and_projection_to_tangent_space_general_case(self): """ Test that the riemannian exponential and the riemannian logarithm are inverse. Expect their composition to give the identity function. NB: points on the n-dimensional sphere are (n+1)-D vectors of norm 1. """ # TODO(nina): Fix that this test fails, also in numpy # Riemannian Exp then Riemannian Log # General case # NB: Riemannian log gives a regularized tangent vector, # so we take the norm modulo 2 * pi. base_point = gs.array([0., -3., 0., 3., 4.]) base_point = base_point / gs.linalg.norm(base_point) vector = gs.array([9., 5., 0., 0., -1.]) vector = self.space.projection_to_tangent_space(vector=vector, base_point=base_point) # exp = self.metric.exp(tangent_vec=vector, base_point=base_point) # result = self.metric.log(point=exp, base_point=base_point) expected = vector norm_expected = gs.linalg.norm(expected) regularized_norm_expected = gs.mod(norm_expected, 2 * gs.pi) expected = expected / norm_expected * regularized_norm_expected expected = helper.to_vector(expected)
def test_mean(self): point = gs.array([2., 1., 1., 1.]) points = gs.array([point, point]) result = self.metric.mean(points) expected = helper.to_vector(point) self.assertAllClose(result, expected)
def test_log_and_exp_edge_case(self): """ Test that the riemannian exponential and the riemannian logarithm are inverse. Expect their composition to give the identity function. NB: points on the n-dimensional sphere are (n+1)-D vectors of norm 1. """ # Riemannian Log then Riemannian Exp # Edge case: two very close points, base_point_2 and point_2, # form an angle < epsilon base_point = gs.array([1., 2., 3., 4., 6.]) base_point = base_point / gs.linalg.norm(base_point) point = (base_point + 1e-12 * gs.array([-1., -2., 1., 1., .1])) point = point / gs.linalg.norm(point) log = self.metric.log(point=point, base_point=base_point) result = self.metric.exp(tangent_vec=log, base_point=base_point) expected = point expected = helper.to_vector(expected) self.assertAllClose(result, expected)
def test_log_vectorization(self): dim = self.dimension n_samples = 3 one_point = tf.convert_to_tensor([[-1., 0.]]) one_base_point = tf.convert_to_tensor([[1.0, 0.]]) n_points = tf.convert_to_tensor([[-1., 0.], [1., 0.], [2., math.sqrt(3)]]) n_base_points = tf.convert_to_tensor([[2., -math.sqrt(3)], [4.0, math.sqrt(15)], [-4.0, math.sqrt(15)]]) result = self.metric.log(one_point, one_base_point) expected = one_point - one_base_point expected = helper.to_vector(expected) with self.test_session(): self.assertAllClose(gs.eval(result), gs.eval(expected)) result = self.metric.log(n_points, one_base_point) self.assertAllClose(gs.eval(result).shape, (n_samples, dim)) result = self.metric.log(one_point, n_base_points) self.assertAllClose(gs.eval(result).shape, (n_samples, dim)) result = self.metric.log(n_points, n_base_points) self.assertAllClose(gs.eval(result).shape, (n_samples, dim))
def test_log_vectorization(self): n_samples = self.n_samples dim = self.dimension one_point = gs.array([0., 1.]) one_base_point = gs.array([2., 10.]) n_points = gs.array([ [2., 1.], [-2., -4.], [-5., 1.]]) n_base_points = gs.array([ [2., 10.], [8., -1.], [-3., 6.]]) result = self.metric.log(one_point, one_base_point) expected = one_point - one_base_point expected = helper.to_vector(expected) self.assertAllClose(result, expected) result = self.metric.log(n_points, one_base_point) self.assertAllClose(gs.shape(result), (n_samples, dim)) result = self.metric.log(one_point, n_base_points) self.assertAllClose(gs.shape(result), (n_samples, dim)) result = self.metric.log(n_points, n_base_points) self.assertAllClose(gs.shape(result), (n_samples, dim))
def test_exp_and_log_and_projection_to_tangent_space_edge_case(self): """ Test that the riemannian exponential and the riemannian logarithm are inverse. Expect their composition to give the identity function. NB: points on the n-dimensional sphere are (n+1)-D vectors of norm 1. """ # Riemannian Exp then Riemannian Log # Edge case: tangent vector has norm < epsilon base_point = gs.array([10., -2., -.5, 34., 3.]) base_point = base_point / gs.linalg.norm(base_point) vector = 1e-10 * gs.array([.06, -51., 6., 5., 3.]) vector = self.space.projection_to_tangent_space(vector=vector, base_point=base_point) exp = self.metric.exp(tangent_vec=vector, base_point=base_point) result = self.metric.log(point=exp, base_point=base_point) expected = self.space.projection_to_tangent_space( vector=vector, base_point=base_point) expected = helper.to_vector(expected) self.assertAllClose(result, expected, atol=1e-8)
def test_exp_vectorization(self): n_samples = self.n_samples dim = self.dimension + 1 one_vec = self.space.random_uniform() one_base_point = self.space.random_uniform() n_vecs = self.space.random_uniform(n_samples=n_samples) n_base_points = self.space.random_uniform(n_samples=n_samples) one_tangent_vec = self.space.projection_to_tangent_space( one_vec, base_point=one_base_point) result = self.metric.exp(one_tangent_vec, one_base_point) gs.testing.assert_allclose(result.shape, (1, dim)) n_tangent_vecs = self.space.projection_to_tangent_space( n_vecs, base_point=one_base_point) result = self.metric.exp(n_tangent_vecs, one_base_point) gs.testing.assert_allclose(result.shape, (n_samples, dim)) expected = gs.zeros((n_samples, dim)) for i in range(n_samples): expected[i] = self.metric.exp(n_tangent_vecs[i], one_base_point) expected = helper.to_vector(expected) gs.testing.assert_allclose(result, expected) one_tangent_vec = self.space.projection_to_tangent_space( one_vec, base_point=n_base_points) result = self.metric.exp(one_tangent_vec, n_base_points) gs.testing.assert_allclose(result.shape, (n_samples, dim)) expected = gs.zeros((n_samples, dim)) for i in range(n_samples): expected[i] = self.metric.exp(one_tangent_vec[i], n_base_points[i]) expected = helper.to_vector(expected) gs.testing.assert_allclose(result, expected) n_tangent_vecs = self.space.projection_to_tangent_space( n_vecs, base_point=n_base_points) result = self.metric.exp(n_tangent_vecs, n_base_points) gs.testing.assert_allclose(result.shape, (n_samples, dim)) expected = gs.zeros((n_samples, dim)) for i in range(n_samples): expected[i] = self.metric.exp(n_tangent_vecs[i], n_base_points[i]) expected = helper.to_vector(expected) gs.testing.assert_allclose(result, expected)
def test_log(self): base_point = gs.array([-1., 0.]) point = gs.array([2., math.sqrt(3)]) result = self.metric.log(point=point, base_point=base_point) expected = point - base_point expected = helper.to_vector(expected) self.assertAllClose(result, expected)
def test_log(self): base_point = gs.array([0, 1]) point = gs.array([2, 10]) result = self.metric.log(point=point, base_point=base_point) expected = point - base_point expected = helper.to_vector(expected) gs.testing.assert_allclose(result, expected)
def test_exp(self): base_point = gs.array([1.0, 0.]) vector = gs.array([2., math.sqrt(3)]) result = self.metric.exp(tangent_vec=vector, base_point=base_point) expected = base_point + vector expected = helper.to_vector(expected) self.assertAllClose(result, expected)
def test_exp(self): base_point = gs.array([0, 1]) vector = gs.array([2, 10]) result = self.metric.exp(tangent_vec=vector, base_point=base_point) expected = base_point + vector expected = helper.to_vector(expected) gs.testing.assert_allclose(result, expected)
def test_log(self): base_point = tf.convert_to_tensor([-1., 0.]) point = tf.convert_to_tensor([2., math.sqrt(3)]) result = self.metric.log(point=point, base_point=base_point) expected = point - base_point expected = helper.to_vector(expected) with self.test_session(): self.assertAllClose(gs.eval(result), gs.eval(expected))
def test_exp(self): base_point = tf.convert_to_tensor([1.0, 0.]) vector = tf.convert_to_tensor([2., math.sqrt(3)]) result = self.metric.exp(tangent_vec=vector, base_point=base_point) expected = base_point + vector expected = helper.to_vector(expected) with self.test_session(): self.assertAllClose(gs.eval(result), gs.eval(expected))
def test_mean(self): point = gs.array([0., 0., 0., 0., 1.]) points = gs.zeros((2, point.shape[0])) points[0, :] = point points[1, :] = point result = self.metric.mean(points) expected = helper.to_vector(point) self.assertAllClose(expected, result)
def test_mean(self): # TODO(nina): Fix the fact that it doesn't work for [1., 4.] point = tf.convert_to_tensor([[1., 4.]]) result = self.metric.mean(points=[point, point, point]) expected = point expected = helper.to_vector(expected) with self.test_session(): self.assertAllClose(gs.eval(result), gs.eval(expected)) points = tf.convert_to_tensor([[1., 2.], [2., 3.], [3., 4.], [4., 5.]]) weights = gs.array([1., 2., 1., 2.]) result = self.metric.mean(points, weights) expected = tf.convert_to_tensor([16. / 6., 22. / 6.]) expected = helper.to_vector(expected) with self.test_session(): self.assertAllClose(gs.eval(result), gs.eval(expected))
def test_estimate_hyperbolic(self): point = gs.array([2., 1., 1., 1.]) points = gs.array([point, point]) mean = FrechetMean(metric=self.hyperbolic.metric) mean.fit(X=points) result = mean.estimate_ expected = helper.to_vector(point) self.assertAllClose(result, expected)
def test_intrinsic_and_extrinsic_coords(self): """ Test that the composition of intrinsic_to_extrinsic_coords and extrinsic_to_intrinsic_coords gives the identity. """ point_int = gs.ones(self.dimension) point_ext = self.space.intrinsic_to_extrinsic_coords(point_int) result = self.space.extrinsic_to_intrinsic_coords(point_ext) expected = point_int expected = helper.to_vector(expected) self.assertAllClose(result, expected) point_ext = gs.array([2.0, 1.0, 1.0, 1.0]) point_int = self.space.extrinsic_to_intrinsic_coords(point_ext) result = self.space.intrinsic_to_extrinsic_coords(point_int) expected = point_ext expected = helper.to_vector(expected) self.assertAllClose(result, expected)
def test_intrinsic_and_extrinsic_coords(self): """ Test that the composition of intrinsic_to_extrinsic_coords and extrinsic_to_intrinsic_coords gives the identity. """ point_int = gs.array([.1, 0., 0., .1]) point_ext = self.space.intrinsic_to_extrinsic_coords(point_int) result = self.space.extrinsic_to_intrinsic_coords(point_ext) expected = point_int expected = helper.to_vector(expected) self.assertAllClose(result, expected) point_ext = (1. / (gs.sqrt(6.)) * gs.array([1., 0., 0., 1., 2.])) point_int = self.space.extrinsic_to_intrinsic_coords(point_ext) result = self.space.intrinsic_to_extrinsic_coords(point_int) expected = point_ext expected = helper.to_vector(expected) self.assertAllClose(result, expected)
def test_estimate_sphere(self): point = gs.array([0., 0., 0., 0., 1.]) points = gs.zeros((2, point.shape[0])) points[0, :] = point points[1, :] = point mean = FrechetMean(metric=self.sphere.metric) mean.fit(X=points) result = mean.estimate_ expected = helper.to_vector(point) self.assertAllClose(expected, result)