def test_write_and_read_array(self, tmp_path, rng): # noqa: F811
file_name = str(tmp_path / "test.ga")
mv_array = MVArray([random_point_pair(rng=rng) for i in range(1000)])
mv_array.save(file_name, compression=True, transpose=False, sparse=False, support=False)
loaded_array = layout.load_ga_file(file_name)
np.testing.assert_equal(loaded_array.value, mv_array.value)
def test_2d_mv_array(self, g3):
layout, blades = g3, g3.blades
Nrows = 2
Ncolumns = 3
value_array_a = self._random_value_array(g3, Nrows, Ncolumns)
value_array_b = self._random_value_array(g3, Nrows, Ncolumns)
mv_array_a = MVArray.from_value_array(layout, value_array_a)
assert mv_array_a.shape == (Nrows, Ncolumns)
mv_array_b = MVArray.from_value_array(layout, value_array_b)
assert mv_array_b.shape == (Nrows, Ncolumns)
# check properties of the array are preserved (no need to check both a and b)
np.testing.assert_array_equal(mv_array_a.value, value_array_a)
assert mv_array_a.value.dtype == value_array_a.dtype
assert type(mv_array_a.value) == type(value_array_a)
# Check addition
mv_array_sum = mv_array_a + mv_array_b
array_sum = value_array_a + value_array_b
np.testing.assert_array_equal(mv_array_sum.value, array_sum)
# Check elementwise gp
mv_array_gp = mv_array_a * mv_array_b
value_array_gp = np.zeros((Nrows, Ncolumns, layout.gaDims))
for i in range(Nrows):
for j in range(Ncolumns):
value_array_gp[i,
j, :] = layout.gmt_func(value_array_a[i, j, :],
value_array_b[i, j, :])
np.testing.assert_array_equal(mv_array_gp.value, value_array_gp)
# Check elementwise op
mv_array_op = mv_array_a ^ mv_array_b
value_array_op = np.zeros((Nrows, Ncolumns, layout.gaDims))
for i in range(Nrows):
for j in range(Ncolumns):
value_array_op[i,
j, :] = layout.omt_func(value_array_a[i, j, :],
value_array_b[i, j, :])
np.testing.assert_array_equal(mv_array_op.value, value_array_op)
# Check elementwise ip
mv_array_ip = mv_array_a | mv_array_b
value_array_ip = np.zeros((Nrows, Ncolumns, layout.gaDims))
for i in range(Nrows):
for j in range(Ncolumns):
value_array_ip[i,
j, :] = layout.imt_func(value_array_a[i, j, :],
value_array_b[i, j, :])
np.testing.assert_array_equal(mv_array_ip.value, value_array_ip)
def test_array_overload(self, algebra):
'''
test overload operations
'''
layout, blades = algebra, algebra.blades
test_array = MVArray([layout.randomMV() for i in range(100)])
normed_array = test_array.normal()
other_array = np.array([t.normal().value for t in test_array])
np.testing.assert_almost_equal(normed_array.value, other_array)
dual_array = test_array.dual()
other_array_2 = np.array([t.dual().value for t in test_array])
np.testing.assert_almost_equal(dual_array.value, other_array_2)
def object_set_cost_matrix(object_set_a, object_set_b,
object_type="generic", symmetric=False):
"""
Evaluates the rotor cost matrix between two sets of objects
"""
object_array_a = MVArray(object_set_a).value
object_array_b = MVArray(object_set_b).value
if object_type == 'lines':
ret_mat = val_line_set_cost_matrix(object_array_a, object_array_b)
if symmetric:
ret_mat = np.minimum(ret_mat, val_line_set_cost_matrix(object_array_a, -object_array_b))
return ret_mat
else:
ret_mat = val_object_set_cost_matrix(object_array_a, object_array_b)
if symmetric:
ret_mat = np.minimum(ret_mat, val_object_set_cost_matrix(object_array_a, -object_array_b))
return ret_mat
def test_array_control(self, g3, rng): # noqa: F811
'''
test methods to take control addition from numpy arrays
'''
layout, blades = g3, g3.blades
e1 = blades['e1']
e3 = blades['e3']
e12 = blades['e12']
for i in range(100):
number_array = rng.random(4)
output = e12 + (e1 * number_array)
output2 = MVArray([e12 + (e1 * n) for n in number_array])
np.testing.assert_almost_equal(output, output2)
output = e12 + (e1 * number_array)
output2 = MVArray([e12 + (e1 * n) for n in number_array])
np.testing.assert_almost_equal(output, output2)
output = (number_array * e1) + e12
output2 = MVArray([(n * e1) + e12 for n in number_array])
np.testing.assert_almost_equal(output, output2)
output = number_array / e12
output2 = MVArray([n / e12 for n in number_array])
np.testing.assert_almost_equal(output, output2)
output = (e1 / number_array)
output2 = MVArray([(e1 / n) for n in number_array])
np.testing.assert_almost_equal(output, output2)
output = ((e1 / number_array) * e3) / e12
output2 = MVArray([((e1 / n) * e3) / e12 for n in number_array])
np.testing.assert_almost_equal(output, output2)
def _mv_ones(num_elements):
return MVArray([D.MultiVector(value=np.ones(2**4, dtype=np.float32)) for i in range(num_elements)])
