ucon 0.3.3rc2__py3-none-any.whl → 0.3.4__py3-none-any.whl

tests/ucon/test_core.py

@@ -1,101 +1,264 @@
 import math
-from unittest import TestCase
+import unittest
 
 from ucon import Number
 from ucon import Exponent
 from ucon import Ratio
 from ucon import Scale
 from ucon import Dimension
+from ucon import Unit
 from ucon import units
-from ucon.unit import Unit
+from ucon.algebra import Vector
+from ucon.core import CompositeUnit, ScaleDescriptor
 
 
-class TestExponent(TestCase):
+class TestDimension(unittest.TestCase):
 
-    thousand = Exponent(10, 3)
-    thousandth = Exponent(10, -3)
-    kibibyte = Exponent(2, 10)
-    mebibyte = Exponent(2, 20)
+    def test_basic_dimensions_are_unique(self):
+        seen = set()
+        for dim in Dimension:
+            self.assertNotIn(dim.value, seen, f'Duplicate vector found for {dim.name}')
+            seen.add(dim.value)
 
-    def test___init__(self):
-        with self.assertRaises(ValueError):
-            Exponent(5, 3)  # no support for base 5 logarithms
+    def test_multiplication_adds_exponents(self):
+        self.assertEqual(
+            Dimension.mass * Dimension.acceleration,
+            Dimension.force,
+        )
+        self.assertEqual(
+            Dimension.length * Dimension.length,
+            Dimension.area,
+        )
+        self.assertEqual(
+            Dimension.length * Dimension.length * Dimension.length,
+            Dimension.volume,
+        )
+
+    def test_division_subtracts_exponents(self):
+        self.assertEqual(
+            Dimension.length / Dimension.time,
+            Dimension.velocity,
+        )
+        self.assertEqual(
+            Dimension.force / Dimension.area,
+            Dimension.pressure,
+        )
 
-    def test_parts(self):
-        self.assertEqual((10, 3), self.thousand.parts())
-        self.assertEqual((10, -3), self.thousandth.parts())
+    # def test_none_dimension_behaves_neutrally(self):
+    #     base = Dimension.mass
+    #     self.assertEqual(base * Dimension.none, base)
+    #     self.assertEqual(base / Dimension.none, base)
+    #     self.assertEqual(Dimension.none * base, base)
+    #     with self.assertRaises(ValueError) as exc:
+    #         Dimension.none / base
+    #     assert type(exc.exception) == ValueError
+    #     assert str(exc.exception).endswith('is not a valid Dimension')
+
+    def test_hash_and_equality_consistency(self):
+        d1 = Dimension.mass
+        d2 = Dimension.mass
+        d3 = Dimension.length
+        self.assertEqual(d1, d2)
+        self.assertNotEqual(d1, d3)
+        self.assertEqual(hash(d1), hash(d2))
+        self.assertNotEqual(hash(d1), hash(d3))
+
+    def test_composite_quantities_examples(self):
+        # Energy = Force * Length
+        self.assertEqual(
+            Dimension.force * Dimension.length,
+            Dimension.energy,
+        )
+        # Power = Energy / Time
+        self.assertEqual(
+            Dimension.energy / Dimension.time,
+            Dimension.power,
+        )
+        # Pressure = Force / Area
+        self.assertEqual(
+            Dimension.force / Dimension.area,
+            Dimension.pressure,
+        )
+        # Charge = Current * Time
+        self.assertEqual(
+            Dimension.current * Dimension.time,
+            Dimension.charge,
+        )
 
-    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_vector_equality_reflects_dimension_equality(self):
+        self.assertEqual(Dimension.mass.value, Dimension.mass.value)
+        self.assertNotEqual(Dimension.mass.value, Dimension.time.value)
+        self.assertEqual(Dimension.mass, Dimension.mass)
+        self.assertNotEqual(Dimension.mass, Dimension.time)
+
+    def test_pow_identity_and_zero(self):
+        self.assertIs(Dimension.length ** 1, Dimension.length)
+        self.assertIs(Dimension.mass ** 0, Dimension.none)
+
+    def test_pow_known_results(self):
+        self.assertEqual(Dimension.length ** 2, Dimension.area)
+        self.assertEqual(Dimension.time ** -1, Dimension.frequency)
+
+    def test_pow_returns_derived_dimension_for_unknown(self):
+        jerk = Dimension.length * (Dimension.time ** -3)  # length / time^3
+        self.assertTrue(jerk.name.startswith("derived("))
+        self.assertNotIn(jerk.name, Dimension.__members__)
+
+    def test_resolve_known_vector_returns_enum_member(self):
+        dim = Dimension._resolve(Vector(0, 1, 0, 0, 0, 0, 0))
+        self.assertIs(dim, Dimension.length)
+
+    def test_resolve_unknown_vector_returns_dynamic_dimension(self):
+        vec = Vector(T=1, L=-1, M=0, I=0, Θ=0, J=0, N=0)  # “speed per time”, not an enum member
+        dyn = Dimension._resolve(vec)
+        self.assertNotIn(dyn.name, Dimension.__members__)
+        self.assertEqual(dyn.value, vec)
+        self.assertEqual(dyn.name, f"derived({vec})")
+
+    def test_resolve_returns_same_dynamic_for_same_vector(self):
+        vec = Vector(T=2, L=-2, M=0, I=0, Θ=0, J=0, N=0)
+        first = Dimension._resolve(vec)
+        second = Dimension._resolve(vec)
+        self.assertEqual(first.value, second.value)
+        self.assertEqual(first.name, second.name)
+
+    def test_dynamic_dimensions_compare_by_vector(self):
+        v1 = Vector(T=2, L=-2, M=0, I=0, Θ=0, J=0, N=0)
+        v2 = Vector(T=2, L=-2, M=0, I=0, Θ=0, J=0, N=0)
+        d1 = Dimension._resolve(v1)
+        d2 = Dimension._resolve(v2)
+        self.assertEqual(d1.value, d2.value)
+        self.assertEqual(d1 == d2, True)
+        self.assertEqual(hash(d1), hash(d2))
+
+    def test_pow_zero_returns_none(self):
+        # Dimension ** 0 should always return Dimension.none
+        self.assertIs(Dimension.length ** 0, Dimension.none)
+
+    def test_pow_fractional(self):
+        # Fractional powers = derived dimensions not equal to any registered one
+        d = Dimension.length ** 0.5
+        self.assertIsInstance(d, Dimension)
+        self.assertNotIn(d, list(Dimension))
+
+    def test_invalid_operand_multiply(self):
+        with self.assertRaises(TypeError):
+            Dimension.length * 10
 
-    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_invalid_operand_divide(self):
+        with self.assertRaises(TypeError):
+            Dimension.time / "bad"
+
+
+class TestDimensionResolve(unittest.TestCase):
+
+    def test_registered_multiplication(self):
+        # velocity = length / time
+        v = Dimension.length / Dimension.time
+        self.assertIs(v, Dimension.velocity)
+        self.assertEqual(v.value, Vector(-1, 1, 0, 0, 0, 0, 0))
+
+    def test_registered_power(self):
+        # area = length ** 2
+        a = Dimension.length ** 2
+        self.assertIs(a, Dimension.area)
+        self.assertEqual(a.value, Vector(0, 2, 0, 0, 0, 0, 0))
+
+    def test_unregistered_multiplication_creates_derived(self):
+        # L * M should yield derived(Vector(L=1, M=1))
+        d = Dimension.length * Dimension.mass
+        self.assertIsInstance(d, Dimension)
+        self.assertNotIn(d, list(Dimension))
+        self.assertIn("derived", d.name)
+        self.assertEqual(d.value, Vector(0, 1, 1, 0, 0, 0, 0))
+
+    def test_unregistered_division_creates_derived(self):
+        # M / T should yield derived(Vector(M=1, T=-1))
+        d = Dimension.mass / Dimension.time
+        self.assertIsInstance(d, Dimension)
+        self.assertNotIn(d, list(Dimension))
+        self.assertIn("derived", d.name)
+        self.assertEqual(d.value, Vector(-1, 0, 1, 0, 0, 0, 0))
+
+    def test_unregistered_power_creates_derived(self):
+        # (L * M)^2 → derived(Vector(L=2, M=2))
+        d1 = Dimension.length * Dimension.mass
+        d2 = d1 ** 2
+        self.assertIsInstance(d2, Dimension)
+        self.assertIn("derived", d2.name)
+        self.assertEqual(d2.value, Vector(0, 2, 2, 0, 0, 0, 0))
+
+    def test_registered_vs_derived_equality(self):
+        # Ensure derived dimensions only equal themselves
+        derived = Dimension.length * Dimension.mass
+        again = Dimension._resolve(Vector(0, 1, 1, 0, 0, 0, 0))
+        self.assertEqual(derived, again)
+        self.assertNotEqual(derived, Dimension.length)
+        self.assertNotEqual(derived, Dimension.mass)
+
+
+class TestDimensionEdgeCases(unittest.TestCase):
+
+    def test_invalid_multiplication_type(self):
+        with self.assertRaises(TypeError):
+            Dimension.length * 5
+        with self.assertRaises(TypeError):
+            "mass" * Dimension.time
 
-    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))
+    def test_invalid_division_type(self):
+        with self.assertRaises(TypeError):
+            Dimension.time / "length"
+        with self.assertRaises(TypeError):
+            5 / Dimension.mass
 
+    def test_equality_with_non_dimension(self):
         with self.assertRaises(TypeError):
-            _ = self.thousand == 1000  # comparison to non-Exponent
+            Dimension.mass ==  "mass"
 
-    def test___repr__(self):
-        self.assertIn("Exponent", repr(Exponent(10, -3)))
+    def test_enum_uniqueness_and_hash(self):
+        # Hashes should be unique per distinct dimension
+        hashes = {hash(d) for d in Dimension}
+        self.assertEqual(len(hashes), len(Dimension))
+        # All Dimension.value entries must be distinct Vectors
+        values = [d.value for d in Dimension]
+        self.assertEqual(len(values), len(set(values)))
+
+    def test_combined_chained_operations(self):
+        # (mass * acceleration) / area = pressure
+        result = (Dimension.mass * Dimension.acceleration) / Dimension.area
+        self.assertEqual(result, Dimension.pressure)
+
+    def test_dimension_round_trip_equality(self):
+        # Multiplying and dividing by the same dimension returns self
+        d = Dimension.energy
+        self.assertEqual((d * Dimension.none) / Dimension.none, d)
+        self.assertEqual(d / Dimension.none, d)
+        self.assertEqual(Dimension.none * d, d)
+
+    def test_enum_is_hashable_and_iterable(self):
+        seen = {d for d in Dimension}
+        self.assertIn(Dimension.mass, seen)
+        self.assertEqual(len(seen), len(Dimension))
+
+
+class TestScaleDescriptor(unittest.TestCase):
 
-    def test___str__(self):
-        self.assertEqual(str(self.thousand), '10^3')
-        self.assertEqual(str(self.thousandth), '10^-3')
+    def test_scale_descriptor_power_and_repr(self):
+        exp = Exponent(10, 3)
+        desc = ScaleDescriptor(exp, "k", "kilo")
 
-    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)
+        # power property should reflect Exponent.power
+        assert desc.power == 3
+        assert desc.base == 10
+        assert math.isclose(desc.evaluated, 1e3)
 
-        with self.assertRaises(ValueError):
-            e.to_base(5)
+        # repr should include alias and power
+        r = repr(desc)
+        assert "kilo" in r or "k" in r
+        assert "10^3" in r
 
 
-class TestScale(TestCase):
+class TestScale(unittest.TestCase):
 
     def test___truediv__(self):
         self.assertEqual(Scale.deca, Scale.one / Scale.deci)
@@ -103,7 +266,6 @@ class TestScale(TestCase):
         self.assertEqual(Scale.kibi, Scale.mebi / Scale.kibi)
         self.assertEqual(Scale.milli, Scale.one / Scale.deca / Scale.deca / Scale.deca)
         self.assertEqual(Scale.deca, Scale.kilo / Scale.hecto)
-        self.assertEqual(Scale._kibi, Scale.one / Scale.kibi)
         self.assertEqual(Scale.kibi, Scale.kibi / Scale.one)
         self.assertEqual(Scale.one, Scale.one / Scale.one)
         self.assertEqual(Scale.one, Scale.kibi / Scale.kibi)
@@ -126,11 +288,11 @@ class TestScale(TestCase):
 
     def test_all(self):
         for scale in Scale:
-            self.assertTrue(isinstance(scale.value, Exponent))
+            self.assertTrue(isinstance(scale.value.exponent, Exponent))
         self.assertIsInstance(Scale.all(), dict)
 
 
-class TestScaleMultiplicationAdditional(TestCase):
+class TestScaleMultiplicationAdditional(unittest.TestCase):
 
     def test_decimal_combinations(self):
         self.assertEqual(Scale.kilo * Scale.centi, Scale.deca)
@@ -166,8 +328,28 @@ class TestScaleMultiplicationAdditional(TestCase):
         self.assertIsInstance(result, Scale)
         self.assertEqual(result.value.base, 10)
 
+    def test_scale_multiplication_with_unit(self):
+        meter = Unit('m', name='meter', dimension=Dimension.length)
+        kilometer = Scale.kilo * meter
+        self.assertIsInstance(kilometer, Unit)
+        self.assertEqual(kilometer.scale, Scale.kilo)
+        self.assertEqual(kilometer.dimension, Dimension.length)
+        self.assertIn('meter', kilometer.name)
+
+    def test_scale_multiplication_with_unit_returns_not_implemented_for_invalid_type(self):
+        with self.assertRaises(TypeError):
+            Scale.kilo * 1
+
+    def test_scale_mul_with_unknown_exponent_hits_nearest(self):
+        # Construct two strange scales (base10^7 * base10^5 = base10^12 = tera)
+        s = Scale.nearest(10**7) * Scale.nearest(10**5)
+        self.assertIs(s, Scale.tera)
+
+    def test_scale_mul_non_unit_non_scale(self):
+        self.assertEqual(Scale.kilo.__mul__("nope"), NotImplemented)
 
-class TestScaleDivisionAdditional(TestCase):
+
+class TestScaleDivisionAdditional(unittest.TestCase):
 
     def test_division_same_base_large_gap(self):
         # kilo / milli = mega
@@ -184,7 +366,6 @@ class TestScaleDivisionAdditional(TestCase):
 
     def test_division_binary_inverse_scales(self):
         self.assertEqual(Scale.kibi / Scale.kibi, Scale.one)
-        self.assertEqual(Scale.kibi / Scale.mebi, Scale._kibi)
         self.assertEqual(Scale.mebi / Scale.kibi, Scale.kibi)
 
     def test_division_unmatched_returns_nearest(self):
@@ -198,8 +379,15 @@ class TestScaleDivisionAdditional(TestCase):
         with self.assertRaises(TypeError):
             Scale.kilo / 42
 
+    def test_scale_div_hits_nearest(self):
+        # giga / kilo = 10^(9-3) = 10^6 = mega
+        self.assertIs(Scale.giga / Scale.kilo, Scale.mega)
+
+    def test_scale_div_non_scale(self):
+        self.assertEqual(Scale.kilo.__truediv__("bad"), NotImplemented)
 
-class TestScaleNearestAdditional(TestCase):
+
+class TestScaleNearestAdditional(unittest.TestCase):
 
     def test_nearest_handles_zero(self):
         self.assertEqual(Scale.nearest(0), Scale.one)
@@ -230,7 +418,7 @@ class TestScaleNearestAdditional(TestCase):
         self.assertEqual(Scale.nearest(10**-9), Scale.nano)
 
 
-class TestScaleInternals(TestCase):
+class TestScaleInternals(unittest.TestCase):
 
     def test_decimal_and_binary_sets_are_disjoint(self):
         decimal_bases = {s.value.base for s in Scale._decimal_scales()}
@@ -253,175 +441,195 @@ class TestScaleInternals(TestCase):
         self.assertIs(Scale.by_value(), Scale.by_value())
 
 
-class TestNumber(TestCase):
-
-    number = Number(unit=units.gram, quantity=1)
+class TestUnit(unittest.TestCase):
 
-    def test_as_ratio(self):
-        ratio = self.number.as_ratio()
-        self.assertIsInstance(ratio, Ratio)
-        self.assertEqual(ratio.numerator, self.number)
-        self.assertEqual(ratio.denominator, Number())
-
-    def test_simplify(self):
-        ten_decagrams = Number(unit=units.gram, scale=Scale.deca, quantity=10)
-        point_one_decagrams = Number(unit=units.gram, scale=Scale.deca, quantity=0.1)
-        two_kibigrams = Number(unit=units.gram, scale=Scale.kibi, quantity=2)
-
-        self.assertEqual(Number(unit=units.gram, quantity=100), ten_decagrams.simplify())
-        self.assertEqual(Number(unit=units.gram, quantity=1), point_one_decagrams.simplify())
-        self.assertEqual(Number(unit=units.gram, quantity=2048), two_kibigrams.simplify())
-
-    def test_to(self):
-        thousandth_of_a_kilogram = Number(unit=units.gram, scale=Scale.kilo, quantity=0.001)
-        thousand_milligrams = Number(unit=units.gram, scale=Scale.milli, quantity=1000)
-        kibigram_fraction = Number(unit=units.gram, scale=Scale.kibi, quantity=0.0009765625)
-
-        self.assertEqual(thousandth_of_a_kilogram, self.number.to(Scale.kilo))
-        self.assertEqual(thousand_milligrams, self.number.to(Scale.milli))
-        self.assertEqual(kibigram_fraction, self.number.to(Scale.kibi))
-
-    def test___repr__(self):
-        self.assertIn(str(self.number.quantity), str(self.number))
-        self.assertIn(str(self.number.scale.value.evaluated), str(self.number))
-        self.assertIn(self.number.unit.name, str(self.number))
-
-    def test___truediv__(self):
-        some_number = Number(unit=units.gram, scale=Scale.deca, quantity=10)
-        another_number = Number(unit=units.gram, scale=Scale.milli, quantity=10)
-        that_number = Number(unit=units.gram, scale=Scale.kibi, quantity=10)
-
-        some_quotient = self.number / some_number
-        another_quotient = self.number / another_number
-        that_quotient = self.number / that_number
-
-        self.assertEqual(some_quotient.value, 0.01)
-        self.assertEqual(another_quotient.value, 100.0)
-        self.assertEqual(that_quotient.value, 0.00009765625)
-
-    def test___eq__(self):
-        self.assertEqual(self.number, Ratio(self.number))  # 1 gram / 1
-        with self.assertRaises(TypeError):
-            self.number == 1
-
-
-class TestRatio(TestCase):
-
-    point_five = Number(quantity=0.5)
-    one = Number()
-    two = Number(quantity=2)
-    three = Number(quantity=3)
-    four = Number(quantity=4)
-
-    one_half = Ratio(numerator=one, denominator=two)
-    three_fourths = Ratio(numerator=three, denominator=four)
-    one_ratio = Ratio(numerator=one)
-    three_halves = Ratio(numerator=three, denominator=two)
-    two_ratio = Ratio(numerator=two, denominator=one)
-
-    def test_evaluate(self):
-        self.assertEqual(self.one_ratio.numerator, self.one)
-        self.assertEqual(self.one_ratio.denominator, self.one)
-        self.assertEqual(self.one_ratio.evaluate(), self.one)
-        self.assertEqual(self.two_ratio.evaluate(), self.two)
-
-    def test_reciprocal(self):
-        self.assertEqual(self.two_ratio.reciprocal().numerator, self.one)
-        self.assertEqual(self.two_ratio.reciprocal().denominator, self.two)
-        self.assertEqual(self.two_ratio.reciprocal().evaluate(), self.point_five)
-
-    def test___mul__commutivity(self):
-        # Does commutivity hold?
-        self.assertEqual(self.three_halves * self.one_half, self.three_fourths)
-        self.assertEqual(self.one_half * self.three_halves, self.three_fourths)
-
-    def test___mul__(self):
-        n1 = Number(unit=units.gram, quantity=3.119)
-        n2 = Number(unit=units.liter, scale=Scale.milli)
-        bromine_density = Ratio(n1, n2)
-    
-        # How many grams of bromine are in 2 milliliters?
-        two_milliliters_bromine = Number(unit=units.liter, scale=Scale.milli, quantity=2)
-        ratio = two_milliliters_bromine.as_ratio() * bromine_density
-        answer = ratio.evaluate()
-        self.assertEqual(answer.unit.dimension, Dimension.mass)
-        self.assertEqual(answer.value, 6.238) # Grams
-
-    def test___truediv__(self):
-        seconds_per_hour = Ratio(
-            numerator=Number(unit=units.second, quantity=3600),
-            denominator=Number(unit=units.hour, quantity=1)
-        )
-
-        # How many Wh from 20 kJ?
-        twenty_kilojoules = Number(unit=units.joule, scale=Scale.kilo, quantity=20)
-        ratio = twenty_kilojoules.as_ratio() / seconds_per_hour
-        answer = ratio.evaluate()
-        self.assertEqual(answer.unit.dimension, Dimension.energy)
-        self.assertEqual(round(answer.value, 5), 5.55556)  # Watt * hours
-
-    def test___eq__(self):
-        self.assertEqual(self.one_half, self.point_five)
-        with self.assertRaises(ValueError):
-            self.one_half == 1/2
+    unit_name = 'second'
+    unit_type = 'time'
+    unit_aliases = ('seconds', 'secs', 's', 'S')
+    unit = Unit(*unit_aliases, name=unit_name, dimension=Dimension.time)
 
     def test___repr__(self):
-        self.assertEqual(str(self.one_ratio), '<1.0 >')
-        self.assertEqual(str(self.two_ratio), '<2 > / <1.0 >')
-        self.assertEqual(str(self.two_ratio.evaluate()), '<2.0 >')
-
-
-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"
-
-
-class TestScaleEdgeCases(TestCase):
+        self.assertEqual(f'<Unit {self.unit_aliases[0]}>', str(self.unit))
+
+    def test_unit_repr_has_dimension_when_no_shorthand(self):
+        u = Unit(name="", dimension=Dimension.force)
+        r = repr(u)
+        self.assertIn("force", r)
+        self.assertTrue(r.startswith("<Unit"))
+
+    def test_unit_equality_alias_normalization(self):
+        # ('',) should normalize to () under _norm
+        u1 = Unit("", name="x", dimension=Dimension.length)
+        u2 = Unit(name="x", dimension=Dimension.length)
+        self.assertEqual(u1, u2)
+
+    def test_unit_invalid_eq_type(self):
+        self.assertFalse(Unit("m", dimension=Dimension.length) == "meter")
+
+
+class TestCompositeUnit(unittest.TestCase):
+    def test_composite_unit_collapses_to_unit(self):
+        u = Unit("m", name="meter", dimension=Dimension.length)
+        cu = CompositeUnit({u: 1})
+        # should anneal to Unit
+        self.assertIsInstance(cu, Unit)
+        self.assertEqual(cu.shorthand, u.shorthand)
+
+    def test_merge_of_identical_units(self):
+        m = Unit("m", name="meter", dimension=Dimension.length)
+        # Inner composite that already has m^1
+        inner = CompositeUnit({m: 1, units.second: -1})
+        # Outer composite sees both `m:1` and `inner:1`
+        cu = CompositeUnit({m: 1, inner: 1})
+        # merge_unit should accumulate the exponents → m^(1 + 1) = m^2
+        self.assertIn(m, cu.components)
+        self.assertEqual(cu.components[m], 2)
+
+    def test_merge_of_nested_composite_units(self):
+        m = Unit("m", dimension=Dimension.length)
+        s = Unit("s", dimension=Dimension.time)
+        velocity = CompositeUnit({m: 1, s: -1})
+        accel = CompositeUnit({velocity: 1, s: -1})
+        # expect m*s^-2
+        self.assertEqual(accel.components[m], 1)
+        self.assertEqual(accel.components[s], -2)
+
+    def test_drop_dimensionless_component(self):
+        m = Unit("m", dimension=Dimension.length)
+        none = Unit("", dimension=Dimension.none)
+        cu = CompositeUnit({m: 2, none: 1})
+        self.assertIn(m, cu.components)
+        self.assertNotIn(none, cu.components)
+
+    def test_anneal_single_unit(self):
+        m = Unit("m", dimension=Dimension.length)
+        cu = CompositeUnit({m: 1})
+        self.assertIsInstance(cu, Unit)
+        self.assertEqual(cu.name, m.name)
+
+    def test_composite_mul_with_scale(self):
+        m = Unit("m", dimension=Dimension.length)
+        s = Unit("s", dimension=Dimension.time)
+        cu = CompositeUnit({m: 1, s: -1})
+        result = Scale.kilo * cu
+        # equivalent to scale multiplication on RMUL path
+        self.assertIsNotNone(result)
+        self.assertIsNotNone(result.shorthand, "km/s")
+
+    def test_composite_div_dimensionless(self):
+        m = Unit("m", dimension=Dimension.length)
+        none = Unit("", dimension=Dimension.none)
+        cu = CompositeUnit({m: 2})
+        out = cu / none
+        self.assertEqual(out.components[m], 2)
+
+    def test_truediv_composite_by_composite(self):
+        m = Unit("m", dimension=Dimension.length)
+        s = Unit("s", dimension=Dimension.time)
+        velocity = CompositeUnit({m: 1, s: -1})
+        accel = CompositeUnit({m: 1, s: -2})
+        jerk = accel / velocity
+        # jerk = m^1 s^-2  /  m^1 s^-1 = s^-1
+        self.assertEqual(list(jerk.components.values()), [-1])
+
+
+class TestUnitEdgeCases(unittest.TestCase):
+
+    # --- Initialization & representation -----------------------------------
+
+    def test_default_unit_is_dimensionless(self):
+        u = Unit()
+        self.assertEqual(u.dimension, Dimension.none)
+        self.assertEqual(u.name, '')
+        self.assertEqual(u.aliases, ())
+        self.assertEqual(u.shorthand, '')
+        self.assertEqual(repr(u), '<Unit>')
+
+    def test_unit_with_aliases_and_name(self):
+        u = Unit('m', 'M', name='meter', dimension=Dimension.length)
+        self.assertEqual(u.shorthand, 'm')
+        self.assertIn('m', u.aliases)
+        self.assertIn('M', u.aliases)
+        self.assertIn('length', u.dimension.name)
+        self.assertIn('meter', u.name)
+        self.assertIn('<Unit m>', repr(u))
+
+    def test_hash_and_equality_consistency(self):
+        u1 = Unit('m', name='meter', dimension=Dimension.length)
+        u2 = Unit('m', name='meter', dimension=Dimension.length)
+        u3 = Unit('s', name='second', dimension=Dimension.time)
+        self.assertEqual(u1, u2)
+        self.assertEqual(hash(u1), hash(u2))
+        self.assertNotEqual(u1, u3)
+        self.assertNotEqual(hash(u1), hash(u3))
+
+    def test_units_with_same_name_but_different_dimension_not_equal(self):
+        u1 = Unit(name='amp', dimension=Dimension.current)
+        u2 = Unit(name='amp', dimension=Dimension.time)
+        self.assertNotEqual(u1, u2)
+
+    # --- arithmetic behavior ----------------------------------------------
+
+    def test_multiplication_produces_composite_unit(self):
+        m = Unit('m', name='meter', dimension=Dimension.length)
+        s = Unit('s', name='second', dimension=Dimension.time)
+        v = m / s
+        self.assertIsInstance(v, Unit)
+        self.assertEqual(v.dimension, Dimension.velocity)
+        self.assertIn('/', repr(v))
+
+    def test_division_with_dimensionless_denominator_returns_self(self):
+        m = Unit('m', name='meter', dimension=Dimension.length)
+        none = Unit(name='none', dimension=Dimension.none)
+        result = m / none
+        self.assertEqual(result, m)
+
+    def test_division_of_identical_units_returns_dimensionless(self):
+        m1 = Unit('m', name='meter', dimension=Dimension.length)
+        m2 = Unit('m', name='meter', dimension=Dimension.length)
+        result = m1 / m2
+        self.assertEqual(result.dimension, Dimension.none)
+        self.assertEqual(result.name, '')
+
+    def test_multiplying_with_dimensionless_returns_self(self):
+        m = Unit('m', name='meter', dimension=Dimension.length)
+        none = Unit(name='none', dimension=Dimension.none)
+        result = m * none
+        self.assertEqual(result.dimension, Dimension.length)
+        self.assertEqual('m', result.shorthand)
+
+    def test_invalid_dimension_combinations_raise_value_error(self):
+        m = Unit('m', name='meter', dimension=Dimension.length)
+        c = Unit('C', name='coulomb', dimension=Dimension.charge)
+        # The result of combination gives CompositeUnit
+        self.assertIsInstance(m / c, CompositeUnit)
+        self.assertIsInstance(m * c, CompositeUnit)
+
+    # --- equality, hashing, immutability ----------------------------------
+
+    def test_equality_with_non_unit(self):
+        self.assertFalse(Unit('m', name='meter', dimension=Dimension.length) == 'meter')
+
+    def test_hash_stability_in_collections(self):
+        m1 = Unit('m', name='meter', dimension=Dimension.length)
+        s = set([m1])
+        self.assertIn(Unit('m', name='meter', dimension=Dimension.length), s)
+
+    def test_operations_do_not_mutate_operands(self):
+        m = Unit('m', name='meter', dimension=Dimension.length)
+        s = Unit('s', name='second', dimension=Dimension.time)
+        _ = m / s
+        self.assertEqual(m.dimension, Dimension.length)
+        self.assertEqual(s.dimension, Dimension.time)
+
+    # --- operator edge cases ----------------------------------------------
+
+    def test_repr_contains_dimension_name_even_without_name(self):
+        u = Unit(dimension=Dimension.force)
+        self.assertIn('force', repr(u))
+
+
+class TestScaleEdgeCases(unittest.TestCase):
 
     def test_nearest_prefers_decimal_by_default(self):
         self.assertEqual(Scale.nearest(1024), Scale.kilo)
@@ -429,7 +637,6 @@ class TestScaleEdgeCases(TestCase):
         self.assertEqual(Scale.nearest(1/1024), Scale.milli)
 
     def test_nearest_includes_binary_when_opted_in(self):
-        self.assertEqual(Scale.nearest(1/1024, include_binary=True), Scale._kibi)
         self.assertEqual(Scale.nearest(1024, include_binary=True), Scale.kibi)
         self.assertEqual(Scale.nearest(50_000, include_binary=True), Scale.kibi)
         self.assertEqual(Scale.nearest(2**20, include_binary=True), Scale.mebi)
@@ -465,119 +672,3 @@ class TestScaleEdgeCases(TestCase):
         all_map = Scale.all()
         by_val = Scale.by_value()
         self.assertTrue(all((val in by_val.values()) for _, val in all_map.items()))
-
-
-class TestNumberEdgeCases(TestCase):
-
-    def test_default_number_is_dimensionless_one(self):
-        n = Number()
-        self.assertEqual(n.unit, units.none)
-        self.assertEqual(n.scale, Scale.one)
-        self.assertEqual(n.quantity, 1)
-        self.assertAlmostEqual(n.value, 1.0)
-        self.assertIn("1", repr(n))
-
-    def test_to_new_scale_changes_value(self):
-        n = Number(quantity=1000, scale=Scale.kilo)
-        converted = n.to(Scale.one)
-        self.assertNotEqual(n.value, converted.value)
-        self.assertAlmostEqual(converted.value, 1000)
-
-    def test_simplify_uses_value_as_quantity(self):
-        n = Number(quantity=2, scale=Scale.kilo)
-        simplified = n.simplify()
-        self.assertEqual(simplified.quantity, n.value)
-        self.assertEqual(simplified.unit, n.unit)
-
-    def test_multiplication_combines_units_and_quantities(self):
-        n1 = Number(unit=units.joule, quantity=2)
-        n2 = Number(unit=units.second, quantity=3)
-        result = n1 * n2
-        self.assertEqual(result.quantity, 6)
-        self.assertEqual(result.unit.dimension, Dimension.energy * Dimension.time)
-
-    def test_division_combines_units_scales_and_quantities(self):
-        n1 = Number(unit=units.meter, scale=Scale.kilo, quantity=1000)
-        n2 = Number(unit=units.second, scale=Scale.one, quantity=2)
-        result = n1 / n2
-        self.assertEqual(result.scale, Scale.kilo / Scale.one)
-        self.assertEqual(result.unit.dimension, Dimension.velocity)
-        self.assertAlmostEqual(result.quantity, 500)
-
-    def test_equality_with_non_number_raises_value_error(self):
-        n = Number()
-        with self.assertRaises(TypeError):
-            n == '5'
-
-    def test_equality_between_numbers_and_ratios(self):
-        n1 = Number(quantity=10)
-        n2 = Number(quantity=10)
-        r = Ratio(n1, n2)
-        self.assertTrue(r == Number())
-
-    def test_repr_includes_scale_and_unit(self):
-        n = Number(unit=units.volt, scale=Scale.kilo, quantity=5)
-        rep = repr(n)
-        self.assertIn("kilo", rep)
-        self.assertIn("volt", rep)
-
-
-class TestRatioEdgeCases(TestCase):
-
-    def test_default_ratio_is_dimensionless_one(self):
-        r = Ratio()
-        self.assertEqual(r.numerator.unit, units.none)
-        self.assertEqual(r.denominator.unit, units.none)
-        self.assertAlmostEqual(r.evaluate().value, 1.0)
-
-    def test_reciprocal_swaps_numerator_and_denominator(self):
-        n1 = Number(quantity=10)
-        n2 = Number(quantity=2)
-        r = Ratio(n1, n2)
-        reciprocal = r.reciprocal()
-        self.assertEqual(reciprocal.numerator, r.denominator)
-        self.assertEqual(reciprocal.denominator, r.numerator)
-
-    def test_evaluate_returns_number_division_result(self):
-        r = Ratio(Number(unit=units.meter), Number(unit=units.second))
-        result = r.evaluate()
-        self.assertIsInstance(result, Number)
-        self.assertEqual(result.unit.dimension, Dimension.velocity)
-
-    def test_multiplication_between_compatible_ratios(self):
-        r1 = Ratio(Number(unit=units.meter), Number(unit=units.second))
-        r2 = Ratio(Number(unit=units.second), Number(unit=units.meter))
-        product = r1 * r2
-        self.assertIsInstance(product, Ratio)
-        self.assertEqual(product.evaluate().unit.dimension, Dimension.none)
-
-    def test_multiplication_with_incompatible_units_fallback(self):
-        r1 = Ratio(Number(unit=units.meter), Number(unit=units.ampere))
-        r2 = Ratio(Number(unit=units.ampere), Number(unit=units.meter))
-        result = r1 * r2
-        self.assertIsInstance(result, Ratio)
-
-    def test_division_between_ratios_yields_new_ratio(self):
-        r1 = Ratio(Number(quantity=2), Number(quantity=1))
-        r2 = Ratio(Number(quantity=4), Number(quantity=2))
-        result = r1 / r2
-        self.assertIsInstance(result, Ratio)
-        self.assertAlmostEqual(result.evaluate().value, 1.0)
-
-    def test_equality_with_non_ratio_raises_value_error(self):
-        r = Ratio()
-        with self.assertRaises(ValueError):
-            _ = (r == "not_a_ratio")
-
-    def test_repr_handles_equal_numerator_denominator(self):
-        r = Ratio()
-        self.assertEqual(str(r.evaluate().value), "1.0")
-        rep = repr(r)
-        self.assertTrue(rep.startswith("<1"))
-
-    def test_repr_of_non_equal_ratio_includes_slash(self):
-        n1 = Number(quantity=2)
-        n2 = Number(quantity=1)
-        r = Ratio(n1, n2)
-        rep = repr(r)
-        self.assertIn("/", rep)