ucon 0.4.1__py3-none-any.whl → 0.5.0__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_quantity.py

@@ -364,6 +364,66 @@ class TestRatioEdgeCases(unittest.TestCase):
         self.assertIn("/", rep)
 
 
+class TestRatioExponentScaling(unittest.TestCase):
+    """Tests for Ratio.evaluate() using Exponent-based scaling.
+
+    Ensures Ratio.evaluate() behaves consistently with Number.__truediv__
+    when units cancel to dimensionless results.
+    """
+
+    def test_evaluate_dimensionless_with_different_scales(self):
+        """Ratio of same unit with different scales should fold scales."""
+        kg = Scale.kilo * units.gram
+        # 500 g / 1 kg = 0.5 (dimensionless)
+        ratio = Ratio(units.gram(500), kg(1))
+        result = ratio.evaluate()
+        self.assertAlmostEqual(result.quantity, 0.5, places=10)
+        self.assertEqual(result.unit.dimension, Dimension.none)
+
+    def test_evaluate_matches_number_truediv(self):
+        """Ratio.evaluate() should match Number.__truediv__ for dimensionless."""
+        kg = Scale.kilo * units.gram
+        num = units.gram(500)
+        den = kg(1)
+
+        ratio_result = Ratio(num, den).evaluate()
+        truediv_result = num / den
+
+        self.assertAlmostEqual(ratio_result.quantity, truediv_result.quantity, places=10)
+        self.assertEqual(ratio_result.unit.dimension, truediv_result.unit.dimension)
+
+    def test_evaluate_cross_base_scaling(self):
+        """Binary and decimal prefixes should combine correctly."""
+        kibigram = Scale.kibi * units.gram  # 1024 g
+        kg = Scale.kilo * units.gram         # 1000 g
+        # 1 kibigram / 1 kg = 1024/1000 = 1.024
+        ratio = Ratio(kibigram(1), kg(1))
+        result = ratio.evaluate()
+        self.assertAlmostEqual(result.quantity, 1.024, places=10)
+        self.assertEqual(result.unit.dimension, Dimension.none)
+
+    def test_evaluate_dimensionful_preserves_scales(self):
+        """Non-cancelling units should preserve symbolic scales."""
+        km = Scale.kilo * units.meter
+        # 100 km / 2 h = 50 km/h (scales preserved, not folded)
+        ratio = Ratio(km(100), units.hour(2))
+        result = ratio.evaluate()
+        self.assertAlmostEqual(result.quantity, 50.0, places=10)
+        self.assertEqual(result.unit.dimension, Dimension.velocity)
+        self.assertIn("km", result.unit.shorthand)
+
+    def test_evaluate_complex_composition(self):
+        """Composed ratios should maintain scale semantics."""
+        mL = Scale.milli * units.liter
+        # Density: 3.119 g/mL
+        density = Ratio(units.gram(3.119), mL(1))
+        # Volume: 2 mL
+        volume = Ratio(mL(2), Number())
+        # Mass = density * volume
+        result = (density * volume).evaluate()
+        self.assertAlmostEqual(result.quantity, 6.238, places=3)
+
+
 class TestCallableUnits(unittest.TestCase):
     """Tests for the callable unit syntax: unit(quantity) -> Number."""
 

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):
@@ -1091,13 +1118,27 @@ class Ratio:
         return Ratio(numerator=self.denominator, denominator=self.numerator)
 
     def evaluate(self) -> "Number":
-        # Pure arithmetic, no scale normalization.
-        numeric = self.numerator.quantity / self.denominator.quantity
+        """Evaluate the ratio to a Number.
 
-        # Pure unit division, with UnitFactor preservation.
+        Uses Exponent-derived arithmetic for scale handling:
+        - If the result is dimensionless (units cancel), scales are folded
+          into the magnitude using _canonical_magnitude.
+        - If the result is dimensionful, raw quantities are divided and
+          unit scales are preserved symbolically.
+
+        This matches the behavior of Number.__truediv__ for consistency.
+        """
+        # Symbolic quotient in the unit algebra
         unit = self.numerator.unit / self.denominator.unit
 
-        # DO NOT normalize, DO NOT fold scale.
+        # Dimensionless result: fold all scale factors into magnitude
+        if not unit.dimension:
+            num = self.numerator._canonical_magnitude
+            den = self.denominator._canonical_magnitude
+            return Number(quantity=num / den, unit=_none)
+
+        # Dimensionful result: preserve user's chosen scales symbolically
+        numeric = self.numerator.quantity / self.denominator.quantity
         return Number(quantity=numeric, unit=unit)
 
     def __mul__(self, another_ratio: 'Ratio') -> 'Ratio':

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/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.1.dist-info → ucon-0.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ucon
-Version: 0.4.1
+Version: 0.5.0
 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,7 @@ 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
 - 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 +198,34 @@ 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
+```
+
 ---
 
 ## 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** | Metrology | Uncertainty propagation, `UnitSystem` | 🚧 In Progress |
+| **0.7.x** | Pydantic Integration | Type-safe quantity validation | ⏳ Planned |
 
 See full roadmap: [ROADMAP.md](./ROADMAP.md)
 

{ucon-0.4.1.dist-info → ucon-0.5.0.dist-info}/RECORD

@@ -1,22 +1,23 @@
 tests/ucon/__init__.py,sha256=9BAHYTs27Ed3VgqiMUH4XtVttAmOPgK0Zvj-dUNo7D8,119
-tests/ucon/test_algebra.py,sha256=Esm38M1QBNsV7vdfoFgqRUluyvWX7yccB0RwZXk4DpA,8433
+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_quantity.py,sha256=7rFg4cpdmGV7vyCwg72Bt4EFBgkyM3cPFoRbRn0bqEI,21943
+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_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=o3Q4posUOYoIhQVHl6bANCIcGKgGOpNZsnqGZw9ujYk,41523
-ucon/graph.py,sha256=EH0Zi4yj8SI6o27V4uo4muucaqV5nCoL6S3syb-IfXc,14587
+ucon/algebra.py,sha256=4JiT_SHHep86Sv3tVkgKsRY95lBRASMkyH4vOUA-gfM,7459
+ucon/core.py,sha256=GjLKV0ERyYLhBZBpyIfCrKL718EN1RlUKwqxx2B3Rc4,43606
+ucon/graph.py,sha256=lPoYSvHNGBZxeZ-4dyZIu2OS5R1JTo0qPZ9wd0vg-s4,15566
 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.1.dist-info/licenses/LICENSE,sha256=LtimSYBSw1L_X6n1-VEdZRdwuROzPumrMUNX21asFuI,11356
-ucon-0.4.1.dist-info/licenses/NOTICE,sha256=bh4fBOItio3kM4hSNYhqfFpcaAvOoixjD7Du8im-sYA,1079
-ucon-0.4.1.dist-info/METADATA,sha256=bHAexnROmQ4BUaxkY83fLe6ptkCGwt7aVEckFrflg3U,12348
-ucon-0.4.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-ucon-0.4.1.dist-info/top_level.txt,sha256=zZYRJiQrVUtN32ziJD2YEq7ClSvDmVYHYy5ArRAZGxI,11
-ucon-0.4.1.dist-info/RECORD,,
+ucon/units.py,sha256=u1ILwGllzNiwGLadlg5jguKPyFV1u-CZSUMgUDWTen4,7509
+ucon-0.5.0.dist-info/licenses/LICENSE,sha256=LtimSYBSw1L_X6n1-VEdZRdwuROzPumrMUNX21asFuI,11356
+ucon-0.5.0.dist-info/licenses/NOTICE,sha256=bh4fBOItio3kM4hSNYhqfFpcaAvOoixjD7Du8im-sYA,1079
+ucon-0.5.0.dist-info/METADATA,sha256=TZDRVKaAMyCbbwanZ44Ej5JsCGNf0iWch1PD_CFnIx4,12901
+ucon-0.5.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+ucon-0.5.0.dist-info/top_level.txt,sha256=zZYRJiQrVUtN32ziJD2YEq7ClSvDmVYHYy5ArRAZGxI,11
+ucon-0.5.0.dist-info/RECORD,,