def test_is_equal(self, arr):
assume(GeneralQuaternion(*arr).norm() > DEFAULT_TOLERANCE)
q = Quaternion(*arr)
assert q == q
assert q == -q
assert q != q + Quaternion(1, 2, 3, 4)
assert q == GeneralQuaternion(*q.coordinates)
def test_type(self):
# Unit quaternion can be unitary or general:
assert isinstance(GeneralQuaternion.unit(), GeneralQuaternion)
assert isinstance(Quaternion.unit(), Quaternion)
# Unit quaternion can not be unitary:
assert isinstance(GeneralQuaternion.zero(), GeneralQuaternion)
assert not isinstance(Quaternion.zero(), Quaternion)
assert isinstance(Quaternion.zero(), GeneralQuaternion)
assert isinstance(exp(GeneralQuaternion(1, 2, 3, 4)), GeneralQuaternion)
assert isinstance(exp(Quaternion(1, 2, 3, 4)), Quaternion)
assert isinstance(log(Quaternion(1, 2, 3, 4)), GeneralQuaternion)
assert not isinstance(log(Quaternion(1, 2, 3, 4)), Quaternion)
def test_average(self, arr):
q = GeneralQuaternion(*arr[:4])
assume(q.norm() > DEFAULT_TOLERANCE) # ignore quaternions of norm==0, whose inverse is numerically unstable
q = q.normalized()
randoms = [GeneralQuaternion(*arr[4*i: 4*i+4]) for i in range(1, self.NUM_ELEMENTS+1)]
q_with_noise = [q + n * (.1 * DEFAULT_TOLERANCE) for n in randoms]
# test without weights:
average = Quaternion.average(*q_with_noise)
assert average == q or average == -q
# test with weights:
weights = [1] + (self.NUM_ELEMENTS-1) * [0] # only uses q_with_noise[0]
average = Quaternion.average(*q_with_noise, weights=weights)
assert average == q_with_noise[0] or average == -q_with_noise[0]
def test_mul(self, arr):
assume(GeneralQuaternion(*arr).norm() > DEFAULT_TOLERANCE)
q = Quaternion(*arr)
# multiply by scalar:
assert isinstance(2 * q, Quaternion)
assert isinstance(q * 2, Quaternion)
assert q == q * 2 == 2 * q # Note: up to scale; differs from GeneralQuaternion() * 2
# multiply by Quaternion:
other = Quaternion(1, 2, 3, 4)
assert isinstance(q * other, Quaternion)
assert (q * other).is_unitary()
# multiply by GeneralQuaternion:
other = GeneralQuaternion(1, 2, 3, 4)
for mul in [other * q, q * other]:
assert isinstance(mul, GeneralQuaternion) and not isinstance(mul, Quaternion)
assert mul.norm() == pytest.approx(other.norm())
def test_distance(self, arr, angle_rad):
assume(GeneralQuaternion(*arr).norm() > DEFAULT_TOLERANCE)
q = Quaternion(*arr)
assert q.distance(-q) == pytest.approx(0) or q.distance(-q) == pytest.approx(2 * np.math.pi)
for diff in [Quaternion.from_ra_dec_roll(np.degrees(angle_rad), 0, 0),
Quaternion.from_ra_dec_roll(0, np.degrees(angle_rad), 0),
Quaternion.from_ra_dec_roll(0, 0, np.degrees(angle_rad))]:
assert q.distance(q * diff) == pytest.approx(angle_rad)
assert q.distance(diff * q) == pytest.approx(angle_rad)
def test_positive_representant(self, arr):
assume(GeneralQuaternion(*arr).norm() > DEFAULT_TOLERANCE)
q = Quaternion(*arr)
assert q.positive_representant == q or q.positive_representant == -q
assert q.positive_representant == (-q).positive_representant
def test_constructor(self, arr):
assume(GeneralQuaternion(*arr).norm() > DEFAULT_TOLERANCE)
q = Quaternion(*arr)
assert isinstance(q, Quaternion)
assert q.is_unitary()
def test_exp_log(self, arr):
assume(np.linalg.norm(arr) > DEFAULT_TOLERANCE)
q = GeneralQuaternion(*arr).normalized()
assert exp(log(q)) == q
assert (log(exp(q)).imaginary.tolist() == pytest.approx(
q.imaginary.tolist())) # log defined up to real
def test_log_identity(self):
assert log(Quaternion.unit()) == GeneralQuaternion.zero()
def test_exp_identity(self):
assert exp(GeneralQuaternion.zero()) == Quaternion.unit()
def test_basis(self, arr):
assume(GeneralQuaternion(*arr).norm() > DEFAULT_TOLERANCE)
q = Quaternion(*arr)
b1, b2, b3 = q.basis
assert np.array_equal([b1, b2, b3], q.matrix)
def test_from_matrix(self, arr):
assume(GeneralQuaternion(*arr).norm() > DEFAULT_TOLERANCE)
q = Quaternion(*arr)
assert q.from_matrix(q.matrix) == q
def test_matrix(self, arr):
assume(GeneralQuaternion(*arr).norm() > DEFAULT_TOLERANCE)
q = Quaternion(*arr)
m = q.matrix
np.testing.assert_almost_equal(np.identity(3), m.dot(m.T))
