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

tests/ucon/test_unit_system.py

@@ -0,0 +1,174 @@
+# © 2026 The Radiativity Company
+# Licensed under the Apache License, Version 2.0
+# See the LICENSE file for details.
+
+"""
+Tests for UnitSystem.
+
+Verifies construction, validation, and query methods for named
+unit system definitions.
+"""
+
+import unittest
+
+from ucon import units
+from ucon.core import Dimension, Unit, UnitSystem, DimensionNotCovered
+
+
+class TestUnitSystemConstruction(unittest.TestCase):
+    """Test UnitSystem construction and validation."""
+
+    def test_valid_construction(self):
+        system = UnitSystem(
+            name="SI",
+            bases={
+                Dimension.length: units.meter,
+                Dimension.mass: units.kilogram,
+                Dimension.time: units.second,
+            }
+        )
+        self.assertEqual(system.name, "SI")
+        self.assertEqual(len(system.bases), 3)
+
+    def test_single_base_allowed(self):
+        system = UnitSystem(
+            name="length-only",
+            bases={Dimension.length: units.meter}
+        )
+        self.assertEqual(len(system.bases), 1)
+
+    def test_empty_name_rejected(self):
+        with self.assertRaises(ValueError) as ctx:
+            UnitSystem(name="", bases={Dimension.length: units.meter})
+        self.assertIn("name", str(ctx.exception).lower())
+
+    def test_empty_bases_rejected(self):
+        with self.assertRaises(ValueError) as ctx:
+            UnitSystem(name="empty", bases={})
+        self.assertIn("base", str(ctx.exception).lower())
+
+    def test_mismatched_dimension_rejected(self):
+        # meter has Dimension.length, but we declare it as mass
+        with self.assertRaises(ValueError) as ctx:
+            UnitSystem(
+                name="bad",
+                bases={Dimension.mass: units.meter}
+            )
+        self.assertIn("dimension", str(ctx.exception).lower())
+
+    def test_partial_system_allowed(self):
+        # Imperial doesn't need mole or candela
+        system = UnitSystem(
+            name="Imperial",
+            bases={
+                Dimension.length: units.foot,
+                Dimension.mass: units.pound,
+                Dimension.time: units.second,
+            }
+        )
+        self.assertEqual(len(system.bases), 3)
+
+
+class TestUnitSystemQueries(unittest.TestCase):
+    """Test UnitSystem query methods."""
+
+    def setUp(self):
+        self.si = UnitSystem(
+            name="SI",
+            bases={
+                Dimension.length: units.meter,
+                Dimension.mass: units.kilogram,
+                Dimension.time: units.second,
+                Dimension.temperature: units.kelvin,
+            }
+        )
+
+    def test_covers_returns_true_for_covered(self):
+        self.assertTrue(self.si.covers(Dimension.length))
+        self.assertTrue(self.si.covers(Dimension.mass))
+        self.assertTrue(self.si.covers(Dimension.time))
+
+    def test_covers_returns_false_for_uncovered(self):
+        self.assertFalse(self.si.covers(Dimension.current))
+        self.assertFalse(self.si.covers(Dimension.luminous_intensity))
+
+    def test_base_for_returns_correct_unit(self):
+        self.assertEqual(self.si.base_for(Dimension.length), units.meter)
+        self.assertEqual(self.si.base_for(Dimension.mass), units.kilogram)
+        self.assertEqual(self.si.base_for(Dimension.time), units.second)
+
+    def test_base_for_raises_for_uncovered(self):
+        with self.assertRaises(DimensionNotCovered) as ctx:
+            self.si.base_for(Dimension.current)
+        self.assertIn("current", str(ctx.exception).lower())
+
+    def test_dimensions_property(self):
+        dims = self.si.dimensions
+        self.assertIsInstance(dims, set)
+        self.assertEqual(len(dims), 4)
+        self.assertIn(Dimension.length, dims)
+        self.assertIn(Dimension.mass, dims)
+
+
+class TestUnitSystemEquality(unittest.TestCase):
+    """Test UnitSystem equality and hashing."""
+
+    def test_same_systems_equal(self):
+        s1 = UnitSystem(
+            name="SI",
+            bases={Dimension.length: units.meter}
+        )
+        s2 = UnitSystem(
+            name="SI",
+            bases={Dimension.length: units.meter}
+        )
+        self.assertEqual(s1, s2)
+
+    def test_different_names_not_equal(self):
+        s1 = UnitSystem(name="SI", bases={Dimension.length: units.meter})
+        s2 = UnitSystem(name="CGS", bases={Dimension.length: units.meter})
+        self.assertNotEqual(s1, s2)
+
+    def test_different_bases_not_equal(self):
+        s1 = UnitSystem(name="test", bases={Dimension.length: units.meter})
+        s2 = UnitSystem(name="test", bases={Dimension.length: units.foot})
+        self.assertNotEqual(s1, s2)
+
+    def test_hashable(self):
+        s1 = UnitSystem(name="SI", bases={Dimension.length: units.meter})
+        s2 = UnitSystem(name="SI", bases={Dimension.length: units.meter})
+        self.assertEqual(hash(s1), hash(s2))
+        self.assertEqual(len({s1, s2}), 1)
+
+
+class TestUnitSystemImmutability(unittest.TestCase):
+    """Test that UnitSystem is immutable."""
+
+    def test_frozen_dataclass(self):
+        system = UnitSystem(
+            name="SI",
+            bases={Dimension.length: units.meter}
+        )
+        with self.assertRaises(AttributeError):
+            system.name = "changed"
+
+
+class TestPredefinedSystems(unittest.TestCase):
+    """Test predefined unit systems in ucon.units."""
+
+    def test_si_system_exists(self):
+        from ucon.units import si
+        self.assertEqual(si.name, "SI")
+        self.assertTrue(si.covers(Dimension.length))
+        self.assertTrue(si.covers(Dimension.mass))
+        self.assertTrue(si.covers(Dimension.time))
+
+    def test_imperial_system_exists(self):
+        from ucon.units import imperial
+        self.assertEqual(imperial.name, "Imperial")
+        self.assertTrue(imperial.covers(Dimension.length))
+        self.assertTrue(imperial.covers(Dimension.mass))
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/ucon/test_vector_fraction.py

@@ -0,0 +1,185 @@
+# © 2026 The Radiativity Company
+# Licensed under the Apache License, Version 2.0
+# See the LICENSE file for details.
+
+"""
+Tests for Vector with Fraction exponents.
+
+Verifies backward compatibility with integer exponents and
+correct behavior with fractional exponents for BasisTransform support.
+"""
+
+import unittest
+from fractions import Fraction
+
+from ucon.algebra import Vector
+
+
+class TestVectorIntegerBackwardCompatibility(unittest.TestCase):
+    """Verify existing integer-based code works unchanged."""
+
+    def test_integer_construction(self):
+        v = Vector(1, 0, -2, 0, 0, 0, 0, 0)
+        self.assertEqual(tuple(v), (1, 0, -2, 0, 0, 0, 0, 0))
+
+    def test_integer_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_integer_subtraction(self):
+        v1 = Vector(2, 1, 0, 0, 0, 0, 0, 0)
+        v2 = Vector(1, 1, 0, 0, 0, 0, 0, 0)
+        result = v1 - v2
+        self.assertEqual(result, Vector(1, 0, 0, 0, 0, 0, 0, 0))
+
+    def test_integer_scalar_multiplication(self):
+        v = Vector(1, -2, 0, 0, 0, 0, 3, 0)
+        result = v * 2
+        self.assertEqual(result, Vector(2, -4, 0, 0, 0, 0, 6, 0))
+
+    def test_integer_equality(self):
+        v1 = Vector(1, 0, 0, 0, 0, 0, 0, 0)
+        v2 = Vector(1, 0, 0, 0, 0, 0, 0, 0)
+        self.assertEqual(v1, v2)
+
+    def test_integer_hash_consistency(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)
+
+
+class TestVectorFractionConstruction(unittest.TestCase):
+    """Test Vector construction with Fraction values."""
+
+    def test_fraction_construction(self):
+        v = Vector(Fraction(3, 2), Fraction(1, 2), Fraction(-1), 0, 0, 0, 0, 0)
+        self.assertEqual(v.T, Fraction(3, 2))
+        self.assertEqual(v.L, Fraction(1, 2))
+        self.assertEqual(v.M, Fraction(-1))
+
+    def test_mixed_int_fraction_construction(self):
+        v = Vector(1, Fraction(1, 2), 0, 0, 0, 0, 0, 0)
+        self.assertEqual(v.T, Fraction(1))
+        self.assertEqual(v.L, Fraction(1, 2))
+
+    def test_float_converted_to_fraction(self):
+        v = Vector(0.5, 0, 0, 0, 0, 0, 0, 0)
+        self.assertEqual(v.T, Fraction(1, 2))
+
+    def test_default_values_are_fraction_zero(self):
+        v = Vector()
+        self.assertEqual(v.T, Fraction(0))
+        self.assertEqual(v.L, Fraction(0))
+
+
+class TestVectorFractionEquality(unittest.TestCase):
+    """Test equality across int and Fraction representations."""
+
+    def test_int_equals_fraction(self):
+        v1 = Vector(1, 0, 0, 0, 0, 0, 0, 0)
+        v2 = Vector(Fraction(1), Fraction(0), Fraction(0), Fraction(0),
+                    Fraction(0), Fraction(0), Fraction(0), Fraction(0))
+        self.assertEqual(v1, v2)
+
+    def test_int_fraction_hash_equality(self):
+        v1 = Vector(1, 0, -2, 0, 0, 0, 0, 0)
+        v2 = Vector(Fraction(1), Fraction(0), Fraction(-2), Fraction(0),
+                    Fraction(0), Fraction(0), Fraction(0), Fraction(0))
+        self.assertEqual(hash(v1), hash(v2))
+
+    def test_int_fraction_in_set(self):
+        v1 = Vector(1, 0, 0, 0, 0, 0, 0, 0)
+        v2 = Vector(Fraction(1), 0, 0, 0, 0, 0, 0, 0)
+        s = {v1, v2}
+        self.assertEqual(len(s), 1)
+
+
+class TestVectorFractionArithmetic(unittest.TestCase):
+    """Test arithmetic with Fraction exponents."""
+
+    def test_fraction_addition(self):
+        v1 = Vector(Fraction(1, 2), 0, 0, 0, 0, 0, 0, 0)
+        v2 = Vector(Fraction(1, 2), 0, 0, 0, 0, 0, 0, 0)
+        result = v1 + v2
+        self.assertEqual(result.T, Fraction(1))
+
+    def test_fraction_subtraction(self):
+        v1 = Vector(Fraction(3, 2), 0, 0, 0, 0, 0, 0, 0)
+        v2 = Vector(Fraction(1, 2), 0, 0, 0, 0, 0, 0, 0)
+        result = v1 - v2
+        self.assertEqual(result.T, Fraction(1))
+
+    def test_fraction_scalar_multiply(self):
+        v = Vector(Fraction(1, 2), 0, 0, 0, 0, 0, 0, 0)
+        result = v * 2
+        self.assertEqual(result.T, Fraction(1))
+
+    def test_fraction_scalar_multiply_by_fraction(self):
+        v = Vector(1, 0, 0, 0, 0, 0, 0, 0)
+        result = v * Fraction(1, 2)
+        self.assertEqual(result.T, Fraction(1, 2))
+
+    def test_no_floating_point_drift(self):
+        # 1/3 * 3 should equal exactly 1, not 0.9999...
+        v = Vector(Fraction(1, 3), 0, 0, 0, 0, 0, 0, 0)
+        result = v * 3
+        self.assertEqual(result.T, Fraction(1))
+        self.assertEqual(result, Vector(1, 0, 0, 0, 0, 0, 0, 0))
+
+    def test_complex_fraction_arithmetic(self):
+        # CGS-ESU charge dimension: M^(1/2) · L^(3/2) · T^(-1)
+        esu_charge = Vector(
+            T=-1,
+            L=Fraction(3, 2),
+            M=Fraction(1, 2),
+        )
+        # Multiply by 2 (squaring the unit)
+        squared = esu_charge * 2
+        self.assertEqual(squared.T, Fraction(-2))
+        self.assertEqual(squared.L, Fraction(3))
+        self.assertEqual(squared.M, Fraction(1))
+
+
+class TestVectorIterationWithFraction(unittest.TestCase):
+    """Test iteration and length with Fraction values."""
+
+    def test_iteration_returns_fractions(self):
+        v = Vector(Fraction(1, 2), 1, 0, 0, 0, 0, 0, 0)
+        components = list(v)
+        self.assertEqual(components[0], Fraction(1, 2))
+        self.assertEqual(components[1], Fraction(1))
+
+    def test_length_unchanged(self):
+        v = Vector(Fraction(1, 2), 0, 0, 0, 0, 0, 0, 0)
+        self.assertEqual(len(v), 8)
+
+
+class TestVectorNegation(unittest.TestCase):
+    """Test vector negation with Fraction values."""
+
+    def test_negation_with_fractions(self):
+        v = Vector(Fraction(1, 2), Fraction(-3, 4), 0, 0, 0, 0, 0, 0)
+        neg = -v
+        self.assertEqual(neg.T, Fraction(-1, 2))
+        self.assertEqual(neg.L, Fraction(3, 4))
+
+
+class TestVectorRightMultiply(unittest.TestCase):
+    """Test right multiplication (scalar * vector)."""
+
+    def test_rmul_integer(self):
+        v = Vector(Fraction(1, 2), 0, 0, 0, 0, 0, 0, 0)
+        result = 2 * v
+        self.assertEqual(result.T, Fraction(1))
+
+    def test_rmul_fraction(self):
+        v = Vector(1, 0, 0, 0, 0, 0, 0, 0)
+        result = Fraction(1, 2) * v
+        self.assertEqual(result.T, Fraction(1, 2))
+
+
+if __name__ == "__main__":
+    unittest.main()

ucon/__init__.py

@@ -38,19 +38,37 @@ Design Philosophy
 """
 from ucon import units
 from ucon.algebra import Exponent
-from ucon.core import Dimension, Scale, Unit, UnitFactor, UnitProduct, Number, Ratio
+from ucon.core import (
+    BasisTransform,
+    Dimension,
+    DimensionNotCovered,
+    NonInvertibleTransform,
+    RebasedUnit,
+    Scale,
+    Unit,
+    UnitFactor,
+    UnitProduct,
+    UnitSystem,
+    Number,
+    Ratio,
+)
 from ucon.graph import get_default_graph, using_graph
 
 
 __all__ = [
-    'Exponent',
+    'BasisTransform',
     'Dimension',
+    'DimensionNotCovered',
+    'Exponent',
+    'NonInvertibleTransform',
     'Number',
     'Ratio',
+    'RebasedUnit',
     'Scale',
     'Unit',
     'UnitFactor',
     'UnitProduct',
+    'UnitSystem',
     'get_default_graph',
     'using_graph',
     'units',

ucon/algebra.py

@@ -20,13 +20,14 @@ Classes
 - :class:`Exponent` — Base/power pair supporting prefix arithmetic.
 """
 import math
-from dataclasses import dataclass
+from dataclasses import dataclass, fields
+from fractions import Fraction
 from functools import partial, reduce, total_ordering
 from operator import __sub__ as subtraction
 from typing import Callable, Iterable, Iterator, Tuple, Union
 
 
-diff: Callable[[Iterable], int] = partial(reduce, subtraction)
+diff: Callable[[Iterable], Fraction] = partial(reduce, subtraction)
 
 
 @dataclass
@@ -43,22 +44,34 @@ class Vector:
     - Addition (`+`) → multiplication of quantities
     - Subtraction (`-`) → division of quantities
 
+    Components are stored as `Fraction` for exact arithmetic, enabling
+    fractional exponents (e.g., CGS-ESU charge: M^(1/2) · L^(3/2) · T^(-1)).
+    Integer and float inputs are automatically converted to Fraction.
+
     e.g.
     Vector(T=1, L=0, M=0, I=0, Θ=0, J=0, N=0, B=0)   => "time"
     Vector(T=0, L=2, M=0, I=0, Θ=0, J=0, N=0, B=0)   => "area"
     Vector(T=-2, L=1, M=1, I=0, Θ=0, J=0, N=0, B=0)  => "force"
     Vector(T=0, L=0, M=0, I=0, Θ=0, J=0, N=0, B=1)   => "information"
+    Vector(L=Fraction(3,2), M=Fraction(1,2), T=-1)   => "esu_charge"
     """
-    T: int = 0  # time
-    L: int = 0  # length
-    M: int = 0  # mass
-    I: int = 0  # current
-    Θ: int = 0  # temperature
-    J: int = 0  # luminous intensity
-    N: int = 0  # amount of substance
-    B: int = 0  # information (bits)
-
-    def __iter__(self) -> Iterator[int]:
+    T: Union[int, float, Fraction] = 0  # time
+    L: Union[int, float, Fraction] = 0  # length
+    M: Union[int, float, Fraction] = 0  # mass
+    I: Union[int, float, Fraction] = 0  # current
+    Θ: Union[int, float, Fraction] = 0  # temperature
+    J: Union[int, float, Fraction] = 0  # luminous intensity
+    N: Union[int, float, Fraction] = 0  # amount of substance
+    B: Union[int, float, Fraction] = 0  # information (bits)
+
+    def __post_init__(self):
+        """Convert all components to Fraction for exact arithmetic."""
+        for field in fields(self):
+            val = getattr(self, field.name)
+            if not isinstance(val, Fraction):
+                object.__setattr__(self, field.name, Fraction(val))
+
+    def __iter__(self) -> Iterator[Fraction]:
         yield self.T
         yield self.L
         yield self.M
@@ -90,7 +103,7 @@ class Vector:
         values = tuple(diff(pair) for pair in zip(tuple(self), tuple(vector)))
         return Vector(*values)
 
-    def __mul__(self, scalar: Union[int, float]) -> 'Vector':
+    def __mul__(self, scalar: Union[int, float, Fraction]) -> 'Vector':
         """
         Scalar multiplication of the exponent vector.
 
@@ -99,9 +112,18 @@ class Vector:
             >>> Dimension.length ** 2   # area
             >>> Dimension.time ** -1    # frequency
         """
-        values = tuple(component * scalar for component in tuple(self))
+        n = Fraction(scalar) if not isinstance(scalar, Fraction) else scalar
+        values = tuple(component * n for component in tuple(self))
         return Vector(*values)
 
+    def __rmul__(self, scalar: Union[int, float, Fraction]) -> 'Vector':
+        """Right multiplication: scalar * vector."""
+        return self.__mul__(scalar)
+
+    def __neg__(self) -> 'Vector':
+        """Negate the vector: -v."""
+        return Vector(*(-component for component in tuple(self)))
+
     def __eq__(self, other) -> bool:
         if not isinstance(other, Vector):
             return NotImplemented