ucon 0.5.2__py3-none-any.whl → 0.6.0__py3-none-any.whl

tests/ucon/conversion/test_map.py

@@ -1,409 +0,0 @@
-# © 2025 The Radiativity Company
-# Licensed under the Apache License, Version 2.0
-# See the LICENSE file for details.
-
-import unittest
-
-from ucon.maps import AffineMap, ComposedMap, LinearMap, Map
-
-
-class TestLinearMap(unittest.TestCase):
-
-    def test_apply(self):
-        m = LinearMap(39.37)
-        self.assertAlmostEqual(m(1.0), 39.37)
-        self.assertAlmostEqual(m(0.0), 0.0)
-        self.assertAlmostEqual(m(2.5), 98.425)
-
-    def test_inverse(self):
-        m = LinearMap(39.37)
-        inv = m.inverse()
-        self.assertIsInstance(inv, LinearMap)
-        self.assertAlmostEqual(inv.a, 1.0 / 39.37)
-
-    def test_inverse_zero_raises(self):
-        m = LinearMap(0)
-        with self.assertRaises(ZeroDivisionError):
-            m.inverse()
-
-    def test_round_trip(self):
-        m = LinearMap(39.37)
-        for x in [0.0, 1.0, -5.5, 1000.0]:
-            self.assertAlmostEqual(m.inverse()(m(x)), x, places=10)
-
-    def test_compose_closed(self):
-        f = LinearMap(39.37)
-        g = LinearMap(1.0 / 12.0)
-        composed = f @ g
-        self.assertIsInstance(composed, LinearMap)
-        self.assertAlmostEqual(composed.a, 39.37 / 12.0)
-
-    def test_compose_apply(self):
-        f = LinearMap(2.0)
-        g = LinearMap(3.0)
-        # (f @ g)(x) = f(g(x)) = 2 * (3 * x) = 6x
-        self.assertAlmostEqual((f @ g)(5.0), 30.0)
-
-    def test_identity(self):
-        ident = LinearMap.identity()
-        self.assertAlmostEqual(ident(42.0), 42.0)
-        m = LinearMap(7.0)
-        self.assertEqual(m @ ident, m)
-        self.assertEqual(ident @ m, m)
-
-    def test_invertible(self):
-        self.assertTrue(LinearMap(5.0).invertible)
-        self.assertFalse(LinearMap(0).invertible)
-
-    def test_eq(self):
-        self.assertEqual(LinearMap(3.0), LinearMap(3.0))
-        self.assertNotEqual(LinearMap(3.0), LinearMap(4.0))
-
-    def test_repr(self):
-        self.assertIn("39.37", repr(LinearMap(39.37)))
-
-    def test_matmul_non_map_returns_not_implemented(self):
-        m = LinearMap(2.0)
-        result = m.__matmul__(42)
-        self.assertIs(result, NotImplemented)
-
-    def test_matmul_with_affine(self):
-        lin = LinearMap(2.0)
-        aff = AffineMap(3.0, 5.0)
-        composed = lin @ aff
-        # lin(aff(x)) = 2 * (3x + 5) = 6x + 10
-        self.assertIsInstance(composed, AffineMap)
-        self.assertAlmostEqual(composed.a, 6.0)
-        self.assertAlmostEqual(composed.b, 10.0)
-        self.assertAlmostEqual(composed(1.0), 16.0)
-
-    def test_pow(self):
-        m = LinearMap(3.0)
-        squared = m ** 2
-        self.assertIsInstance(squared, LinearMap)
-        self.assertAlmostEqual(squared.a, 9.0)
-
-    def test_pow_negative(self):
-        m = LinearMap(4.0)
-        inv = m ** -1
-        self.assertIsInstance(inv, LinearMap)
-        self.assertAlmostEqual(inv.a, 0.25)
-
-    def test_pow_fractional(self):
-        m = LinearMap(4.0)
-        sqrt = m ** 0.5
-        self.assertIsInstance(sqrt, LinearMap)
-        self.assertAlmostEqual(sqrt.a, 2.0)
-
-    def test_is_identity_true(self):
-        m = LinearMap(1.0)
-        self.assertTrue(m.is_identity())
-
-    def test_is_identity_false(self):
-        m = LinearMap(2.0)
-        self.assertFalse(m.is_identity())
-
-    def test_is_identity_near_one(self):
-        m = LinearMap(1.0 + 1e-10)
-        self.assertTrue(m.is_identity())
-
-    def test_hash(self):
-        m1 = LinearMap(3.0)
-        m2 = LinearMap(3.0)
-        self.assertEqual(hash(m1), hash(m2))
-        self.assertEqual(len({m1, m2}), 1)
-
-
-class TestAffineMap(unittest.TestCase):
-
-    def test_apply(self):
-        # Celsius to Fahrenheit: F = 1.8 * C + 32
-        c_to_f = AffineMap(1.8, 32.0)
-        self.assertAlmostEqual(c_to_f(0.0), 32.0)
-        self.assertAlmostEqual(c_to_f(100.0), 212.0)
-        self.assertAlmostEqual(c_to_f(-40.0), -40.0)
-
-    def test_inverse(self):
-        c_to_f = AffineMap(1.8, 32.0)
-        f_to_c = c_to_f.inverse()
-        self.assertIsInstance(f_to_c, AffineMap)
-        self.assertAlmostEqual(f_to_c(32.0), 0.0)
-        self.assertAlmostEqual(f_to_c(212.0), 100.0)
-
-    def test_inverse_zero_raises(self):
-        m = AffineMap(0, 5.0)
-        with self.assertRaises(ZeroDivisionError):
-            m.inverse()
-
-    def test_round_trip(self):
-        m = AffineMap(1.8, 32.0)
-        for x in [0.0, 100.0, -40.0, 37.5]:
-            self.assertAlmostEqual(m.inverse()(m(x)), x, places=10)
-
-    def test_compose_closed(self):
-        f = AffineMap(2.0, 3.0)
-        g = AffineMap(4.0, 5.0)
-        composed = f @ g
-        self.assertIsInstance(composed, AffineMap)
-        # f(g(x)) = 2*(4x+5)+3 = 8x+13
-        self.assertAlmostEqual(composed.a, 8.0)
-        self.assertAlmostEqual(composed.b, 13.0)
-
-    def test_compose_apply(self):
-        f = AffineMap(2.0, 3.0)
-        g = AffineMap(4.0, 5.0)
-        for x in [0.0, 1.0, -2.0]:
-            self.assertAlmostEqual((f @ g)(x), f(g(x)), places=10)
-
-    def test_invertible(self):
-        self.assertTrue(AffineMap(1.8, 32.0).invertible)
-        self.assertFalse(AffineMap(0, 32.0).invertible)
-
-    def test_eq(self):
-        self.assertEqual(AffineMap(1.8, 32.0), AffineMap(1.8, 32.0))
-        self.assertNotEqual(AffineMap(1.8, 32.0), AffineMap(1.8, 0.0))
-
-    def test_repr(self):
-        r = repr(AffineMap(1.8, 32.0))
-        self.assertIn("1.8", r)
-        self.assertIn("32.0", r)
-
-    def test_matmul_with_linear(self):
-        aff = AffineMap(2.0, 3.0)
-        lin = LinearMap(4.0)
-        composed = aff @ lin
-        # aff(lin(x)) = 2 * (4x) + 3 = 8x + 3
-        self.assertIsInstance(composed, AffineMap)
-        self.assertAlmostEqual(composed.a, 8.0)
-        self.assertAlmostEqual(composed.b, 3.0)
-        self.assertAlmostEqual(composed(1.0), 11.0)
-
-    def test_matmul_non_map_returns_not_implemented(self):
-        m = AffineMap(1.8, 32.0)
-        result = m.__matmul__("not a map")
-        self.assertIs(result, NotImplemented)
-
-    def test_pow_one(self):
-        m = AffineMap(1.8, 32.0)
-        result = m ** 1
-        self.assertIs(result, m)
-
-    def test_pow_negative_one(self):
-        m = AffineMap(1.8, 32.0)
-        result = m ** -1
-        inv = m.inverse()
-        self.assertEqual(result.a, inv.a)
-        self.assertEqual(result.b, inv.b)
-
-    def test_pow_invalid_raises(self):
-        m = AffineMap(1.8, 32.0)
-        with self.assertRaises(ValueError) as ctx:
-            m ** 2
-        self.assertIn("only supports exp=1 or exp=-1", str(ctx.exception))
-
-    def test_is_identity_true(self):
-        m = AffineMap(1.0, 0.0)
-        self.assertTrue(m.is_identity())
-
-    def test_is_identity_false_due_to_offset(self):
-        m = AffineMap(1.0, 5.0)
-        self.assertFalse(m.is_identity())
-
-    def test_is_identity_false_due_to_scale(self):
-        m = AffineMap(2.0, 0.0)
-        self.assertFalse(m.is_identity())
-
-    def test_hash(self):
-        m1 = AffineMap(1.8, 32.0)
-        m2 = AffineMap(1.8, 32.0)
-        self.assertEqual(hash(m1), hash(m2))
-        self.assertEqual(len({m1, m2}), 1)
-
-
-class TestComposedMap(unittest.TestCase):
-
-    def test_heterogeneous_composition(self):
-        # LinearMap @ AffineMap now returns AffineMap (closed composition)
-        # Use ComposedMap directly to test the fallback behavior
-        lin = LinearMap(2.0)
-        aff = AffineMap(3.0, 1.0)
-        composed = ComposedMap(lin, aff)
-        # lin(aff(x)) = 2 * (3x + 1) = 6x + 2
-        self.assertAlmostEqual(composed(0.0), 2.0)
-        self.assertAlmostEqual(composed(1.0), 8.0)
-
-    def test_inverse(self):
-        composed = ComposedMap(LinearMap(2.0), AffineMap(3.0, 1.0))
-        for x in [0.0, 1.0, -3.0, 10.0]:
-            self.assertAlmostEqual(composed.inverse()(composed(x)), x, places=10)
-
-    def test_invertible(self):
-        self.assertTrue(ComposedMap(LinearMap(2.0), AffineMap(3.0, 1.0)).invertible)
-        self.assertFalse(ComposedMap(LinearMap(0), AffineMap(3.0, 1.0)).invertible)
-
-    def test_non_invertible_raises(self):
-        composed = ComposedMap(LinearMap(0), AffineMap(3.0, 1.0))
-        with self.assertRaises(ValueError):
-            composed.inverse()
-
-    def test_repr(self):
-        composed = ComposedMap(LinearMap(2.0), AffineMap(3.0, 1.0))
-        r = repr(composed)
-        self.assertIn("LinearMap", r)
-        self.assertIn("AffineMap", r)
-
-    def test_matmul(self):
-        c1 = ComposedMap(LinearMap(2.0), AffineMap(3.0, 1.0))
-        c2 = LinearMap(5.0)
-        composed = c1 @ c2
-        self.assertIsInstance(composed, ComposedMap)
-        # c1(c2(x)) = c1(5x) = 2*(3*5x + 1) = 30x + 2
-        self.assertAlmostEqual(composed(1.0), 32.0)
-        self.assertAlmostEqual(composed(0.0), 2.0)
-
-    def test_matmul_non_map_returns_not_implemented(self):
-        composed = ComposedMap(LinearMap(2.0), AffineMap(3.0, 1.0))
-        result = composed.__matmul__(42)
-        self.assertIs(result, NotImplemented)
-
-    def test_pow_one(self):
-        composed = ComposedMap(LinearMap(2.0), AffineMap(3.0, 1.0))
-        result = composed ** 1
-        self.assertIs(result, composed)
-
-    def test_pow_negative_one(self):
-        composed = ComposedMap(LinearMap(2.0), AffineMap(3.0, 1.0))
-        result = composed ** -1
-        # Round-trip should be identity
-        for x in [0.0, 1.0, 5.0]:
-            self.assertAlmostEqual(result(composed(x)), x, places=10)
-
-    def test_pow_invalid_raises(self):
-        composed = ComposedMap(LinearMap(2.0), AffineMap(3.0, 1.0))
-        with self.assertRaises(ValueError) as ctx:
-            composed ** 2
-        self.assertIn("only supports exp=1 or exp=-1", str(ctx.exception))
-
-    def test_invertible_both_non_invertible(self):
-        composed = ComposedMap(LinearMap(0), LinearMap(0))
-        self.assertFalse(composed.invertible)
-
-    def test_invertible_inner_non_invertible(self):
-        composed = ComposedMap(LinearMap(2.0), LinearMap(0))
-        self.assertFalse(composed.invertible)
-
-    def test_is_identity(self):
-        composed = ComposedMap(LinearMap(1.0), LinearMap(1.0))
-        self.assertTrue(composed.is_identity())
-
-    def test_is_identity_false(self):
-        composed = ComposedMap(LinearMap(2.0), LinearMap(0.5))
-        self.assertTrue(composed.is_identity())  # 2 * 0.5 = 1
-
-    def test_is_identity_with_offset(self):
-        composed = ComposedMap(LinearMap(1.0), AffineMap(1.0, 5.0))
-        self.assertFalse(composed.is_identity())
-
-
-class TestMapABC(unittest.TestCase):
-
-    def test_cannot_instantiate(self):
-        with self.assertRaises(TypeError):
-            Map()
-
-
-class TestCrossTypeComposition(unittest.TestCase):
-    """Tests for composition between different Map types."""
-
-    def test_linear_at_affine_at_linear(self):
-        """Chain: LinearMap @ AffineMap @ LinearMap"""
-        l1 = LinearMap(2.0)
-        a = AffineMap(3.0, 1.0)
-        l2 = LinearMap(4.0)
-        # l1 @ a = AffineMap(6, 2)
-        # (l1 @ a) @ l2 = AffineMap(24, 2)
-        composed = l1 @ a @ l2
-        self.assertIsInstance(composed, AffineMap)
-        self.assertAlmostEqual(composed(1.0), 26.0)
-
-    def test_affine_at_linear_at_affine(self):
-        """Chain: AffineMap @ LinearMap @ AffineMap"""
-        a1 = AffineMap(2.0, 1.0)
-        l = LinearMap(3.0)
-        a2 = AffineMap(4.0, 5.0)
-        # l @ a2 = AffineMap(12, 15)
-        # a1 @ (l @ a2) = AffineMap(24, 31)
-        composed = a1 @ l @ a2
-        self.assertIsInstance(composed, AffineMap)
-        self.assertAlmostEqual(composed(1.0), 55.0)
-
-    def test_composed_preserves_semantics(self):
-        """Verify f @ g computes f(g(x)) correctly for all type combinations."""
-        maps = [
-            LinearMap(2.0),
-            LinearMap(0.5),
-            AffineMap(3.0, 1.0),
-            AffineMap(1.0, -5.0),
-        ]
-        for f in maps:
-            for g in maps:
-                composed = f @ g
-                for x in [0.0, 1.0, -2.0, 10.0]:
-                    expected = f(g(x))
-                    actual = composed(x)
-                    self.assertAlmostEqual(actual, expected, places=10,
-                        msg=f"Failed for {type(f).__name__} @ {type(g).__name__} at x={x}")
-
-
-class TestMapEdgeCases(unittest.TestCase):
-    """Edge case tests for Map hierarchy."""
-
-    def test_linear_map_with_negative_scale(self):
-        m = LinearMap(-3.0)
-        self.assertAlmostEqual(m(5.0), -15.0)
-        self.assertAlmostEqual(m.inverse()(m(5.0)), 5.0)
-
-    def test_affine_map_with_negative_scale(self):
-        m = AffineMap(-2.0, 10.0)
-        self.assertAlmostEqual(m(5.0), 0.0)
-        self.assertAlmostEqual(m.inverse()(m(5.0)), 5.0)
-
-    def test_linear_map_very_small_scale(self):
-        m = LinearMap(1e-10)
-        self.assertAlmostEqual(m(1e10), 1.0)
-        self.assertTrue(m.invertible)
-
-    def test_linear_map_very_large_scale(self):
-        m = LinearMap(1e10)
-        self.assertAlmostEqual(m(1e-10), 1.0)
-        self.assertTrue(m.invertible)
-
-    def test_affine_identity(self):
-        """AffineMap(1, 0) should be identity."""
-        m = AffineMap(1.0, 0.0)
-        for x in [0.0, 1.0, -100.0, 1e6]:
-            self.assertAlmostEqual(m(x), x)
-
-    def test_linear_identity(self):
-        """LinearMap(1) should be identity."""
-        m = LinearMap(1.0)
-        for x in [0.0, 1.0, -100.0, 1e6]:
-            self.assertAlmostEqual(m(x), x)
-
-    def test_composed_map_deep_nesting(self):
-        """Test deeply nested ComposedMap."""
-        m = LinearMap(2.0)
-        for _ in range(5):
-            m = ComposedMap(m, LinearMap(1.5))
-        # 2 * 1.5^5 = 2 * 7.59375 = 15.1875
-        self.assertAlmostEqual(m(1.0), 2.0 * (1.5 ** 5))
-
-    def test_inverse_of_inverse(self):
-        """(m.inverse()).inverse() == m"""
-        m = LinearMap(7.0)
-        self.assertEqual(m.inverse().inverse(), m)
-
-        m2 = AffineMap(3.0, 5.0)
-        double_inv = m2.inverse().inverse()
-        self.assertAlmostEqual(double_inv.a, m2.a)
-        self.assertAlmostEqual(double_inv.b, m2.b)

tests/ucon/test_algebra.py

@@ -1,239 +0,0 @@
-# © 2025 The Radiativity Company
-# Licensed under the Apache License, Version 2.0
-# See the LICENSE file for details.
-
-import math
-from unittest import TestCase
-
-from ucon.algebra import Exponent, Vector
-
-
-class TestVector(TestCase):
-
-    def test_vector_iteration_and_length(self):
-        v = Vector(1, 0, 0, 0, 0, 0, 0, 0)
-        self.assertEqual(tuple(v), (1, 0, 0, 0, 0, 0, 0, 0))
-        self.assertEqual(len(v), 8)  # 7 SI + 1 information
-
-    def test_vector_addition(self):
-        v1 = Vector(1, 0, 0, 0, 0, 0, 0, 0)
-        v2 = Vector(0, 2, 0, 0, 0, 0, 0, 0)
-        result = v1 + v2
-        self.assertEqual(result, Vector(1, 2, 0, 0, 0, 0, 0, 0))
-
-    def test_vector_subtraction(self):
-        v1 = Vector(2, 1, 0, 0, 0, 0, 0, 0)
-        v2 = Vector(1, 1, 0, 0, 0, 0, 0, 0)
-        self.assertEqual(v1 - v2, Vector(1, 0, 0, 0, 0, 0, 0, 0))
-
-    def test_vector_scalar_multiplication_by_integer(self):
-        v = Vector(1, -2, 0, 0, 0, 0, 3, 0)
-        scaled = v * 2
-        self.assertEqual(scaled, Vector(2, -4, 0, 0, 0, 0, 6, 0))
-        self.assertEqual(v, Vector(1, -2, 0, 0, 0, 0, 3, 0))  # original unchanged
-
-    def test_vector_scalar_multiplication_by_float(self):
-        v = Vector(0, 1, 0, 0, 0, 0, 0, 0)
-        scaled = v * 0.5
-        self.assertEqual(scaled, Vector(0.0, 0.5, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0))
-
-    def test_vector_scalar_multiplication_by_zero(self):
-        v = Vector(1, 2, 3, 4, 5, 6, 7, 8)
-        zeroed = v * 0
-        self.assertEqual(zeroed, Vector(0, 0, 0, 0, 0, 0, 0, 0))
-
-    def test_vector_equality_and_hash(self):
-        v1 = Vector(1, 0, 0, 0, 0, 0, 0, 0)
-        v2 = Vector(1, 0, 0, 0, 0, 0, 0, 0)
-        v3 = Vector(0, 1, 0, 0, 0, 0, 0, 0)
-        self.assertTrue(v1 == v2)
-        self.assertFalse(v1 == v3)
-        self.assertEqual(hash(v1), hash(v2))
-        self.assertNotEqual(hash(v1), hash(v3))
-
-
-class TestVectorEdgeCases(TestCase):
-
-    def test_zero_vector_equality_and_additivity(self):
-        zero = Vector()
-        self.assertEqual(zero, Vector(0, 0, 0, 0, 0, 0, 0, 0))
-        # Adding or subtracting zero should yield same vector
-        v = Vector(1, 2, 3, 4, 5, 6, 7, 8)
-        self.assertEqual(v + zero, v)
-        self.assertEqual(v - zero, v)
-
-    def test_vector_with_negative_exponents(self):
-        v1 = Vector(1, -2, 3, 0, 0, 0, 0, 0)
-        v2 = Vector(-1, 2, -3, 0, 0, 0, 0, 0)
-        result = v1 + v2
-        self.assertEqual(result, Vector(0, 0, 0, 0, 0, 0, 0, 0))
-        self.assertEqual(v1 - v1, Vector())  # perfect cancellation
-
-    def test_vector_equality_with_non_vector(self):
-        v = Vector()
-        # Non-Vector comparisons return NotImplemented, which Python
-        # resolves to False (not equal) rather than raising an error
-        self.assertFalse(v == "not a vector")
-        self.assertFalse(v == None)
-
-    def test_hash_consistency_for_equal_vectors(self):
-        v1 = Vector(1, 0, 0, 0, 0, 0, 0, 0)
-        v2 = Vector(1, 0, 0, 0, 0, 0, 0, 0)
-        self.assertEqual(hash(v1), hash(v2))
-        self.assertEqual(len({v1, v2}), 1)
-
-    def test_iter_length_order_consistency(self):
-        v = Vector(1, 2, 3, 4, 5, 6, 7, 8)
-        components = list(v)
-        self.assertEqual(len(components), len(v))
-        # Ensure order of iteration is fixed (T→L→M→I→Θ→J→N→B)
-        self.assertEqual(components, [1, 2, 3, 4, 5, 6, 7, 8])
-
-    def test_vector_arithmetic_does_not_mutate_operands(self):
-        v1 = Vector(1, 0, 0, 0, 0, 0, 0, 0)
-        v2 = Vector(0, 1, 0, 0, 0, 0, 0, 0)
-        _ = v1 + v2
-        self.assertEqual(v1, Vector(1, 0, 0, 0, 0, 0, 0, 0))
-        self.assertEqual(v2, Vector(0, 1, 0, 0, 0, 0, 0, 0))
-
-    def test_invalid_addition_type_raises(self):
-        v = Vector(1, 0, 0, 0, 0, 0, 0, 0)
-        with self.assertRaises(TypeError):
-            _ = v + "length"
-        with self.assertRaises(TypeError):
-            _ = v - 5
-
-
-class TestExponent(TestCase):
-
-    thousand = Exponent(10, 3)
-    thousandth = Exponent(10, -3)
-    kibibyte = Exponent(2, 10)
-    mebibyte = Exponent(2, 20)
-
-    def test___init__(self):
-        with self.assertRaises(ValueError):
-            Exponent(5, 3)  # no support for base 5 logarithms
-
-    def test_parts(self):
-        self.assertEqual((10, 3), self.thousand.parts())
-        self.assertEqual((10, -3), self.thousandth.parts())
-
-    def test_evaluated_property(self):
-        self.assertEqual(1000, self.thousand.evaluated)
-        self.assertAlmostEqual(0.001, self.thousandth.evaluated)
-        self.assertEqual(1024, self.kibibyte.evaluated)
-        self.assertEqual(1048576, self.mebibyte.evaluated)
-
-    def test___truediv__(self):
-         # same base returns a new Exponent
-        ratio = self.thousand / self.thousandth
-        self.assertIsInstance(ratio, Exponent)
-        self.assertEqual(ratio.base, 10)
-        self.assertEqual(ratio.power, 6)
-        self.assertEqual(ratio.evaluated, 1_000_000)
-
-        # different base returns numeric float
-        val = self.thousand / self.kibibyte
-        self.assertIsInstance(val, float)
-        self.assertAlmostEqual(1000 / 1024, val)
-
-    def test___mul__(self):
-        product = self.kibibyte * self.mebibyte
-        self.assertIsInstance(product, Exponent)
-        self.assertEqual(product.base, 2)
-        self.assertEqual(product.power, 30)
-        self.assertEqual(product.evaluated, 2**30)
-
-        # cross-base multiplication returns numeric
-        val = self.kibibyte * self.thousand
-        self.assertIsInstance(val, float)
-        self.assertAlmostEqual(1024 * 1000, val)
-
-    def test___hash__(self):
-        a = Exponent(10, 3)
-        b = Exponent(10, 3)
-        self.assertEqual(hash(a), hash(b))
-        self.assertEqual(len({a, b}), 1) # both should hash to same value
-
-    def test___float__(self):
-        self.assertEqual(float(self.thousand), 1000.0)
-
-    def test___int__(self):
-        self.assertEqual(int(self.thousand), 1000)
-
-    def test_comparisons(self):
-        self.assertTrue(self.thousand > self.thousandth)
-        self.assertTrue(self.thousandth < self.thousand)
-        self.assertTrue(self.kibibyte < self.mebibyte)
-        self.assertTrue(self.kibibyte == Exponent(2, 10))
-
-        with self.assertRaises(TypeError):
-            _ = self.thousand == 1000  # comparison to non-Exponent
-
-    def test___repr__(self):
-        self.assertIn("Exponent", repr(Exponent(10, -3)))
-
-    def test___str__(self):
-        self.assertEqual(str(self.thousand), '10^3')
-        self.assertEqual(str(self.thousandth), '10^-3')
-
-    def test_to_base(self):
-        e = Exponent(2, 10)
-        converted = e.to_base(10)
-        self.assertIsInstance(converted, Exponent)
-        self.assertEqual(converted.base, 10)
-        self.assertAlmostEqual(converted.power, math.log10(1024), places=10)
-
-        with self.assertRaises(ValueError):
-            e.to_base(5)
-
-
-class TestExponentEdgeCases(TestCase):
-
-    def test_extreme_powers(self):
-        e = Exponent(10, 308)
-        self.assertTrue(math.isfinite(e.evaluated))
-        e_small = Exponent(10, -308)
-        self.assertGreater(e.evaluated, e_small.evaluated)
-
-    def test_precision_rounding_in_hash(self):
-        a = Exponent(10, 6)
-        b = Exponent(10, 6 + 1e-16)
-        # rounding in hash avoids floating drift
-        self.assertEqual(hash(a), hash(b))
-
-    def test_negative_and_zero_power(self):
-        e0 = Exponent(10, 0)
-        e_neg = Exponent(10, -1)
-        self.assertEqual(e0.evaluated, 1.0)
-        self.assertEqual(e_neg.evaluated, 0.1)
-        self.assertLess(e_neg, e0)
-
-    def test_valid_exponent_evaluates_correctly(self):
-        base, power = 10, 3
-        e = Exponent(base, power)
-        self.assertEqual(e.evaluated, 1000)
-        self.assertEqual(e.parts(), (base, power))
-        self.assertEqual(f'{base}^{power}', str(e))
-        self.assertEqual(f'Exponent(base={base}, power={power})', repr(e))
-
-    def test_invalid_base_raises_value_error(self):
-        with self.assertRaises(ValueError):
-            Exponent(5, 2)
-
-    def test_exponent_comparisons(self):
-        e1 = Exponent(10, 2)
-        e2 = Exponent(10, 3)
-        self.assertTrue(e1 < e2)
-        self.assertTrue(e2 > e1)
-        self.assertFalse(e1 == e2)
-
-    def test_division_returns_exponent(self):
-        e1 = Exponent(10, 3)
-        e2 = Exponent(10, 2)
-        self.assertEqual(e1 / e2, Exponent(10, 1))
-
-    def test_equality_with_different_type(self):
-        with self.assertRaises(TypeError):
-            Exponent(10, 2) == "10^2"