ucon 0.4.2__py3-none-any.whl → 0.5.1__py3-none-any.whl

tests/ucon/test_algebra.py

@@ -71,10 +71,10 @@ class TestVectorEdgeCases(TestCase):
 
     def test_vector_equality_with_non_vector(self):
         v = Vector()
-        with self.assertRaises(AssertionError):
-            v == "not a vector"
-        with self.assertRaises(AssertionError):
-            v == None
+        # 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)

tests/ucon/test_dimensionless_units.py

@@ -0,0 +1,248 @@
+# © 2026 The Radiativity Company
+# Licensed under the Apache License, Version 2.0
+# See the LICENSE file for details.
+
+"""
+Tests for v0.5.0 dimensionless units (pseudo-dimensions).
+
+Tests pseudo-dimension isolation, angle/solid-angle/ratio unit conversions,
+and cross-pseudo-dimension conversion failure.
+"""
+
+import math
+import unittest
+
+from ucon import units
+from ucon.core import Dimension, Vector
+from ucon.graph import ConversionNotFound
+
+
+class TestPseudoDimensionIsolation(unittest.TestCase):
+    """Test that pseudo-dimensions are semantically isolated."""
+
+    def test_angle_not_equal_to_none(self):
+        self.assertNotEqual(Dimension.angle, Dimension.none)
+
+    def test_solid_angle_not_equal_to_none(self):
+        self.assertNotEqual(Dimension.solid_angle, Dimension.none)
+
+    def test_ratio_not_equal_to_none(self):
+        self.assertNotEqual(Dimension.ratio, Dimension.none)
+
+    def test_angle_not_equal_to_solid_angle(self):
+        self.assertNotEqual(Dimension.angle, Dimension.solid_angle)
+
+    def test_angle_not_equal_to_ratio(self):
+        self.assertNotEqual(Dimension.angle, Dimension.ratio)
+
+    def test_solid_angle_not_equal_to_ratio(self):
+        self.assertNotEqual(Dimension.solid_angle, Dimension.ratio)
+
+    def test_angle_equal_to_itself(self):
+        self.assertEqual(Dimension.angle, Dimension.angle)
+
+    def test_none_equal_to_itself(self):
+        self.assertEqual(Dimension.none, Dimension.none)
+
+    def test_all_pseudo_dimensions_have_zero_vector(self):
+        zero = Vector()
+        self.assertEqual(Dimension.none.vector, zero)
+        self.assertEqual(Dimension.angle.vector, zero)
+        self.assertEqual(Dimension.solid_angle.vector, zero)
+        self.assertEqual(Dimension.ratio.vector, zero)
+
+
+class TestPseudoDimensionHashing(unittest.TestCase):
+    """Test that pseudo-dimensions can coexist in sets and dicts."""
+
+    def test_all_pseudo_dimensions_in_set(self):
+        dims = {Dimension.none, Dimension.angle, Dimension.solid_angle, Dimension.ratio}
+        self.assertEqual(len(dims), 4)
+
+    def test_all_pseudo_dimensions_as_dict_keys(self):
+        d = {
+            Dimension.none: "none",
+            Dimension.angle: "angle",
+            Dimension.solid_angle: "solid_angle",
+            Dimension.ratio: "ratio",
+        }
+        self.assertEqual(len(d), 4)
+        self.assertEqual(d[Dimension.angle], "angle")
+        self.assertEqual(d[Dimension.ratio], "ratio")
+
+    def test_distinct_hashes(self):
+        hashes = {
+            hash(Dimension.none),
+            hash(Dimension.angle),
+            hash(Dimension.solid_angle),
+            hash(Dimension.ratio),
+        }
+        self.assertEqual(len(hashes), 4)
+
+
+class TestAlgebraicResolution(unittest.TestCase):
+    """Test that algebraic operations resolve to none, not pseudo-dimensions."""
+
+    def test_length_divided_by_length_is_none(self):
+        result = Dimension.length / Dimension.length
+        self.assertEqual(result, Dimension.none)
+        self.assertIs(result, Dimension.none)
+
+    def test_energy_divided_by_energy_is_none(self):
+        result = Dimension.energy / Dimension.energy
+        self.assertEqual(result, Dimension.none)
+        self.assertIs(result, Dimension.none)
+
+    def test_angle_times_length_is_length(self):
+        # Since angle has zero vector, angle * length = length
+        result = Dimension.angle * Dimension.length
+        self.assertEqual(result, Dimension.length)
+
+
+class TestUnitDimensions(unittest.TestCase):
+    """Test that units have correct dimensions."""
+
+    def test_radian_is_angle(self):
+        self.assertEqual(units.radian.dimension, Dimension.angle)
+
+    def test_degree_is_angle(self):
+        self.assertEqual(units.degree.dimension, Dimension.angle)
+
+    def test_steradian_is_solid_angle(self):
+        self.assertEqual(units.steradian.dimension, Dimension.solid_angle)
+
+    def test_square_degree_is_solid_angle(self):
+        self.assertEqual(units.square_degree.dimension, Dimension.solid_angle)
+
+    def test_percent_is_ratio(self):
+        self.assertEqual(units.percent.dimension, Dimension.ratio)
+
+    def test_ppm_is_ratio(self):
+        self.assertEqual(units.ppm.dimension, Dimension.ratio)
+
+
+class TestAngleConversions(unittest.TestCase):
+    """Test angle unit conversions."""
+
+    def test_radian_to_degree(self):
+        angle = units.radian(math.pi)
+        result = angle.to(units.degree)
+        self.assertAlmostEqual(result.value, 180, places=9)
+
+    def test_degree_to_radian(self):
+        angle = units.degree(90)
+        result = angle.to(units.radian)
+        self.assertAlmostEqual(result.value, math.pi / 2, places=9)
+
+    def test_turn_to_degree(self):
+        angle = units.turn(1)
+        result = angle.to(units.degree)
+        self.assertAlmostEqual(result.value, 360, places=9)
+
+    def test_turn_to_radian(self):
+        angle = units.turn(1)
+        result = angle.to(units.radian)
+        self.assertAlmostEqual(result.value, 2 * math.pi, places=9)
+
+    def test_turn_to_gradian(self):
+        angle = units.turn(1)
+        result = angle.to(units.gradian)
+        self.assertAlmostEqual(result.value, 400, places=9)
+
+    def test_degree_to_arcminute(self):
+        angle = units.degree(1)
+        result = angle.to(units.arcminute)
+        self.assertAlmostEqual(result.value, 60, places=9)
+
+    def test_arcminute_to_arcsecond(self):
+        angle = units.arcminute(1)
+        result = angle.to(units.arcsecond)
+        self.assertAlmostEqual(result.value, 60, places=9)
+
+    def test_degree_to_arcsecond_composed(self):
+        angle = units.degree(1)
+        result = angle.to(units.arcsecond)
+        self.assertAlmostEqual(result.value, 3600, places=9)
+
+
+class TestSolidAngleConversions(unittest.TestCase):
+    """Test solid angle unit conversions."""
+
+    def test_steradian_to_square_degree(self):
+        solid = units.steradian(1)
+        result = solid.to(units.square_degree)
+        expected = (180 / math.pi) ** 2
+        self.assertAlmostEqual(result.value, expected, places=1)
+
+    def test_square_degree_to_steradian(self):
+        solid = units.square_degree(1)
+        result = solid.to(units.steradian)
+        expected = (math.pi / 180) ** 2
+        self.assertAlmostEqual(result.value, expected, places=9)
+
+
+class TestRatioConversions(unittest.TestCase):
+    """Test ratio unit conversions."""
+
+    def test_one_to_percent(self):
+        r = units.ratio_one(0.5)
+        result = r.to(units.percent)
+        self.assertAlmostEqual(result.value, 50, places=9)
+
+    def test_percent_to_one(self):
+        r = units.percent(25)
+        result = r.to(units.ratio_one)
+        self.assertAlmostEqual(result.value, 0.25, places=9)
+
+    def test_one_to_ppm(self):
+        r = units.ratio_one(0.001)
+        result = r.to(units.ppm)
+        self.assertAlmostEqual(result.value, 1000, places=9)
+
+    def test_ppm_to_ppb(self):
+        r = units.ppm(1)
+        result = r.to(units.ppb)
+        self.assertAlmostEqual(result.value, 1000, places=9)
+
+    def test_one_to_permille(self):
+        r = units.ratio_one(0.005)
+        result = r.to(units.permille)
+        self.assertAlmostEqual(result.value, 5, places=9)
+
+    def test_basis_point_to_percent(self):
+        r = units.basis_point(100)
+        result = r.to(units.percent)
+        self.assertAlmostEqual(result.value, 1, places=9)
+
+    def test_percent_to_basis_point(self):
+        r = units.percent(0.25)
+        result = r.to(units.basis_point)
+        self.assertAlmostEqual(result.value, 25, places=9)
+
+
+class TestCrossPseudoDimensionFails(unittest.TestCase):
+    """Test that cross-pseudo-dimension conversions fail."""
+
+    def test_radian_to_percent_fails(self):
+        with self.assertRaises(ConversionNotFound):
+            units.radian(1).to(units.percent)
+
+    def test_percent_to_degree_fails(self):
+        with self.assertRaises(ConversionNotFound):
+            units.percent(50).to(units.degree)
+
+    def test_radian_to_steradian_fails(self):
+        with self.assertRaises(ConversionNotFound):
+            units.radian(1).to(units.steradian)
+
+    def test_steradian_to_percent_fails(self):
+        with self.assertRaises(ConversionNotFound):
+            units.steradian(1).to(units.percent)
+
+    def test_ppm_to_arcminute_fails(self):
+        with self.assertRaises(ConversionNotFound):
+            units.ppm(1000).to(units.arcminute)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/ucon/test_uncertainty.py

@@ -0,0 +1,264 @@
+# © 2026 The Radiativity Company
+# Licensed under the Apache License, Version 2.0
+# See the LICENSE file for details.
+
+"""
+Tests for v0.5.x uncertainty propagation.
+
+Tests Number construction with uncertainty, display formatting,
+arithmetic propagation, and conversion propagation.
+"""
+
+import math
+import unittest
+
+from ucon import units, Scale
+from ucon.core import Number, UnitProduct
+
+
+class TestUncertaintyConstruction(unittest.TestCase):
+    """Test constructing Numbers with uncertainty."""
+
+    def test_number_with_uncertainty(self):
+        n = units.meter(1.234, uncertainty=0.005)
+        self.assertEqual(n.value, 1.234)
+        self.assertEqual(n.uncertainty, 0.005)
+
+    def test_number_without_uncertainty(self):
+        n = units.meter(1.234)
+        self.assertEqual(n.value, 1.234)
+        self.assertIsNone(n.uncertainty)
+
+    def test_unit_product_callable_with_uncertainty(self):
+        km = Scale.kilo * units.meter
+        n = km(5.0, uncertainty=0.1)
+        self.assertEqual(n.value, 5.0)
+        self.assertEqual(n.uncertainty, 0.1)
+
+    def test_composite_unit_with_uncertainty(self):
+        mps = units.meter / units.second
+        n = mps(10.0, uncertainty=0.5)
+        self.assertEqual(n.value, 10.0)
+        self.assertEqual(n.uncertainty, 0.5)
+
+
+class TestUncertaintyDisplay(unittest.TestCase):
+    """Test display formatting with uncertainty."""
+
+    def test_repr_with_uncertainty(self):
+        n = units.meter(1.234, uncertainty=0.005)
+        r = repr(n)
+        self.assertIn("1.234", r)
+        self.assertIn("±", r)
+        self.assertIn("0.005", r)
+        self.assertIn("m", r)
+
+    def test_repr_without_uncertainty(self):
+        n = units.meter(1.234)
+        r = repr(n)
+        self.assertIn("1.234", r)
+        self.assertNotIn("±", r)
+
+    def test_repr_dimensionless_with_uncertainty(self):
+        n = Number(quantity=0.5, uncertainty=0.01)
+        r = repr(n)
+        self.assertIn("0.5", r)
+        self.assertIn("±", r)
+        self.assertIn("0.01", r)
+
+
+class TestAdditionSubtractionPropagation(unittest.TestCase):
+    """Test uncertainty propagation through addition and subtraction."""
+
+    def test_addition_both_uncertain(self):
+        a = units.meter(10.0, uncertainty=0.3)
+        b = units.meter(5.0, uncertainty=0.4)
+        c = a + b
+        self.assertAlmostEqual(c.value, 15.0, places=9)
+        # sqrt(0.3² + 0.4²) = sqrt(0.09 + 0.16) = sqrt(0.25) = 0.5
+        self.assertAlmostEqual(c.uncertainty, 0.5, places=9)
+
+    def test_subtraction_both_uncertain(self):
+        a = units.meter(10.0, uncertainty=0.3)
+        b = units.meter(5.0, uncertainty=0.4)
+        c = a - b
+        self.assertAlmostEqual(c.value, 5.0, places=9)
+        # sqrt(0.3² + 0.4²) = 0.5
+        self.assertAlmostEqual(c.uncertainty, 0.5, places=9)
+
+    def test_addition_one_uncertain(self):
+        a = units.meter(10.0, uncertainty=0.3)
+        b = units.meter(5.0)  # no uncertainty
+        c = a + b
+        self.assertAlmostEqual(c.value, 15.0, places=9)
+        self.assertAlmostEqual(c.uncertainty, 0.3, places=9)
+
+    def test_addition_neither_uncertain(self):
+        a = units.meter(10.0)
+        b = units.meter(5.0)
+        c = a + b
+        self.assertAlmostEqual(c.value, 15.0, places=9)
+        self.assertIsNone(c.uncertainty)
+
+
+class TestMultiplicationPropagation(unittest.TestCase):
+    """Test uncertainty propagation through multiplication."""
+
+    def test_multiplication_both_uncertain(self):
+        a = units.meter(10.0, uncertainty=0.2)  # 2% relative
+        b = units.meter(5.0, uncertainty=0.15)  # 3% relative
+        c = a * b
+        self.assertAlmostEqual(c.value, 50.0, places=9)
+        # relative: sqrt((0.2/10)² + (0.15/5)²) = sqrt(0.0004 + 0.0009) = sqrt(0.0013) ≈ 0.0361
+        # absolute: 50 * 0.0361 ≈ 1.803
+        expected = 50.0 * math.sqrt((0.2/10)**2 + (0.15/5)**2)
+        self.assertAlmostEqual(c.uncertainty, expected, places=6)
+
+    def test_multiplication_one_uncertain(self):
+        a = units.meter(10.0, uncertainty=0.2)
+        b = units.meter(5.0)  # no uncertainty
+        c = a * b
+        self.assertAlmostEqual(c.value, 50.0, places=9)
+        # Only a contributes: |c| * (δa/a) = 50 * 0.02 = 1.0
+        expected = 50.0 * (0.2/10)
+        self.assertAlmostEqual(c.uncertainty, expected, places=9)
+
+    def test_multiplication_neither_uncertain(self):
+        a = units.meter(10.0)
+        b = units.meter(5.0)
+        c = a * b
+        self.assertAlmostEqual(c.value, 50.0, places=9)
+        self.assertIsNone(c.uncertainty)
+
+
+class TestDivisionPropagation(unittest.TestCase):
+    """Test uncertainty propagation through division."""
+
+    def test_division_both_uncertain(self):
+        a = units.meter(10.0, uncertainty=0.2)  # 2% relative
+        b = units.second(2.0, uncertainty=0.04)  # 2% relative
+        c = a / b
+        self.assertAlmostEqual(c.value, 5.0, places=9)
+        # relative: sqrt((0.2/10)² + (0.04/2)²) = sqrt(0.0004 + 0.0004) = sqrt(0.0008) ≈ 0.0283
+        # absolute: 5 * 0.0283 ≈ 0.1414
+        expected = 5.0 * math.sqrt((0.2/10)**2 + (0.04/2)**2)
+        self.assertAlmostEqual(c.uncertainty, expected, places=6)
+
+    def test_division_one_uncertain(self):
+        a = units.meter(10.0, uncertainty=0.2)
+        b = units.second(2.0)  # no uncertainty
+        c = a / b
+        self.assertAlmostEqual(c.value, 5.0, places=9)
+        expected = 5.0 * (0.2/10)
+        self.assertAlmostEqual(c.uncertainty, expected, places=9)
+
+    def test_division_neither_uncertain(self):
+        a = units.meter(10.0)
+        b = units.second(2.0)
+        c = a / b
+        self.assertAlmostEqual(c.value, 5.0, places=9)
+        self.assertIsNone(c.uncertainty)
+
+
+class TestScalarOperations(unittest.TestCase):
+    """Test uncertainty propagation with scalar multiplication/division."""
+
+    def test_scalar_multiply_number(self):
+        a = units.meter(10.0, uncertainty=0.2)
+        c = a * 3  # scalar multiplication
+        self.assertAlmostEqual(c.value, 30.0, places=9)
+        self.assertAlmostEqual(c.uncertainty, 0.6, places=9)
+
+    def test_scalar_divide_number(self):
+        a = units.meter(10.0, uncertainty=0.2)
+        c = a / 2  # scalar division
+        self.assertAlmostEqual(c.value, 5.0, places=9)
+        self.assertAlmostEqual(c.uncertainty, 0.1, places=9)
+
+
+class TestConversionPropagation(unittest.TestCase):
+    """Test uncertainty propagation through unit conversion."""
+
+    def test_linear_conversion(self):
+        # meter to foot: factor ≈ 3.28084
+        length = units.meter(1.0, uncertainty=0.01)
+        length_ft = length.to(units.foot)
+        self.assertAlmostEqual(length_ft.value, 3.28084, places=4)
+        # uncertainty scales by same factor
+        self.assertAlmostEqual(length_ft.uncertainty, 0.01 * 3.28084, places=4)
+
+    def test_affine_conversion(self):
+        # Celsius to Kelvin: K = C + 273.15
+        # Derivative is 1, so uncertainty unchanged
+        temp = units.celsius(25.0, uncertainty=0.5)
+        temp_k = temp.to(units.kelvin)
+        self.assertAlmostEqual(temp_k.value, 298.15, places=9)
+        self.assertAlmostEqual(temp_k.uncertainty, 0.5, places=9)
+
+    def test_fahrenheit_to_celsius(self):
+        # F to C: C = (F - 32) * 5/9
+        # Derivative is 5/9 ≈ 0.5556
+        temp = units.fahrenheit(100.0, uncertainty=1.0)
+        temp_c = temp.to(units.celsius)
+        self.assertAlmostEqual(temp_c.value, 37.7778, places=3)
+        self.assertAlmostEqual(temp_c.uncertainty, 1.0 * (5/9), places=6)
+
+    def test_conversion_without_uncertainty(self):
+        length = units.meter(1.0)
+        length_ft = length.to(units.foot)
+        self.assertIsNone(length_ft.uncertainty)
+
+
+class TestEdgeCases(unittest.TestCase):
+    """Test edge cases for uncertainty handling."""
+
+    def test_zero_uncertainty(self):
+        a = units.meter(10.0, uncertainty=0.0)
+        b = units.meter(5.0, uncertainty=0.0)
+        c = a + b
+        self.assertAlmostEqual(c.uncertainty, 0.0, places=9)
+
+    def test_very_small_uncertainty(self):
+        a = units.meter(10.0, uncertainty=1e-15)
+        b = units.meter(5.0, uncertainty=1e-15)
+        c = a * b
+        self.assertIsNotNone(c.uncertainty)
+        self.assertGreater(c.uncertainty, 0)
+
+    def test_uncertainty_preserved_through_simplify(self):
+        km = Scale.kilo * units.meter
+        n = km(5.0, uncertainty=0.1)
+        simplified = n.simplify()
+        self.assertAlmostEqual(simplified.value, 5000.0, places=9)
+        # uncertainty also scales
+        self.assertAlmostEqual(simplified.uncertainty, 100.0, places=9)
+
+
+class TestMapDerivative(unittest.TestCase):
+    """Test Map.derivative() implementations."""
+
+    def test_linear_map_derivative(self):
+        from ucon.maps import LinearMap
+        m = LinearMap(3.28084)
+        self.assertAlmostEqual(m.derivative(0), 3.28084, places=9)
+        self.assertAlmostEqual(m.derivative(100), 3.28084, places=9)
+
+    def test_affine_map_derivative(self):
+        from ucon.maps import AffineMap
+        m = AffineMap(5/9, -32 * 5/9)  # F to C
+        self.assertAlmostEqual(m.derivative(0), 5/9, places=9)
+        self.assertAlmostEqual(m.derivative(100), 5/9, places=9)
+
+    def test_composed_map_derivative(self):
+        from ucon.maps import LinearMap, AffineMap
+        # Compose: first scale by 2, then add 10
+        inner = LinearMap(2)
+        outer = AffineMap(1, 10)
+        composed = outer @ inner
+        # d/dx [1*(2x) + 10] = 2
+        self.assertAlmostEqual(composed.derivative(0), 2, places=9)
+        self.assertAlmostEqual(composed.derivative(5), 2, places=9)
+
+
+if __name__ == "__main__":
+    unittest.main()

ucon/algebra.py

@@ -102,9 +102,10 @@ class Vector:
         values = tuple(component * scalar for component in tuple(self))
         return Vector(*values)
 
-    def __eq__(self, vector: 'Vector') -> bool:
-        assert isinstance(vector, Vector), "Can only compare Vector to another Vector"
-        return tuple(self) == tuple(vector)
+    def __eq__(self, other) -> bool:
+        if not isinstance(other, Vector):
+            return NotImplemented
+        return tuple(self) == tuple(other)
 
     def __hash__(self) -> int:
         # Hash based on the string because tuples have been shown to collide

ucon/core.py

@@ -36,6 +36,10 @@ class Dimension(Enum):
     """
     Represents a **physical dimension** defined by a :class:`Vector`.
     Algebra over multiplication/division & exponentiation, with dynamic resolution.
+
+    Pseudo-dimensions (angle, solid_angle, ratio) share the zero vector but are
+    semantically isolated via unique enum values. They use tuple values (Vector, tag)
+    to prevent Python's Enum from treating them as aliases of `none`.
     """
     none = Vector()
 
@@ -50,6 +54,12 @@ class Dimension(Enum):
     information         = Vector(0, 0, 0, 0, 0, 0, 0, 1)
     # ------------------------------------------------
 
+    # -- PSEUDO-DIMENSIONS (zero vector, distinct values via tuple) --
+    angle       = (Vector(), "angle")        # radian, degree, etc.
+    solid_angle = (Vector(), "solid_angle")  # steradian, square_degree
+    ratio       = (Vector(), "ratio")        # percent, ppm, etc.
+    # ----------------------------------------------------------------
+
     acceleration = Vector(-2, 1, 0, 0, 0, 0, 0, 0)
     angular_momentum = Vector(-1, 2, 1, 0, 0, 0, 0, 0)
     area = Vector(0, 2, 0, 0, 0, 0, 0, 0)
@@ -83,10 +93,22 @@ class Dimension(Enum):
     voltage = Vector(-3, 2, 1, -1, 0, 0, 0, 0)
     volume = Vector(0, 3, 0, 0, 0, 0, 0, 0)
 
+    @property
+    def vector(self) -> 'Vector':
+        """Return the dimensional Vector, handling both regular and pseudo-dimensions."""
+        if isinstance(self.value, tuple):
+            vector, _ = self.value  # discard the tag
+            return vector
+        return self.value
+
     @classmethod
     def _resolve(cls, vector: 'Vector') -> 'Dimension':
+        # Zero vector always resolves to none, never to pseudo-dimensions.
+        # This ensures algebraic operations like length/length yield none.
+        if vector == Vector():
+            return cls.none
         for dim in cls:
-            if dim.value == vector:
+            if dim.vector == vector:
                 return dim
         dyn = object.__new__(cls)
         dyn._name_ = f"derived({vector})"
@@ -96,27 +118,32 @@ class Dimension(Enum):
     def __truediv__(self, dimension: 'Dimension') -> 'Dimension':
         if not isinstance(dimension, Dimension):
             raise TypeError(f"Cannot divide Dimension by non-Dimension type: {type(dimension)}")
-        return self._resolve(self.value - dimension.value)
+        return self._resolve(self.vector - dimension.vector)
 
     def __mul__(self, dimension: 'Dimension') -> 'Dimension':
         if not isinstance(dimension, Dimension):
             raise TypeError(f"Cannot multiply Dimension by non-Dimension type: {type(dimension)}")
-        return self._resolve(self.value + dimension.value)
+        return self._resolve(self.vector + dimension.vector)
 
     def __pow__(self, power: Union[int, float]) -> 'Dimension':
         if power == 1:
             return self
         if power == 0:
             return Dimension.none
-        new_vector = self.value * power
+        new_vector = self.vector * power
         return self._resolve(new_vector)
 
     def __eq__(self, dimension) -> bool:
         if not isinstance(dimension, Dimension):
             raise TypeError(f"Cannot compare Dimension with non-Dimension type: {type(dimension)}")
-        return self.value == dimension.value
+        # For pseudo-dimensions (tuple values), compare by identity
+        if isinstance(self.value, tuple) or isinstance(dimension.value, tuple):
+            return self is dimension
+        # For regular dimensions, compare by vector
+        return self.vector == dimension.vector
 
     def __hash__(self) -> int:
+        # Use the raw value for hashing (tuples and Vectors hash differently)
         return hash(self.value)
 
     def __bool__(self):
@@ -418,15 +445,24 @@ class Unit:
 
     # ----------------- callable (creates Number) -----------------
 
-    def __call__(self, quantity: Union[int, float]) -> "Number":
+    def __call__(self, quantity: Union[int, float], uncertainty: Union[float, None] = None) -> "Number":
         """Create a Number with this unit.
 
+        Parameters
+        ----------
+        quantity : int or float
+            The numeric value.
+        uncertainty : float, optional
+            The measurement uncertainty.
+
         Example
         -------
         >>> meter(5)
         <5 m>
+        >>> meter(1.234, uncertainty=0.005)
+        <1.234 ± 0.005 m>
         """
-        return Number(quantity=quantity, unit=UnitProduct.from_unit(self))
+        return Number(quantity=quantity, unit=UnitProduct.from_unit(self), uncertainty=uncertainty)
 
 
 @dataclass(frozen=True)
@@ -845,15 +881,24 @@ class UnitProduct:
         # Sort by name; UnitFactor exposes .name, so this is stable.
         return hash(tuple(sorted(self.factors.items(), key=lambda x: x[0].name)))
 
-    def __call__(self, quantity: Union[int, float]) -> "Number":
+    def __call__(self, quantity: Union[int, float], uncertainty: Union[float, None] = None) -> "Number":
         """Create a Number with this unit product.
 
+        Parameters
+        ----------
+        quantity : int or float
+            The numeric value.
+        uncertainty : float, optional
+            The measurement uncertainty.
+
         Example
         -------
         >>> (meter / second)(10)
         <10 m/s>
+        >>> (meter / second)(10, uncertainty=0.5)
+        <10 ± 0.5 m/s>
         """
-        return Number(quantity=quantity, unit=self)
+        return Number(quantity=quantity, unit=self, uncertainty=uncertainty)
 
 
 # --------------------------------------------------------------------------------------
@@ -881,9 +926,16 @@ class Number:
         >>> speed = length / time
         >>> speed
         <2.5 m/s>
+
+    Optionally includes measurement uncertainty for error propagation:
+
+        >>> length = meter(1.234, uncertainty=0.005)
+        >>> length
+        <1.234 ± 0.005 m>
     """
     quantity: Union[float, int] = 1.0
     unit: Union[Unit, UnitProduct] = None
+    uncertainty: Union[float, None] = None
 
     def __post_init__(self):
         if self.unit is None:
@@ -925,7 +977,7 @@ class Number:
         """
         if not isinstance(self.unit, UnitProduct):
             # Plain Unit already has no scale
-            return Number(quantity=self.quantity, unit=self.unit)
+            return Number(quantity=self.quantity, unit=self.unit, uncertainty=self.uncertainty)
 
         # Compute the combined scale factor
         scale_factor = self.unit.fold_scale()
@@ -938,8 +990,16 @@ class Number:
 
         base_unit = UnitProduct(base_factors)
 
-        # Adjust quantity by the scale factor
-        return Number(quantity=self.quantity * scale_factor, unit=base_unit)
+        # Adjust quantity and uncertainty by the scale factor
+        new_uncertainty = None
+        if self.uncertainty is not None:
+            new_uncertainty = self.uncertainty * abs(scale_factor)
+
+        return Number(
+            quantity=self.quantity * scale_factor,
+            unit=base_unit,
+            uncertainty=new_uncertainty,
+        )
 
     def to(self, target, graph=None):
         """Convert this Number to a different unit expression.
@@ -972,7 +1032,10 @@ class Number:
         # Scale-only conversion (same base unit, different scale)
         if self._is_scale_only_conversion(src, dst):
             factor = src.fold_scale() / dst.fold_scale()
-            return Number(quantity=self.quantity * factor, unit=target)
+            new_uncertainty = None
+            if self.uncertainty is not None:
+                new_uncertainty = self.uncertainty * abs(factor)
+            return Number(quantity=self.quantity * factor, unit=target, uncertainty=new_uncertainty)
 
         # Graph-based conversion (use default graph if none provided)
         if graph is None:
@@ -981,7 +1044,14 @@ class Number:
         conversion_map = graph.convert(src=src, dst=dst)
         # Use raw quantity - the conversion map handles scale via factorwise decomposition
         converted_quantity = conversion_map(self.quantity)
-        return Number(quantity=converted_quantity, unit=target)
+
+        # Propagate uncertainty through conversion using derivative
+        new_uncertainty = None
+        if self.uncertainty is not None:
+            derivative = abs(conversion_map.derivative(self.quantity))
+            new_uncertainty = derivative * self.uncertainty
+
+        return Number(quantity=converted_quantity, unit=target, uncertainty=new_uncertainty)
 
     def _is_scale_only_conversion(self, src: UnitProduct, dst: UnitProduct) -> bool:
         """Check if conversion is just a scale change (same base units)."""
@@ -1013,12 +1083,82 @@ class Number:
         if isinstance(other, Ratio):
             other = other.evaluate()
 
+        # Scalar multiplication
+        if isinstance(other, (int, float)):
+            new_uncertainty = None
+            if self.uncertainty is not None:
+                new_uncertainty = abs(other) * self.uncertainty
+            return Number(
+                quantity=self.quantity * other,
+                unit=self.unit,
+                uncertainty=new_uncertainty,
+            )
+
         if not isinstance(other, Number):
             return NotImplemented
 
+        # Uncertainty propagation for multiplication
+        # δc = |c| * sqrt((δa/a)² + (δb/b)²)
+        new_uncertainty = None
+        result_quantity = self.quantity * other.quantity
+        if self.uncertainty is not None or other.uncertainty is not None:
+            rel_a = (self.uncertainty / abs(self.quantity)) if (self.uncertainty and self.quantity != 0) else 0
+            rel_b = (other.uncertainty / abs(other.quantity)) if (other.uncertainty and other.quantity != 0) else 0
+            rel_c = math.sqrt(rel_a**2 + rel_b**2)
+            new_uncertainty = abs(result_quantity) * rel_c if rel_c > 0 else None
+
         return Number(
-            quantity=self.quantity * other.quantity,
+            quantity=result_quantity,
             unit=self.unit * other.unit,
+            uncertainty=new_uncertainty,
+        )
+
+    def __add__(self, other: 'Number') -> 'Number':
+        if not isinstance(other, Number):
+            return NotImplemented
+
+        # Dimensions must match for addition
+        if self.unit.dimension != other.unit.dimension:
+            raise TypeError(
+                f"Cannot add Numbers with different dimensions: "
+                f"{self.unit.dimension} vs {other.unit.dimension}"
+            )
+
+        # Uncertainty propagation for addition: δc = sqrt(δa² + δb²)
+        new_uncertainty = None
+        if self.uncertainty is not None or other.uncertainty is not None:
+            ua = self.uncertainty if self.uncertainty is not None else 0
+            ub = other.uncertainty if other.uncertainty is not None else 0
+            new_uncertainty = math.sqrt(ua**2 + ub**2)
+
+        return Number(
+            quantity=self.quantity + other.quantity,
+            unit=self.unit,
+            uncertainty=new_uncertainty,
+        )
+
+    def __sub__(self, other: 'Number') -> 'Number':
+        if not isinstance(other, Number):
+            return NotImplemented
+
+        # Dimensions must match for subtraction
+        if self.unit.dimension != other.unit.dimension:
+            raise TypeError(
+                f"Cannot subtract Numbers with different dimensions: "
+                f"{self.unit.dimension} vs {other.unit.dimension}"
+            )
+
+        # Uncertainty propagation for subtraction: δc = sqrt(δa² + δb²)
+        new_uncertainty = None
+        if self.uncertainty is not None or other.uncertainty is not None:
+            ua = self.uncertainty if self.uncertainty is not None else 0
+            ub = other.uncertainty if other.uncertainty is not None else 0
+            new_uncertainty = math.sqrt(ua**2 + ub**2)
+
+        return Number(
+            quantity=self.quantity - other.quantity,
+            unit=self.unit,
+            uncertainty=new_uncertainty,
         )
 
     def __truediv__(self, other: Quantifiable) -> "Number":
@@ -1026,25 +1166,47 @@ class Number:
         if isinstance(other, Ratio):
             other = other.evaluate()
 
+        # Scalar division
+        if isinstance(other, (int, float)):
+            new_uncertainty = None
+            if self.uncertainty is not None:
+                new_uncertainty = self.uncertainty / abs(other)
+            return Number(
+                quantity=self.quantity / other,
+                unit=self.unit,
+                uncertainty=new_uncertainty,
+            )
+
         if not isinstance(other, Number):
             raise TypeError(f"Cannot divide Number by non-Number/Ratio type: {type(other)}")
 
         # Symbolic quotient in the unit algebra
         unit_quot = self.unit / other.unit
 
+        # Uncertainty propagation for division
+        # δc = |c| * sqrt((δa/a)² + (δb/b)²)
+        def compute_uncertainty(result_quantity):
+            if self.uncertainty is None and other.uncertainty is None:
+                return None
+            rel_a = (self.uncertainty / abs(self.quantity)) if (self.uncertainty and self.quantity != 0) else 0
+            rel_b = (other.uncertainty / abs(other.quantity)) if (other.uncertainty and other.quantity != 0) else 0
+            rel_c = math.sqrt(rel_a**2 + rel_b**2)
+            return abs(result_quantity) * rel_c if rel_c > 0 else None
+
         # --- Case 1: Dimensionless result ----------------------------------
         # If the net dimension is none, we want a pure scalar:
         # fold *all* scale factors into the numeric magnitude.
         if not unit_quot.dimension:
             num = self._canonical_magnitude
             den = other._canonical_magnitude
-            return Number(quantity=num / den, unit=_none)
+            result = num / den
+            return Number(quantity=result, unit=_none, uncertainty=compute_uncertainty(result))
 
         # --- Case 2: Dimensionful result -----------------------------------
         # For "real" physical results like g/mL, m/s², etc., preserve the
         # user's chosen unit scales symbolically. Only divide the raw quantities.
         new_quantity = self.quantity / other.quantity
-        return Number(quantity=new_quantity, unit=unit_quot)
+        return Number(quantity=new_quantity, unit=unit_quot, uncertainty=compute_uncertainty(new_quantity))
 
     def __eq__(self, other: Quantifiable) -> bool:
         if not isinstance(other, (Number, Ratio)):
@@ -1067,6 +1229,10 @@ class Number:
         return True
 
     def __repr__(self):
+        if self.uncertainty is not None:
+            if not self.unit.dimension:
+                return f"<{self.quantity} ± {self.uncertainty}>"
+            return f"<{self.quantity} ± {self.uncertainty} {self.unit.shorthand}>"
         if not self.unit.dimension:
             return f"<{self.quantity}>"
         return f"<{self.quantity} {self.unit.shorthand}>"

ucon/graph.py

@@ -420,4 +420,22 @@ def _build_standard_graph() -> ConversionGraph:
     # --- Information ---
     graph.add_edge(src=units.byte, dst=units.bit, map=LinearMap(8))
 
+    # --- Angle ---
+    import math
+    graph.add_edge(src=units.radian, dst=units.degree, map=LinearMap(180 / math.pi))
+    graph.add_edge(src=units.degree, dst=units.arcminute, map=LinearMap(60))
+    graph.add_edge(src=units.arcminute, dst=units.arcsecond, map=LinearMap(60))
+    graph.add_edge(src=units.turn, dst=units.radian, map=LinearMap(2 * math.pi))
+    graph.add_edge(src=units.turn, dst=units.gradian, map=LinearMap(400))
+
+    # --- Solid Angle ---
+    graph.add_edge(src=units.steradian, dst=units.square_degree, map=LinearMap((180 / math.pi) ** 2))
+
+    # --- Ratio ---
+    graph.add_edge(src=units.ratio_one, dst=units.percent, map=LinearMap(100))
+    graph.add_edge(src=units.ratio_one, dst=units.permille, map=LinearMap(1000))
+    graph.add_edge(src=units.ratio_one, dst=units.ppm, map=LinearMap(1e6))
+    graph.add_edge(src=units.ratio_one, dst=units.ppb, map=LinearMap(1e9))
+    graph.add_edge(src=units.ratio_one, dst=units.basis_point, map=LinearMap(10000))
+
     return graph

ucon/maps.py

@@ -25,7 +25,7 @@ from dataclasses import dataclass
 class Map(ABC):
     """Abstract base for all conversion morphisms.
 
-    Subclasses must implement ``__call__``, ``inverse``, and ``__pow__``.
+    Subclasses must implement ``__call__``, ``inverse``, ``__pow__``, and ``derivative``.
     Composition via ``@`` defaults to :class:`ComposedMap`; subclasses may
     override for closed composition within their own type.
     """
@@ -50,6 +50,14 @@ class Map(ABC):
         """Raise map to a power (for exponent handling in factorwise conversion)."""
         ...
 
+    @abstractmethod
+    def derivative(self, x: float) -> float:
+        """Return the derivative of the map at point x.
+
+        Used for uncertainty propagation: δy = |f'(x)| * δx
+        """
+        ...
+
     def is_identity(self, tol: float = 1e-9) -> bool:
         """Check if this map is approximately the identity."""
         return abs(self(1.0) - 1.0) < tol and abs(self(0.0) - 0.0) < tol
@@ -86,6 +94,10 @@ class LinearMap(Map):
     def __pow__(self, exp: float) -> LinearMap:
         return LinearMap(self.a ** exp)
 
+    def derivative(self, x: float) -> float:
+        """Derivative of y = a*x is a (constant)."""
+        return self.a
+
     @classmethod
     def identity(cls) -> LinearMap:
         return cls(1.0)
@@ -128,6 +140,10 @@ class AffineMap(Map):
             return self.inverse()
         raise ValueError("AffineMap only supports exp=1 or exp=-1")
 
+    def derivative(self, x: float) -> float:
+        """Derivative of y = a*x + b is a (constant)."""
+        return self.a
+
 
 @dataclass(frozen=True)
 class ComposedMap(Map):
@@ -159,3 +175,8 @@ class ComposedMap(Map):
         if exp == -1:
             return self.inverse()
         raise ValueError("ComposedMap only supports exp=1 or exp=-1")
+
+    def derivative(self, x: float) -> float:
+        """Chain rule: d/dx [outer(inner(x))] = outer'(inner(x)) * inner'(x)."""
+        inner_val = self.inner(x)
+        return self.outer.derivative(inner_val) * self.inner.derivative(x)

ucon/units.py

@@ -56,10 +56,10 @@ mole = Unit(name='mole', dimension=Dimension.amount_of_substance, aliases=('mol'
 newton = Unit(name='newton', dimension=Dimension.force, aliases=('N',))
 ohm = Unit(name='ohm', dimension=Dimension.resistance, aliases=('Ω',))
 pascal = Unit(name='pascal', dimension=Dimension.pressure, aliases=('Pa',))
-radian = Unit(name='radian', dimension=Dimension.none, aliases=('rad',))
+radian = Unit(name='radian', dimension=Dimension.angle, aliases=('rad',))
 siemens = Unit(name='siemens', dimension=Dimension.conductance, aliases=('S',))
 sievert = Unit(name='sievert', dimension=Dimension.energy, aliases=('Sv',))
-steradian = Unit(name='steradian', dimension=Dimension.none, aliases=('sr',))
+steradian = Unit(name='steradian', dimension=Dimension.solid_angle, aliases=('sr',))
 tesla = Unit(name='tesla', dimension=Dimension.magnetic_flux_density, aliases=('T',))
 volt = Unit(name='volt', dimension=Dimension.voltage, aliases=('V',))
 watt = Unit(name='watt', dimension=Dimension.power, aliases=('W',))
@@ -113,6 +113,30 @@ byte = Unit(name='byte', dimension=Dimension.information, aliases=('B',))
 # ----------------------------------------------------------------------
 
 
+# -- Angle Units -------------------------------------------------------
+degree = Unit(name='degree', dimension=Dimension.angle, aliases=('deg', '°'))
+gradian = Unit(name='gradian', dimension=Dimension.angle, aliases=('grad', 'gon'))
+arcminute = Unit(name='arcminute', dimension=Dimension.angle, aliases=('arcmin', "'"))
+arcsecond = Unit(name='arcsecond', dimension=Dimension.angle, aliases=('arcsec', '"'))
+turn = Unit(name='turn', dimension=Dimension.angle, aliases=('rev', 'revolution'))
+# ----------------------------------------------------------------------
+
+
+# -- Solid Angle Units -------------------------------------------------
+square_degree = Unit(name='square_degree', dimension=Dimension.solid_angle, aliases=('deg²', 'sq_deg'))
+# ----------------------------------------------------------------------
+
+
+# -- Ratio Units -------------------------------------------------------
+ratio_one = Unit(name='one', dimension=Dimension.ratio, aliases=('1',))
+percent = Unit(name='percent', dimension=Dimension.ratio, aliases=('%',))
+permille = Unit(name='permille', dimension=Dimension.ratio, aliases=('‰',))
+ppm = Unit(name='ppm', dimension=Dimension.ratio, aliases=())
+ppb = Unit(name='ppb', dimension=Dimension.ratio, aliases=())
+basis_point = Unit(name='basis_point', dimension=Dimension.ratio, aliases=('bp', 'bps'))
+# ----------------------------------------------------------------------
+
+
 # Backward compatibility alias
 webers = weber
 

{ucon-0.4.2.dist-info → ucon-0.5.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ucon
-Version: 0.4.2
+Version: 0.5.1
 Summary: a tool for dimensional analysis: a "Unit CONverter"
 Home-page: https://github.com/withtwoemms/ucon
 Author: Emmanuel I. Obi
@@ -35,7 +35,12 @@ Dynamic: maintainer
 Dynamic: maintainer-email
 Dynamic: summary
 
-<img src="https://gist.githubusercontent.com/withtwoemms/0cb9e6bc8df08f326771a89eeb790f8e/raw/dde6c7d3b8a7d79eb1006ace03fb834e044cdebc/ucon-logo.png" align="left" width="200" />
+<table>
+  <tr>
+    <td width="200">
+      <img src="https://gist.githubusercontent.com/withtwoemms/0cb9e6bc8df08f326771a89eeb790f8e/raw/221c60e85ac8361c7d202896b52c1a279081b54c/ucon-logo.png" align="left" width="200" />
+    </td>
+    <td>
 
 # ucon
 
@@ -45,6 +50,10 @@ Dynamic: summary
 [![codecov](https://codecov.io/gh/withtwoemms/ucon/graph/badge.svg?token=BNONQTRJWG)](https://codecov.io/gh/withtwoemms/ucon)
 [![publish](https://github.com/withtwoemms/ucon/workflows/publish/badge.svg)](https://github.com/withtwoemms/ucon/actions?query=workflow%3Apublish)
 
+   </td>
+  </tr>
+</table>
+
 > A lightweight, **unit-aware computation library** for Python — built on first-principles.
 
 ---
@@ -57,6 +66,8 @@ It combines **units**, **scales**, and **dimensions** into a composable algebra
 - Dimensional analysis through `Number` and `Ratio`
 - Scale-aware arithmetic via `UnitFactor` and `UnitProduct`
 - Metric and binary prefixes (`kilo`, `kibi`, `micro`, `mebi`, etc.)
+- Pseudo-dimensions for angles, solid angles, and ratios with semantic isolation
+- Uncertainty propagation through arithmetic and conversions
 - A clean foundation for physics, chemistry, data modeling, and beyond
 
 Think of it as **`decimal.Decimal` for the physical world** — precise, predictable, and type-safe.
@@ -188,16 +199,54 @@ distance_mi = distance.to(units.mile)
 print(distance_mi)  # <3.107... mi>
 ```
 
+Dimensionless units have semantic isolation — angles, solid angles, and ratios are distinct:
+```python
+import math
+from ucon import units
+
+# Angle conversions
+angle = units.radian(math.pi)
+print(angle.to(units.degree))  # <180.0 deg>
+
+# Ratio conversions
+ratio = units.percent(50)
+print(ratio.to(units.ppm))  # <500000.0 ppm>
+
+# Cross-family conversions are prevented
+units.radian(1).to(units.percent)  # raises ConversionNotFound
+```
+
+Uncertainty propagates through arithmetic and conversions:
+```python
+from ucon import units
+
+# Measurements with uncertainty
+length = units.meter(1.234, uncertainty=0.005)
+width = units.meter(0.567, uncertainty=0.003)
+
+print(length)  # <1.234 ± 0.005 m>
+
+# Uncertainty propagates through arithmetic (quadrature)
+area = length * width
+print(area)  # <0.699678 ± 0.00424... m²>
+
+# Uncertainty propagates through conversion
+length_ft = length.to(units.foot)
+print(length_ft)  # <4.048... ± 0.0164... ft>
+```
+
 ---
 
 ## Roadmap Highlights
 
 | Version | Theme | Focus | Status |
 |----------|-------|--------|--------|
-| **0.3.5** | Dimensional Algebra | Unit/Scale separation, `UnitFactor`, `UnitProduct` | ✅ Complete |
-| [**0.4.x**](https://github.com/withtwoemms/ucon/milestone/2) | Conversion System | `ConversionGraph`, `Number.to()`, callable units | 🚧 In Progress |
-| [**0.6.x**](https://github.com/withtwoemms/ucon/milestone/4) | Nonlinear / Specialized Units | Decibel, Percent, pH | ⏳ Planned |
-| [**0.8.x**](https://github.com/withtwoemms/ucon/milestone/6) | Pydantic Integration | Type-safe quantity validation | ⏳ Planned |
+| **0.3.x** | Dimensional Algebra | Unit/Scale separation, `UnitFactor`, `UnitProduct` | ✅ Complete |
+| **0.4.x** | Conversion System | `ConversionGraph`, `Number.to()`, callable units | ✅ Complete |
+| **0.5.0** | Dimensionless Units | Pseudo-dimensions for angle, solid angle, ratio | ✅ Complete |
+| **0.5.x** | Uncertainty | Propagation through arithmetic and conversions | ✅ Complete |
+| **0.5.x** | Unit Systems | `BasisMap`, `UnitSystem` | 🚧 In Progress |
+| **0.7.x** | Pydantic Integration | Type-safe quantity validation | ⏳ Planned |
 
 See full roadmap: [ROADMAP.md](./ROADMAP.md)
 

ucon-0.5.1.dist-info/RECORD

@@ -0,0 +1,24 @@
+tests/ucon/__init__.py,sha256=9BAHYTs27Ed3VgqiMUH4XtVttAmOPgK0Zvj-dUNo7D8,119
+tests/ucon/test_algebra.py,sha256=NnoQOSMW8NJlOTnbr3M_5epvnDPXpVTgO21L2LcytRY,8503
+tests/ucon/test_core.py,sha256=bmwSRWPlhwossy5NJ9rcPWujFmzBBPOeZzPAzN1acFg,32631
+tests/ucon/test_default_graph_conversions.py,sha256=rkcDcSV1_kZeuPf4ModHDpgfkOPZS32xcKq7KPDRN-0,15760
+tests/ucon/test_dimensionless_units.py,sha256=K6BrIPOFL9IO_ksR8t_oJUXmjTgqBUzMdgaV-hZc52w,8410
+tests/ucon/test_quantity.py,sha256=md5nbmy0u2cFBdqNeu-ROhoj29vYrIlGm_AjlmCttgc,24519
+tests/ucon/test_uncertainty.py,sha256=KkJw2dJR0EToxPpBN24x735jr9fv6a2myxjvhOH4MPU,9649
+tests/ucon/test_units.py,sha256=SILymDtDNDyxEhkYQubrfkakKCMexwEwjyHfhrkDrMI,869
+tests/ucon/conversion/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/ucon/conversion/test_graph.py,sha256=fs0aP6qNf8eE1uI7SoGSCW2XAkHYb7T9aaI-kzmO02c,16955
+tests/ucon/conversion/test_map.py,sha256=DVFQ3xwp16Nuy9EtZRjKlWbkXfRUcM1mOzFrS4HhOaw,13886
+ucon/__init__.py,sha256=jaFcNFZC5gxHKzM8OkS1pLxltp6ToLRVpuuhJQY9FKQ,2000
+ucon/algebra.py,sha256=4JiT_SHHep86Sv3tVkgKsRY95lBRASMkyH4vOUA-gfM,7459
+ucon/core.py,sha256=nuDmSuGiG3xUW_kRpOWu9FDhNmKE0aJPwpj30lMdrgo,49464
+ucon/graph.py,sha256=lPoYSvHNGBZxeZ-4dyZIu2OS5R1JTo0qPZ9wd0vg-s4,15566
+ucon/maps.py,sha256=tWP4ayYCEazJzf81EP1_fmtADhg18D1eHldudAMEY0U,5460
+ucon/quantity.py,sha256=GBxZ_96nocx-8F-usNWGbPvWHRhRgdZzqfH9Sx69iC4,465
+ucon/units.py,sha256=u1ILwGllzNiwGLadlg5jguKPyFV1u-CZSUMgUDWTen4,7509
+ucon-0.5.1.dist-info/licenses/LICENSE,sha256=LtimSYBSw1L_X6n1-VEdZRdwuROzPumrMUNX21asFuI,11356
+ucon-0.5.1.dist-info/licenses/NOTICE,sha256=bh4fBOItio3kM4hSNYhqfFpcaAvOoixjD7Du8im-sYA,1079
+ucon-0.5.1.dist-info/METADATA,sha256=dkjXacaxxZbFq9vIBfJJ-2koy03T9Ozf_nimaNm2mwQ,13554
+ucon-0.5.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+ucon-0.5.1.dist-info/top_level.txt,sha256=zZYRJiQrVUtN32ziJD2YEq7ClSvDmVYHYy5ArRAZGxI,11
+ucon-0.5.1.dist-info/RECORD,,

ucon-0.4.2.dist-info/RECORD

@@ -1,22 +0,0 @@
-tests/ucon/__init__.py,sha256=9BAHYTs27Ed3VgqiMUH4XtVttAmOPgK0Zvj-dUNo7D8,119
-tests/ucon/test_algebra.py,sha256=Esm38M1QBNsV7vdfoFgqRUluyvWX7yccB0RwZXk4DpA,8433
-tests/ucon/test_core.py,sha256=bmwSRWPlhwossy5NJ9rcPWujFmzBBPOeZzPAzN1acFg,32631
-tests/ucon/test_default_graph_conversions.py,sha256=rkcDcSV1_kZeuPf4ModHDpgfkOPZS32xcKq7KPDRN-0,15760
-tests/ucon/test_quantity.py,sha256=md5nbmy0u2cFBdqNeu-ROhoj29vYrIlGm_AjlmCttgc,24519
-tests/ucon/test_units.py,sha256=SILymDtDNDyxEhkYQubrfkakKCMexwEwjyHfhrkDrMI,869
-tests/ucon/conversion/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/ucon/conversion/test_graph.py,sha256=fs0aP6qNf8eE1uI7SoGSCW2XAkHYb7T9aaI-kzmO02c,16955
-tests/ucon/conversion/test_map.py,sha256=DVFQ3xwp16Nuy9EtZRjKlWbkXfRUcM1mOzFrS4HhOaw,13886
-ucon/__init__.py,sha256=jaFcNFZC5gxHKzM8OkS1pLxltp6ToLRVpuuhJQY9FKQ,2000
-ucon/algebra.py,sha256=wGl4jJVMd8SXQ4sYDBOxV00ymAzRWfDhea1o4t2kVp4,7482
-ucon/core.py,sha256=PnQ68jwdkbgMb8AIEhy1aJDRxYjNNPi3TQ0B6IDRvqg,42201
-ucon/graph.py,sha256=EH0Zi4yj8SI6o27V4uo4muucaqV5nCoL6S3syb-IfXc,14587
-ucon/maps.py,sha256=yyZ7RqnohO2joTUvvKh40in7E6SKMQIQ8jkECO0-_NA,4753
-ucon/quantity.py,sha256=GBxZ_96nocx-8F-usNWGbPvWHRhRgdZzqfH9Sx69iC4,465
-ucon/units.py,sha256=2hisCuB_kTDcNlG6tzze2ZNVpmsnEeEFGWhfbrbomzk,6096
-ucon-0.4.2.dist-info/licenses/LICENSE,sha256=LtimSYBSw1L_X6n1-VEdZRdwuROzPumrMUNX21asFuI,11356
-ucon-0.4.2.dist-info/licenses/NOTICE,sha256=bh4fBOItio3kM4hSNYhqfFpcaAvOoixjD7Du8im-sYA,1079
-ucon-0.4.2.dist-info/METADATA,sha256=wKqDKC_QGNnWmkeycDI-_str1RtVKeE-uRBltAcUCg0,12348
-ucon-0.4.2.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-ucon-0.4.2.dist-info/top_level.txt,sha256=zZYRJiQrVUtN32ziJD2YEq7ClSvDmVYHYy5ArRAZGxI,11
-ucon-0.4.2.dist-info/RECORD,,