def gradient_points(
self, points: np.ndarray, params: Union[List[float], List[Interval]]
) -> Union[List[np.ndarray], List[Interval]]:
(alpha, ) = params
x = points[:, 0]
y = points[:, 1]
z = points[:, 2]
zero = iv.zeros_like(z)
one = iv.ones_like(z)
return [
iv.stack(
[iv.cos(alpha * z), iv.sin(alpha * z), zero],
axis=1,
convert=isinstance(alpha, Interval)),
iv.stack([-iv.sin(alpha * z),
iv.cos(alpha * z), zero],
axis=1,
convert=isinstance(alpha, Interval)),
iv.stack([
alpha * (-iv.sin(alpha * z) * x - iv.cos(alpha * z) * y),
alpha * (iv.cos(alpha * z) * x - iv.sin(alpha * z) * y), one
],
axis=1,
convert=isinstance(alpha, Interval)),
]
def hessian_points(self, points: np.ndarray, params: Union[List[float], List[Interval]]) -> Union[List[List[np.ndarray]], List[List[Interval]]]:
a, b, theta = params
z = points[:, 2]
zero = iv.zeros_like(z)
one = iv.ones_like(z)
return [
[
iv.stack([
zero,
zero,
zero
], axis=1, convert=isinstance(a, Interval)),
iv.stack([
zero,
zero,
zero
], axis=1, convert=isinstance(a, Interval)),
iv.stack([
(0.5 * iv.square(a) + b) * iv.cos(theta) * one,
(0.5 * iv.square(a) + b) * iv.sin(theta) * one,
zero
], axis=1, convert=isinstance(a, Interval)),
],
[
iv.stack([
zero,
zero,
zero
], axis=1, convert=isinstance(a, Interval)),
iv.stack([
zero,
zero,
zero
], axis=1, convert=isinstance(a, Interval)),
iv.stack([
-(0.5 * iv.square(a) + b) * iv.sin(theta) * one,
(0.5 * iv.square(a) + b) * iv.cos(theta) * one,
zero
], axis=1, convert=isinstance(a, Interval))
],
[
iv.stack([
(0.5 * iv.square(a) + b) * iv.cos(theta) * one,
(0.5 * iv.square(a) + b) * iv.sin(theta) * one,
zero
], axis=1, convert=isinstance(a, Interval)),
iv.stack([
-(0.5 * iv.square(a) + b) * iv.sin(theta) * one,
(0.5 * iv.square(a) + b) * iv.cos(theta) * one,
zero
], axis=1, convert=isinstance(a, Interval)),
iv.stack([
zero,
zero,
zero
], axis=1, convert=isinstance(a, Interval))
],
]
def transform(
self, points: np.ndarray,
params: Union[List[float],
List[Interval]]) -> Union[np.ndarray, Interval]:
assert len(params) == 1
alpha = params[0]
x = points[:, 0]
y = points[:, 1]
z = points[:, 2]
x_transformed = x * iv.cos(alpha * z) - y * iv.sin(alpha * z)
y_transformed = x * iv.sin(alpha * z) + y * iv.cos(alpha * z)
z_transformed = z
return iv.stack([x_transformed, y_transformed, z_transformed],
axis=1,
convert=isinstance(alpha, Interval))
def gradient_params(
self, points: np.ndarray, params: Union[List[float], List[Interval]]
) -> Union[List[np.ndarray], List[Interval]]:
assert len(params) == 1
alpha = params[0]
x = points[:, 0]
y = points[:, 1]
z = points[:, 2]
d_alpha_x = -z * (x * iv.sin(z * alpha) + y * iv.cos(z * alpha))
d_alpha_y = z * (x * iv.cos(z * alpha) - y * iv.sin(z * alpha))
d_alpha_z = iv.zeros_like(z)
return [
iv.stack([d_alpha_x, d_alpha_y, d_alpha_z],
axis=1,
convert=isinstance(alpha, Interval))
]
def gradient_params(self, points: np.ndarray, params: Union[List[float], List[Interval]]) -> Union[List[np.ndarray], List[Interval]]:
a, b = params
x = points[:, 0]
y = points[:, 1]
z = points[:, 2]
return [
iv.stack([
-iv.sin(a) * x - iv.cos(a) * iv.cos(b) * y + iv.cos(a) * iv.sin(b) * z,
iv.cos(a) * x - iv.sin(a) * iv.cos(b) * y + iv.sin(a) * iv.sin(b) * z,
iv.zeros_like(z)
], axis=1, convert=isinstance(a, Interval)),
iv.stack([
iv.sin(a) * iv.sin(b) * y + iv.sin(a) * iv.cos(b) * z,
-iv.cos(a) * iv.sin(b) * y - iv.cos(a) * iv.cos(b) * z,
iv.cos(b) * y - iv.sin(b) * z
], axis=1, convert=isinstance(a, Interval)),
]
def hessian_params(
self, points: np.ndarray, params: Union[List[float], List[Interval]]
) -> Union[List[List[np.ndarray]], List[List[Interval]]]:
assert len(params) == 1
alpha = params[0]
x = points[:, 0]
y = points[:, 1]
z = points[:, 2]
d_alpha_alpha_x = -iv.square(z) * (x * iv.cos(alpha * z) -
y * iv.sin(alpha * z))
d_alpha_alpha_y = -iv.square(z) * (x * iv.sin(alpha * z) +
y * iv.cos(alpha * z))
d_alpha_alpha_z = iv.zeros_like(z)
return [[
iv.stack([d_alpha_alpha_x, d_alpha_alpha_y, d_alpha_alpha_z],
axis=1,
convert=isinstance(alpha, Interval))
]]
def hessian_points_params(self, points: np.ndarray, params: Union[List[float], List[Interval]]) -> Union[List[List[np.ndarray]], List[List[Interval]]]:
a, b = params
x = points[:, 0]
zero = iv.zeros_like(x)
one = iv.ones_like(x)
return [
[
iv.stack([
-iv.sin(a) * one,
iv.cos(a) * one,
zero
], axis=1, convert=isinstance(a, Interval)),
iv.stack([
zero,
zero,
zero
], axis=1, convert=isinstance(a, Interval)),
],
[
iv.stack([
-iv.cos(a) * iv.cos(b) * one,
-iv.sin(a) * iv.cos(b) * one,
zero
], axis=1, convert=isinstance(a, Interval)),
iv.stack([
iv.sin(a) * iv.sin(b) * one,
-iv.cos(a) * iv.sin(b) * one,
iv.cos(b) * one
], axis=1, convert=isinstance(a, Interval)),
],
[
iv.stack([
iv.cos(a) * iv.sin(b) * one,
iv.sin(a) * iv.sin(b) * one,
zero
], axis=1, convert=isinstance(a, Interval)),
iv.stack([
iv.sin(a) * iv.cos(b) * one,
-iv.cos(a) * iv.cos(b) * one,
-iv.sin(b) * one
], axis=1, convert=isinstance(a, Interval)),
]
]
def gradient_points(self, points: np.ndarray, params: Union[List[float], List[Interval]]) -> Union[List[np.ndarray], List[Interval]]:
a, b, theta = params
x = points[:, 0]
y = points[:, 1]
z = points[:, 2]
zero = iv.zeros_like(z)
one = iv.ones_like(z)
return [
iv.stack([
(0.5 * iv.square(a) * z + b * z + 1) * iv.cos(theta),
(0.5 * iv.square(a) * z + b * z + 1) * iv.sin(theta),
zero
], axis=1, convert=isinstance(a, Interval)),
iv.stack([
-(0.5 * iv.square(a) * z + b * z + 1) * iv.sin(theta),
(0.5 * iv.square(a) * z + b * z + 1) * iv.cos(theta),
zero
], axis=1, convert=isinstance(a, Interval)),
iv.stack([
(0.5 * iv.square(a) + b) * (iv.cos(theta) * x - iv.sin(theta) * y),
(0.5 * iv.square(a) + b) * (iv.sin(theta) * x + iv.cos(theta) * y),
one
], axis=1, convert=isinstance(a, Interval))
]
def transform(self, points: np.ndarray, params: Union[List[float], List[Interval]]) -> Union[np.ndarray, Interval]:
a, b = params
x = points[:, 0]
y = points[:, 1]
z = points[:, 2]
return iv.stack([
iv.cos(a) * x - iv.sin(a) * iv.cos(b) * y + iv.sin(a) * iv.sin(b) * z,
iv.sin(a) * x + iv.cos(a) * iv.cos(b) * y - iv.cos(a) * iv.sin(b) * z,
iv.sin(b) * y + iv.cos(b) * z
], axis=1, convert=isinstance(a, Interval))
def hessian_points_params(
self, points: np.ndarray, params: Union[List[float], List[Interval]]
) -> Union[List[List[np.ndarray]], List[List[Interval]]]:
(alpha, ) = params
x = points[:, 0]
y = points[:, 1]
z = points[:, 2]
zero = iv.zeros_like(x)
return [
[
iv.stack([
-z * iv.sin(alpha * z),
z * iv.cos(alpha * z),
zero,
],
axis=1,
convert=isinstance(alpha, Interval))
],
[
iv.stack([
-z * iv.cos(alpha * z),
-z * iv.sin(alpha * z),
zero,
],
axis=1,
convert=isinstance(alpha, Interval))
],
[
iv.stack([
-x * iv.sin(alpha * z) -
alpha * x * z * iv.cos(alpha * z) +
alpha * y * z * iv.sin(alpha * z) - y * iv.cos(alpha * z),
-alpha * x * z * iv.sin(alpha * z) +
x * iv.cos(alpha * z) - y * iv.sin(alpha * z) -
alpha * y * z * iv.cos(alpha * z),
zero,
],
axis=1,
convert=isinstance(alpha, Interval))
],
]
def hessian_params(self, points: np.ndarray, params: Union[List[float], List[Interval]]) -> Union[List[List[np.ndarray]], List[List[Interval]]]:
a, b = params
x = points[:, 0]
y = points[:, 1]
z = points[:, 2]
zero = iv.zeros_like(x)
return [
[
iv.stack([
-iv.cos(a) * x + iv.sin(a) * iv.cos(b) * y - iv.sin(a) * iv.sin(b) * z,
-iv.sin(a) * x - iv.cos(a) * iv.cos(b) * y + iv.cos(a) * iv.sin(b) * z,
zero
], axis=1, convert=isinstance(a, Interval)),
iv.stack([
iv.cos(a) * iv.sin(b) * y + iv.cos(a) * iv.cos(b) * z,
iv.sin(a) * iv.sin(b) * y + iv.sin(a) * iv.cos(b) * z,
zero
], axis=1, convert=isinstance(a, Interval)),
],
[
iv.stack([
iv.cos(a) * iv.sin(b) * y + iv.cos(a) * iv.cos(b) * z,
iv.sin(a) * iv.sin(b) * y + iv.sin(a) * iv.cos(b) * z,
zero
], axis=1, convert=isinstance(a, Interval)),
iv.stack([
iv.sin(a) * iv.cos(b) * y - iv.sin(a) * iv.sin(b) * z,
-iv.cos(a) * iv.cos(b) * y + iv.cos(a) * iv.sin(b) * z,
-iv.sin(b) * y - iv.cos(b) * z
], axis=1, convert=isinstance(a, Interval)),
]
]
def hessian_points(
self, points: np.ndarray, params: Union[List[float], List[Interval]]
) -> Union[List[List[np.ndarray]], List[List[Interval]]]:
(alpha, ) = params
x = points[:, 0]
y = points[:, 1]
z = points[:, 2]
zero = iv.zeros_like(x)
return [
[
iv.stack([
zero,
zero,
zero,
],
axis=1,
convert=isinstance(alpha, Interval)),
iv.stack([
zero,
zero,
zero,
],
axis=1,
convert=isinstance(alpha, Interval)),
iv.stack([
-alpha * iv.sin(alpha * z),
alpha * iv.cos(alpha * z),
zero,
],
axis=1,
convert=isinstance(alpha, Interval)),
],
[
iv.stack([
zero,
zero,
zero,
],
axis=1,
convert=isinstance(alpha, Interval)),
iv.stack([
zero,
zero,
zero,
],
axis=1,
convert=isinstance(alpha, Interval)),
iv.stack([
-alpha * iv.cos(alpha * z),
-alpha * iv.sin(alpha * z),
zero,
],
axis=1,
convert=isinstance(alpha, Interval)),
],
[
iv.stack([
-alpha * iv.sin(alpha * z),
alpha * iv.cos(alpha * z),
zero,
],
axis=1,
convert=isinstance(alpha, Interval)),
iv.stack([
-alpha * iv.cos(alpha * z),
-alpha * iv.sin(alpha * z),
zero,
],
axis=1,
convert=isinstance(alpha, Interval)),
iv.stack([
iv.square(alpha) *
(-iv.cos(alpha * z) * x + iv.sin(alpha * z) * y),
iv.square(alpha) *
(-iv.sin(alpha * z) * x - iv.cos(alpha * z) * y),
zero,
],
axis=1,
convert=isinstance(alpha, Interval)),
],
]
def test_single_scalar(self, a, expected):
self.assertAlmostEqual(expected, iv.sin(a))
def test_nd_array(self, a):
self.assertAlmostEqualNumpy(np.sin(a), iv.sin(a))
def test_nd_interval(self, a):
self.assertSound(iv.sin(a), [a], np.sin)
def hessian_params(self, points: np.ndarray, params: Union[List[float], List[Interval]]) -> Union[List[List[np.ndarray]], List[List[Interval]]]:
a, b, theta = params
x = points[:, 0]
y = points[:, 1]
z = points[:, 2]
zero = iv.zeros_like(z)
return [
[
iv.stack([
z * (iv.cos(theta) * x - iv.sin(theta) * y),
z * (iv.sin(theta) * x + iv.cos(theta) * y),
zero
], axis=1, convert=isinstance(a, Interval)),
iv.stack([
zero,
zero,
zero
], axis=1, convert=isinstance(a, Interval)),
iv.stack([
-a * z * (iv.sin(theta) * x + iv.cos(theta) * y),
a * z * (iv.cos(theta) * x - iv.sin(theta) * y),
zero
], axis=1, convert=isinstance(a, Interval))
],
[
iv.stack([
zero,
zero,
zero
], axis=1, convert=isinstance(a, Interval)),
iv.stack([
zero,
zero,
zero
], axis=1, convert=isinstance(a, Interval)),
iv.stack([
-z * (iv.sin(theta) * x + iv.cos(theta) * y),
z * (iv.cos(theta) * x - iv.sin(theta) * y),
zero
], axis=1, convert=isinstance(a, Interval))
],
[
iv.stack([
-a * z * (iv.sin(theta) * x + iv.cos(theta) * y),
a * z * (iv.cos(theta) * x - iv.sin(theta) * y),
zero
], axis=1, convert=isinstance(a, Interval)),
iv.stack([
-z * (iv.sin(theta) * x + iv.cos(theta) * y),
z * (iv.cos(theta) * x - iv.sin(theta) * y),
zero
], axis=1, convert=isinstance(a, Interval)),
iv.stack([
(0.5 * iv.square(a) * z + b * z + 1) * (-iv.cos(theta) * x + iv.sin(theta) * y),
(0.5 * iv.square(a) * z + b * z + 1) * (-iv.sin(theta) * x - iv.cos(theta) * y),
zero
], axis=1, convert=isinstance(a, Interval))
]
]
def test_single_interval(self, a, expected):
self.assertEqual(expected, iv.sin(a))
self.assertSound(iv.sin(a), [a], np.sin)