def test_transformation_interval(self, points, params):
manual_transformation = RotationZX()
auto_transformation = Composition(RotationZ(), RotationX())
self.assertSound(manual_transformation.transform(points, params),
params,
partial(manual_transformation.transform, points))
self.assertSound(auto_transformation.transform(points, params), params,
partial(auto_transformation.transform, points))
def test_taylor_approximation(self, x, params):
manual_transformation = RotationZX()
auto_transformation = Composition(RotationZ(), RotationX())
manual = taylor.encode(manual_transformation, x, params)
auto = taylor.encode(auto_transformation, x, params)
self.assertSound(manual, params,
partial(manual_transformation.transform, x))
self.assertSound(auto, params, partial(auto_transformation.transform,
x))
def parse_transformation(serialized: str) -> Transformation:
split = serialized.strip().split('+')
if len(split) < 1:
raise ValueError(
"Invalid transformation, expecting at least one valid transformation."
)
elif len(split) == 1:
transformation = _TRANSFORMATIONS[split[0].lower()]
if transformation is None:
raise ValueError(
f"Unknown transformation {split[0]}, please specify a valid transformation or implement it."
)
return transformation()
else:
transformation = Composition(parse_transformation(split[0]),
parse_transformation(split[1]))
for i in range(2, len(split)):
transformation = Composition(transformation,
parse_transformation(split[i]))
return transformation
def test_taylor_approximation(self, x, params):
manual_transformation = TaperingRotation()
auto_transformation = Composition(TaperingZ(), RotationZ())
expected = taylor.encode(manual_transformation, x, params)
actual = taylor.encode(auto_transformation, x, params)
self.assertSound(expected, params,
partial(manual_transformation.transform, x))
self.assertSound(actual, params,
partial(auto_transformation.transform, x))
self.assertAlmostEqualBounds(expected, actual)
def test_taylor_twisting_rotation(self, x, params):
transformation = Composition(TwistingZ(), RotationZ())
actual = taylor.encode(transformation, x, params)
self.assertSound(actual, params, partial(transformation.transform, x))
def test_hessian_points_params_float(self, points, params):
expected = RotationZX().hessian_points_params(points, params)
actual = Composition(RotationZ(), RotationX()).hessian_points_params(
points, params)
self.assertAlmostEqualList(expected, actual)
def test_hessian_points_params_interval(self, points, params):
expected = TaperingRotation().hessian_points_params(points, params)
actual = Composition(TaperingZ(), RotationZ()).hessian_points_params(
points, params)
self.assertAlmostEqualList(expected, actual)
def test_transformation_float(self, points, params):
manual_transformation = RotationZX()
auto_transformation = Composition(RotationZ(), RotationX())
expected = manual_transformation.transform(points, params)
actual = auto_transformation.transform(points, params)
self.assertAlmostEqualNumpy(expected, actual)
def test_gradient_points_float(self, points, params):
expected = TaperingRotation().gradient_points(points, params)
actual = Composition(TaperingZ(),
RotationZ()).gradient_points(points, params)
self.assertAlmostEqualList(expected, actual)
def test_transformation_interval(self, points, params):
expected = TaperingRotation().transform(points, params)
actual = Composition(TaperingZ(),
RotationZ()).transform(points, params)
self.assertAlmostEqualInterval(expected, actual)
def test_taylor_rot_zyx(self, x, params):
transformation = Composition(RotationZ(),
Composition(RotationY(), RotationX()))
actual = taylor.encode(transformation, x, params)
self.assertSound(actual, params, partial(transformation.transform, x))