unitx 0.6.0__tar.gz → 0.6.2__tar.gz

{unitx-0.6.0 → unitx-0.6.2}/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## [0.6.2] - 2026-10-18
+
+### Added
+
+- Support multiplication and division between Quantity and Factor or SymbolicConstant in both operand orders. Multiplication and right-hand division preserve the magnitude and its type, combining the exact factor with the unit's scale; left-hand division takes the reciprocal magnitude and scales the reciprocal unit. Ordinary numeric operands continue to operate on the magnitude.
+- Preserve generic magnitude types in the corresponding public type hints, with runtime and static regression coverage for exact scaling and reciprocal operations.
+
+### Changed
+
+- Combine the compact exact scale and formal units in ScaledUnit string output, grouping denominator factors into one product, such as `J⋅s/(2⋅π)`.
+- Display quantities with scaled units using the combined product and multiplication dots between adjacent numeric factors, such as `3⋅60⋅s`, without evaluating the exact scale. String output remains readable display rather than parser input; `repr()` retains reconstructible state.
+- Document exact-factor quantity arithmetic and the distinction between a symbolic expression such as `SI.h / (2 * PI)` and predefined `SI.hbar`, which continues to expose its numerical value in ordinary `J*s` units.
+
+## [0.6.1] - 2026-10-17
+
+### Changed
+
+- Make multiplication of ordinary numeric magnitudes with Unit and ScaledUnit symmetric: both operand orders construct a Quantity and preserve the magnitude type. Zero and negative magnitudes are supported; float magnitudes retain their stored values without Factor rationalization.
+- Return Quantity when dividing Unit or ScaledUnit by an ordinary number. Integer, Fraction, and finite Decimal divisors produce exact Fraction reciprocals, so `si.deg / 60` preserves the exact arcminute definition; float divisors use native division.
+- Keep Factor and SymbolicConstant multiplication and division as exact ScaledUnit operations. To retain the former explicit scaling behavior, use `unit * Factor(value)` or `unit / Factor(value)`.
+
 ## [0.6.0] - 2026-10-17
 
 ### Added

{unitx-0.6.0 → unitx-0.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: unitx
-Version: 0.6.0
+Version: 0.6.2
 Summary: A modern, intuitive Python library for units, quantities, and dimensional analysis.
 Project-URL: Homepage, https://github.com/DaitTHU/unitx
 Project-URL: Issues, https://github.com/DaitTHU/unitx/issues
@@ -115,6 +115,7 @@ evaluated numerically.
 For unit expressions and explicit construction, import the classes:
 
 ```pycon
+>>> from unitx.factor import Factor
 >>> from unitx.quantity import Quantity
 >>> from unitx.unit import Unit
 >>> Quantity(50, 'cm') == 50 * si.cm
@@ -129,33 +130,65 @@ True
 with the reciprocal unit. Construction preserves the original magnitude and
 its type.
 
-These are directional construction operators: `value * unit` and `value / unit`
-construct a `Quantity`, while `unit * value` and `unit / value` adjust the
-unit's scale and return a `ScaledUnit`. Right-hand numeric scales must be
-positive finite `int`, `Fraction`, `Decimal`, or `float` values; booleans are
-not accepted. Fraction and Decimal scales remain exact. Floats follow Factor's
-denominator limit and may warn or round to zero and fail. A `Factor` or
-`SymbolicConstant` on either side of a unit produces a `ScaledUnit`.
+Multiplication is symmetric: `unit * value` and `value * unit` both construct
+`Quantity` objects and preserve the magnitude's type. Dividing a unit by an
+`int`, `Fraction`, or finite `Decimal` constructs a quantity with an exact
+`Fraction` reciprocal, so `degree / 60` loses no precision. Float divisors use
+native floating-point division without Factor's denominator limit. Booleans
+are not accepted as right-hand numeric operands. A `Factor` or
+`SymbolicConstant` on either side of a unit instead produces a `ScaledUnit`.
 
 ```pycon
 >>> metre = Unit('m')
->>> quantity = 2 * metre
->>> quantity.value, quantity.unit == metre
-(2, True)
->>> double_metre = metre * 2
+>>> metre * 2 == 2 * metre
+True
+>>> (metre * 2).value
+2
+>>> double_metre = metre * Factor(2)
 >>> print(double_metre)
-2 m
+2⋅m
 >>> (3 * double_metre).to('m').value
 6
->>> (3 * (metre / 2)).to('m').value
-Fraction(3, 2)
+>>> arcmin = si.deg / 60
+>>> arcmin.value
+Fraction(1, 60)
+>>> arcmin.to(si.arcmin).value
+Fraction(1, 1)
+
+```
+
+Multiplying a `ScaledUnit` by an ordinary number also constructs a quantity,
+keeping the exact scale in its unit and preserving the supplied magnitude.
+Combining a Unit with a Quantity continues to return a Quantity.
+
+Quantities also accept `Factor` and `SymbolicConstant` operands on either side
+of multiplication or division. Multiplication and right-hand division preserve
+the magnitude and its type, combining the exact factor with the unit instead.
+Left-hand division takes the reciprocal magnitude and unit. Ordinary numeric
+operands continue to act on the magnitude: `q * 2` and `q * Factor(2)` represent
+equal physical quantities but can have different `.value` and `.unit` pairs.
+
+```pycon
+>>> from unitx.factor import PI
+>>> hbar = SI.h / (2 * PI)
+>>> print(hbar)
+6.62607015E-34 J⋅s/(2⋅π)
+>>> hbar.value == SI.h.value
+True
+>>> hbar * (2 * PI) == SI.h
+True
+>>> round(float(hbar.to('J*s').value) / 1e-34, 8)
+1.05457182
 
 ```
 
-Grouping can therefore change the stored magnitude and unit: `(3 * metre) * 2`
-stores magnitude 6 in metres, while `3 * (metre * 2)` stores magnitude 3 in
-double metres. They compare as equal quantities. Combining a Unit with a
-Quantity continues to return a Quantity.
+The local `hbar` above retains the exact scale, whereas predefined `SI.hbar`
+provides its numerical value in ordinary `J*s` units. `.value` is always the
+magnitude paired with `.unit`, including its exact scale. Use
+`.to('J*s').value` to evaluate the local expression in joule seconds;
+conversion involving an irrational factor evaluates it approximately.
+String output combines the scale and formal units into one product, with
+grouped denominator factors and multiplication dots between adjacent numbers.
 
 ## Conversion and arithmetic
 
@@ -238,8 +271,8 @@ True
 
 ```
 
-Multiplying or dividing a unit by a positive numeric scale, `Factor`, or
-`SymbolicConstant` creates a `ScaledUnit`, which preserves an exact additional
+Multiplying or dividing a unit by a `Factor` or `SymbolicConstant` creates a
+`ScaledUnit`, which preserves an exact additional
 scale through unit arithmetic. Its `scale`
 is relative to its formal unit product; its `factor` is the total scale to the
 coherent SI unit. An ordinary `Unit` has an implicit additional scale of one;

{unitx-0.6.0 → unitx-0.6.2}/README.md

@@ -93,6 +93,7 @@ evaluated numerically.
 For unit expressions and explicit construction, import the classes:
 
 ```pycon
+>>> from unitx.factor import Factor
 >>> from unitx.quantity import Quantity
 >>> from unitx.unit import Unit
 >>> Quantity(50, 'cm') == 50 * si.cm
@@ -107,33 +108,65 @@ True
 with the reciprocal unit. Construction preserves the original magnitude and
 its type.
 
-These are directional construction operators: `value * unit` and `value / unit`
-construct a `Quantity`, while `unit * value` and `unit / value` adjust the
-unit's scale and return a `ScaledUnit`. Right-hand numeric scales must be
-positive finite `int`, `Fraction`, `Decimal`, or `float` values; booleans are
-not accepted. Fraction and Decimal scales remain exact. Floats follow Factor's
-denominator limit and may warn or round to zero and fail. A `Factor` or
-`SymbolicConstant` on either side of a unit produces a `ScaledUnit`.
+Multiplication is symmetric: `unit * value` and `value * unit` both construct
+`Quantity` objects and preserve the magnitude's type. Dividing a unit by an
+`int`, `Fraction`, or finite `Decimal` constructs a quantity with an exact
+`Fraction` reciprocal, so `degree / 60` loses no precision. Float divisors use
+native floating-point division without Factor's denominator limit. Booleans
+are not accepted as right-hand numeric operands. A `Factor` or
+`SymbolicConstant` on either side of a unit instead produces a `ScaledUnit`.
 
 ```pycon
 >>> metre = Unit('m')
->>> quantity = 2 * metre
->>> quantity.value, quantity.unit == metre
-(2, True)
->>> double_metre = metre * 2
+>>> metre * 2 == 2 * metre
+True
+>>> (metre * 2).value
+2
+>>> double_metre = metre * Factor(2)
 >>> print(double_metre)
-2 m
+2⋅m
 >>> (3 * double_metre).to('m').value
 6
->>> (3 * (metre / 2)).to('m').value
-Fraction(3, 2)
+>>> arcmin = si.deg / 60
+>>> arcmin.value
+Fraction(1, 60)
+>>> arcmin.to(si.arcmin).value
+Fraction(1, 1)
+
+```
+
+Multiplying a `ScaledUnit` by an ordinary number also constructs a quantity,
+keeping the exact scale in its unit and preserving the supplied magnitude.
+Combining a Unit with a Quantity continues to return a Quantity.
+
+Quantities also accept `Factor` and `SymbolicConstant` operands on either side
+of multiplication or division. Multiplication and right-hand division preserve
+the magnitude and its type, combining the exact factor with the unit instead.
+Left-hand division takes the reciprocal magnitude and unit. Ordinary numeric
+operands continue to act on the magnitude: `q * 2` and `q * Factor(2)` represent
+equal physical quantities but can have different `.value` and `.unit` pairs.
+
+```pycon
+>>> from unitx.factor import PI
+>>> hbar = SI.h / (2 * PI)
+>>> print(hbar)
+6.62607015E-34 J⋅s/(2⋅π)
+>>> hbar.value == SI.h.value
+True
+>>> hbar * (2 * PI) == SI.h
+True
+>>> round(float(hbar.to('J*s').value) / 1e-34, 8)
+1.05457182
 
 ```
 
-Grouping can therefore change the stored magnitude and unit: `(3 * metre) * 2`
-stores magnitude 6 in metres, while `3 * (metre * 2)` stores magnitude 3 in
-double metres. They compare as equal quantities. Combining a Unit with a
-Quantity continues to return a Quantity.
+The local `hbar` above retains the exact scale, whereas predefined `SI.hbar`
+provides its numerical value in ordinary `J*s` units. `.value` is always the
+magnitude paired with `.unit`, including its exact scale. Use
+`.to('J*s').value` to evaluate the local expression in joule seconds;
+conversion involving an irrational factor evaluates it approximately.
+String output combines the scale and formal units into one product, with
+grouped denominator factors and multiplication dots between adjacent numbers.
 
 ## Conversion and arithmetic
 
@@ -216,8 +249,8 @@ True
 
 ```
 
-Multiplying or dividing a unit by a positive numeric scale, `Factor`, or
-`SymbolicConstant` creates a `ScaledUnit`, which preserves an exact additional
+Multiplying or dividing a unit by a `Factor` or `SymbolicConstant` creates a
+`ScaledUnit`, which preserves an exact additional
 scale through unit arithmetic. Its `scale`
 is relative to its formal unit product; its `factor` is the total scale to the
 coherent SI unit. An ordinary `Unit` has an implicit additional scale of one;

{unitx-0.6.0 → unitx-0.6.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = 'hatchling.build'
 
 [project]
 name = 'unitx'
-version = '0.6.0'
+version = '0.6.2'
 description = 'A modern, intuitive Python library for units, quantities, and dimensional analysis.'
 readme = 'README.md'
 requires-python = '>=3.12'

{unitx-0.6.0 → unitx-0.6.2}/src/unitx/factor.py

@@ -398,6 +398,10 @@ class Factor:
         """
         if not compact:
             return str(self._monomial)
+        return str(self._display_monomial())
+
+    def _display_monomial(self) -> Monomial[int | str]:
+        """Collect numeric bases for compact display, without changing exact state."""
         rational, irrational = self.decompose(rationalize_denominator=True)
         display_components: dict[int | str, Fraction] = {}
         if rational.numerator > 1:
@@ -417,7 +421,7 @@ class Factor:
             # Numeric roots use string keys to stay distinct from rational coefficients.
             # Symbol validation and Factor construction prevent collisions with symbols.
             display_components[str(base)] = exponent
-        return str(Monomial._from_dict(display_components))
+        return Monomial._from_dict(display_components)
 
     def __str__(self) -> str:
         return self.format()

{unitx-0.6.0 → unitx-0.6.2}/src/unitx/quantity.py

@@ -7,10 +7,11 @@ from fractions import Fraction
 from typing import Any, Generic, TypeVar, cast, overload
 
 from ._numerics import Fractionable, Magnitude, Number, Real, as_fraction, as_int_if_integral
+from ._unicode import DOT
 from .dimension import DIMENSIONLESS, Dimension
 from .exceptions import DimensionError
-from .factor import ONE, Factor
-from .unit import ScaledUnit, Unit
+from .factor import ONE, Factor, SymbolicConstant
+from .unit import Unit
 
 # Magnitudes are exposed read-only; operations construct new quantities.
 T = TypeVar('T', bound=Magnitude, covariant=True)
@@ -22,7 +23,9 @@ class Quantity(Generic[T]):
     Construction preserves the magnitude's type. Conversion uses Factor's
     scaling rules and can change that type. Arithmetic converts finite Decimal
     operands exactly to Fraction; other magnitudes use native arithmetic.
-    Multiplication or division by a Unit preserves the magnitude unchanged.
+    Multiplication or division by a Unit, Factor, or SymbolicConstant preserves
+    the magnitude unchanged. Exact factors are combined with the unit's scale,
+    while ordinary numeric operands participate in magnitude arithmetic.
 
     Magnitudes must be scalars whose equality returns a bool. NumPy scalars,
     arrays, and NumPy operations are not supported yet; NumPy integration is
@@ -33,9 +36,9 @@ class Quantity(Generic[T]):
     Scalar multiplication and division accept int, float, Fraction, and Decimal.
 
     Type hints preserve the magnitude type at construction and when combining
-    with a Unit. Numeric conversions and arithmetic use unions where the result
-    depends on runtime units or values. In particular, float annotations also
-    accept int inputs, which may produce Fraction after scaling. Custom
+    with a Unit or exact factor. Numeric conversions and arithmetic use unions
+    where the result depends on runtime units or values. In particular, float
+    annotations also accept int inputs, which may produce Fraction after scaling. Custom
     magnitudes retain their arithmetic protocol rather than an assumed Self.
 
     Equality and hashing retain the exact rational coefficient and the unit's
@@ -50,9 +53,9 @@ class Quantity(Generic[T]):
     Powers normalize the exponent once using as_fraction(), just as Unit does,
     and use that exponent for both the magnitude and the unit. Nonintegral
     magnitude powers use native numerical evaluation and can be approximate.
-    str() is readable display and groups units with an explicit scale in
-    parentheses without evaluating that scale. repr() uses a reconstructible
-    Unit expression.
+    str() displays the magnitude followed by the unit's exact product expression
+    without evaluating its scale. Adjacent numeric factors use a multiplication
+    dot. repr() uses a reconstructible Unit expression.
 
     >>> Quantity(1, 'm') + Quantity(50, 'cm')
     Quantity(Fraction(3, 2), Unit('m'))
@@ -106,11 +109,13 @@ class Quantity(Generic[T]):
         return f'{type(self).__name__}({self.value!r}, {self.unit!r})'
 
     def __str__(self) -> str:
-        if isinstance(self.unit, ScaledUnit) and self.unit.scale != ONE:
-            return f'{self.value} ({self.unit})'
-        if self.unit.symbol.startswith('1'):
-            return f'{self.value}{self.unit.symbol[1:]}'
-        return f'{self.value} {self.unit}'
+        unit = str(self.unit)
+        if unit == '1':
+            return str(self.value)
+        if unit.startswith('1/'):
+            return f'{self.value}{unit[1:]}'
+        separator = DOT if unit[0].isdecimal() else ' '
+        return f'{self.value}{separator}{unit}'
 
     def is_dimensionless(self) -> bool:
         return self.dimension is DIMENSIONLESS
@@ -263,7 +268,7 @@ class Quantity(Generic[T]):
         return NotImplemented
 
     @overload
-    def __mul__(self, other: Unit, /) -> Quantity[T]: ...
+    def __mul__(self, other: Unit | Factor | SymbolicConstant, /) -> Quantity[T]: ...
 
     @overload
     def __mul__(self: Quantity[int], other: Quantity[int] | int, /) -> Quantity[int]: ...
@@ -281,7 +286,7 @@ class Quantity(Generic[T]):
             quantity = cast(Quantity[Magnitude], other)
             value = cast(Magnitude, quantity._arithmetic_value)
             return Quantity(self._arithmetic_value * value, self.unit * quantity.unit)
-        if isinstance(other, Unit):
+        if isinstance(other, (Unit, Factor, SymbolicConstant)):
             return Quantity(self.value, self.unit * other)
         if isinstance(other, Fractionable):
             value = cast(Magnitude, Fraction(other) if isinstance(other, Decimal) else other)
@@ -291,7 +296,7 @@ class Quantity(Generic[T]):
     __rmul__ = __mul__
 
     @overload
-    def __truediv__(self, other: Unit, /) -> Quantity[T]: ...
+    def __truediv__(self, other: Unit | Factor | SymbolicConstant, /) -> Quantity[T]: ...
 
     @overload
     def __truediv__(self: Quantity[int], other: Quantity[int] | int, /) -> Quantity[float]: ...
@@ -309,7 +314,7 @@ class Quantity(Generic[T]):
             quantity = cast(Quantity[Magnitude], other)
             value = cast(Magnitude, quantity._arithmetic_value)
             return Quantity(self._arithmetic_value / value, self.unit / quantity.unit)
-        if isinstance(other, Unit):
+        if isinstance(other, (Unit, Factor, SymbolicConstant)):
             return Quantity(self.value, self.unit / other)
         if isinstance(other, Fractionable):
             value = cast(Magnitude, Fraction(other) if isinstance(other, Decimal) else other)
@@ -317,18 +322,22 @@ class Quantity(Generic[T]):
         return NotImplemented
 
     @overload
-    def __rtruediv__(self: Quantity[int], other: Unit | int, /) -> Quantity[float]: ...
+    def __rtruediv__(
+        self: Quantity[int], other: Unit | Factor | SymbolicConstant | int, /
+    ) -> Quantity[float]: ...
 
     @overload
     def __rtruediv__[N: Fractionable](
-        self: Quantity[N], other: Unit | Fractionable, /
+        self: Quantity[N], other: Unit | Factor | SymbolicConstant | Fractionable, /
     ) -> Quantity[Real]: ...
 
     @overload
-    def __rtruediv__(self, other: Unit | Fractionable, /) -> Quantity[Magnitude]: ...
+    def __rtruediv__(
+        self, other: Unit | Factor | SymbolicConstant | Fractionable, /
+    ) -> Quantity[Magnitude]: ...
 
     def __rtruediv__(self, other: object, /) -> Quantity[Magnitude]:
-        if isinstance(other, Unit):
+        if isinstance(other, (Unit, Factor, SymbolicConstant)):
             return Quantity(1 / self._arithmetic_value, other / self.unit)
         if isinstance(other, Fractionable):
             value = Fraction(other) if isinstance(other, Decimal) else other

{unitx-0.6.0 → unitx-0.6.2}/src/unitx/unit.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+from decimal import Decimal
+from fractions import Fraction
 from typing import TYPE_CHECKING, Self, overload
 
 from ._numerics import Fractionable, Magnitude, as_fraction
@@ -32,18 +34,16 @@ class Unit:
     exponents remain exact; float exponents may be approximated with an
     `InexactFloatWarning`.
 
-    A supported scalar magnitude multiplied by a Unit constructs a Quantity
-    with that unit. Dividing a magnitude by a Unit constructs a Quantity with
-    the reciprocal unit. Both preserve the original magnitude and its type
-    without scaling. A Factor or SymbolicConstant instead constructs a
-    ScaledUnit and preserves its exact scale. Multiplying or dividing a Unit
-    by a positive finite int, Fraction, Decimal, or float instead adjusts its
-    scale and returns a ScaledUnit. Factor and SymbolicConstant operands on
-    the right also adjust the scale. Thus 2 * unit constructs a Quantity,
-    while unit * 2 constructs a ScaledUnit. Float scales follow Factor's
-    approximation and warning rules; prefer Fraction or Decimal for exact
-    scales. NumPy scalars, arrays, and NumPy operations are not supported yet;
-    NumPy integration is planned.
+    Multiplying a Unit by an int, Fraction, Decimal, or float constructs a
+    Quantity, just as multiplying the magnitude by the Unit does. Construction
+    preserves the magnitude and its type. Dividing a magnitude by a Unit also
+    preserves it and uses the reciprocal unit. Dividing a Unit by an int,
+    Fraction, or finite Decimal constructs a Quantity with an exact Fraction
+    reciprocal; float divisors use native floating-point division. Booleans
+    are not accepted as right-hand numeric operands.
+    Factor and SymbolicConstant operands instead construct a ScaledUnit on
+    either side and preserve their exact scale. NumPy scalars, arrays, and
+    NumPy operations are not supported yet; NumPy integration is planned.
 
     Equality and hashing compare canonical unit identities and rational
     exponents, regardless of factor insertion order. Aliases compare equal,
@@ -133,7 +133,10 @@ class Unit:
         return self._monomial == other._monomial
 
     @overload
-    def __mul__(self, other: Fractionable | SymbolicConstant | Factor) -> ScaledUnit: ...
+    def __mul__[T: Fractionable](self, other: T) -> Quantity[T]: ...
+
+    @overload
+    def __mul__(self, other: SymbolicConstant | Factor) -> ScaledUnit: ...
 
     @overload
     def __mul__(self, other: ScaledUnit) -> ScaledUnit: ...
@@ -141,8 +144,14 @@ class Unit:
     @overload
     def __mul__(self, other: Unit) -> Unit: ...
 
-    def __mul__(self, other: object) -> Unit:
-        if isinstance(other, Fractionable | SymbolicConstant | Factor):
+    def __mul__(self, other: object) -> Unit | Quantity[Magnitude]:
+        from .quantity import Quantity
+
+        if isinstance(other, Fractionable):
+            if isinstance(other, bool):
+                raise TypeError('Boolean numeric operands are not supported.')
+            return Quantity(other, self)
+        if isinstance(other, SymbolicConstant | Factor):
             scale = other if isinstance(other, Factor) else Factor(other)
             return ScaledUnit(self, scale)
         if not isinstance(other, Unit):
@@ -150,7 +159,13 @@ class Unit:
         return Unit._from_monomial(self._monomial * other._monomial)
 
     @overload
-    def __truediv__(self, other: Fractionable | SymbolicConstant | Factor) -> ScaledUnit: ...
+    def __truediv__(self, other: int | Fraction | Decimal) -> Quantity[Fraction]: ...
+
+    @overload
+    def __truediv__(self, other: float) -> Quantity[float]: ...
+
+    @overload
+    def __truediv__(self, other: SymbolicConstant | Factor) -> ScaledUnit: ...
 
     @overload
     def __truediv__(self, other: ScaledUnit) -> ScaledUnit: ...
@@ -158,8 +173,15 @@ class Unit:
     @overload
     def __truediv__(self, other: Unit) -> Unit: ...
 
-    def __truediv__(self, other: object) -> Unit:
-        if isinstance(other, Fractionable | SymbolicConstant | Factor):
+    def __truediv__(self, other: object) -> Unit | Quantity[Magnitude]:
+        from .quantity import Quantity
+
+        if isinstance(other, Fractionable):
+            if isinstance(other, bool):
+                raise TypeError('Boolean numeric operands are not supported.')
+            reciprocal = 1 / other if isinstance(other, float) else 1 / Fraction(other)
+            return Quantity(reciprocal, self)
+        if isinstance(other, SymbolicConstant | Factor):
             scale = 1 / other if isinstance(other, Factor) else 1 / Factor(other)
             return ScaledUnit(self, scale)
         if not isinstance(other, Unit):
@@ -284,7 +306,8 @@ class ScaledUnit(Unit):
     involving a ScaledUnit return ScaledUnit, even when the scale becomes one.
     Equality compares the formal product and explicit scale, so a scale of one
     compares equal to the unscaled Unit. `symbol` describes only the product;
-    str() also includes its scale, and repr() reconstructs both.
+    str() combines its compact exact scale and formal units into a single
+    product with a grouped denominator, and repr() reconstructs both.
 
     Copying and pickling preserve the formal units and exact scale. Restoring
     a unit requires its referenced unit definitions to be registered.
@@ -293,7 +316,7 @@ class ScaledUnit(Unit):
     >>> minute
     ScaledUnit('s', scale=Factor.from_dict({2: 2, 3: 1, 5: 1}))
     >>> str(minute)
-    '60 s'
+    '60⋅s'
     >>> minute == Unit('s')
     False
     """
@@ -336,9 +359,11 @@ class ScaledUnit(Unit):
     def __str__(self) -> str:
         if self.scale == ONE:
             return self.symbol
-        if self.symbol.startswith('1'):
-            return f'{self.scale}{self.symbol[1:]}'
-        return f'{self.scale} {self.symbol}'
+        components: dict[SingleUnit | int | str, Fraction] = dict(
+            self.scale._display_monomial().components()
+        )
+        components.update(self._monomial.components())
+        return str(Monomial(components))
 
     def __hash__(self) -> int:
         if self.scale == ONE:
@@ -351,19 +376,32 @@ class ScaledUnit(Unit):
         other_scale = other.scale if isinstance(other, ScaledUnit) else ONE
         return self._monomial == other._monomial and self.scale == other_scale
 
-    def __mul__(self, other: Unit | Fractionable | SymbolicConstant | Factor) -> ScaledUnit:
+    @overload
+    def __mul__[T: Fractionable](self, other: T) -> Quantity[T]: ...
+
+    @overload
+    def __mul__(self, other: Unit | SymbolicConstant | Factor) -> ScaledUnit: ...
+
+    def __mul__(self, other: object) -> ScaledUnit | Quantity[Magnitude]:
         if isinstance(other, Fractionable | SymbolicConstant | Factor):
-            scale = other if isinstance(other, Factor) else Factor(other)
-            return ScaledUnit(self, scale)
+            return super().__mul__(other)
         if not isinstance(other, Unit):
             return NotImplemented
         scale = self.scale * other.scale if isinstance(other, ScaledUnit) else self.scale
         return ScaledUnit._from_monomial(self._monomial * other._monomial, scale)
 
-    def __truediv__(self, other: Unit | Fractionable | SymbolicConstant | Factor) -> ScaledUnit:
+    @overload
+    def __truediv__(self, other: int | Fraction | Decimal) -> Quantity[Fraction]: ...
+
+    @overload
+    def __truediv__(self, other: float) -> Quantity[float]: ...
+
+    @overload
+    def __truediv__(self, other: Unit | SymbolicConstant | Factor) -> ScaledUnit: ...
+
+    def __truediv__(self, other: object) -> ScaledUnit | Quantity[Magnitude]:
         if isinstance(other, Fractionable | SymbolicConstant | Factor):
-            scale = 1 / other if isinstance(other, Factor) else 1 / Factor(other)
-            return ScaledUnit(self, scale)
+            return super().__truediv__(other)
         if not isinstance(other, Unit):
             return NotImplemented
         scale = self.scale / other.scale if isinstance(other, ScaledUnit) else self.scale

{unitx-0.6.0 → unitx-0.6.2}/tests/test_quantity.py

@@ -38,9 +38,14 @@ def test_quantity_str(unit: str, expected: str) -> None:
 @pytest.mark.parametrize(
     ('unit', 'expected'),
     [
-        (Factor(2) * Unit(), '3 (2)'),
-        (Factor(2) / Unit('s'), '3 (2/s)'),
-        (Factor(60) * Unit('s'), '3 (60 s)'),
+        (Factor(2) * Unit(), '3⋅2'),
+        (Factor(2) / Unit('s'), '3⋅2/s'),
+        (Factor(60) * Unit('s'), '3⋅60⋅s'),
+        (Unit('J*s') / (2 * PI), '3 J⋅s/(2⋅π)'),
+        (Unit('1/s') / (2 * PI), '3/(2⋅π⋅s)'),
+        (Unit() / PI, '3/π'),
+        (PI * Unit('s'), '3 π⋅s'),
+        (Factor(12) * Unit('s'), '3⋅12⋅s'),
         (ScaledUnit(Unit(), ONE), '3'),
         (ScaledUnit(Unit('1/s'), ONE), '3/s'),
     ],
@@ -52,6 +57,54 @@ def test_quantity_scaled_str(unit: ScaledUnit, expected: str) -> None:
     assert (quantity.value, quantity.unit, quantity.unit.factor) == before
 
 
+@pytest.mark.parametrize('value', [0, -2, 2**60 + 1, 0.1, Fraction(3, 7), Decimal('1.2345'), 2j])
+@pytest.mark.parametrize('unit', [Unit('cm'), ScaledUnit('cm', PI), Unit('km/m')])
+@pytest.mark.parametrize('factor', [ONE, Factor(2), PI, 1 / (2 * PI), Factor(2) ** Fraction(1, 2)])
+def test_quantity_factor_operations(value, unit: Unit, factor) -> None:
+    quantity = Quantity(value, unit)
+    before = (repr(quantity), hash(quantity))
+    with localcontext() as context:
+        context.prec = 2
+        products = (quantity * factor, factor * quantity)
+        quotient = quantity / factor
+    for result in products:
+        assert result.value is value
+        assert result.unit == unit * factor
+        assert (result / factor).unit == unit
+        assert result == value * (unit * factor)
+    assert quotient.value is value
+    assert quotient.unit == unit / factor
+    assert (quotient * factor) == quantity
+    assert hash(quotient * factor) == hash(quantity)
+    assert {quantity: 'found'}[quotient * factor] == 'found'
+    assert (repr(quantity), hash(quantity)) == before
+
+
+@pytest.mark.parametrize('value', [2, Fraction(3, 7), Decimal('1.2345'), 2j])
+@pytest.mark.parametrize('factor', [Factor(2), PI])
+def test_quantity_factor_reciprocal(value, factor) -> None:
+    quantity = Quantity(value, ScaledUnit('cm', PI))
+    result = factor / quantity
+    reciprocal = 1 / quantity
+    assert result.value == reciprocal.value
+    assert type(result.value) is type(reciprocal.value)
+    assert result.unit == factor / quantity.unit
+    assert result == reciprocal * factor
+
+
+def test_quantity_factor_scaling() -> None:
+    quantity = Quantity(3, 'cm')
+    numeric = quantity * 2
+    exact = quantity * Factor(2)
+    assert numeric.value == 6
+    assert numeric.unit == quantity.unit
+    assert exact.value == 3
+    assert exact.unit == ScaledUnit('cm', Factor(2))
+    assert exact == numeric
+    assert hash(exact) == hash(numeric)
+    assert (exact.to('m').to(exact.unit)).value == exact.value
+
+
 def test_quantity_scaled_operations() -> None:
     minute = Factor(60) * Unit('s')
     quantity = Quantity(1, minute)

{unitx-0.6.0 → unitx-0.6.2}/tests/test_si.py

@@ -132,6 +132,11 @@ def test_si_defining_constants(attribute: str, target: str, value: str) -> None:
     assert result.value == Decimal(value)
 
 
+def test_si_hbar_value() -> None:
+    assert SI.hbar.unit == SI.h.unit
+    assert SI.hbar.value == pytest.approx(1.0545718176461565e-34, rel=1e-15, abs=0)
+
+
 @pytest.mark.parametrize(
     ('attribute', 'target'),
     [('Phi0', si.Wb), ('G0', si.S), ('RK', si.ohm), ('a0', si.m), ('lambdaC', si.m), ('Eh', si.J)],

{unitx-0.6.0 → unitx-0.6.2}/tests/test_unit.py

@@ -54,7 +54,7 @@ def test_unit_quantity_construction(value, unit: Unit, reciprocal: Unit) -> None
 @pytest.mark.parametrize('unit', [Unit('cm'), ScaledUnit('cm', scale=PI), Unit('km/m')])
 @pytest.mark.parametrize(
     'value',
-    [1, 2, Fraction(7, 3), Decimal('1.2345'), 0.5, Factor(2), PI, Factor(2) ** Fraction(1, 2)],
+    [Factor(2), PI, Factor(2) ** Fraction(1, 2)],
 )
 def test_unit_numeric_scaling(unit: Unit, value, operation) -> None:
     before = (repr(unit), unit.factor, hash(unit))
@@ -74,12 +74,17 @@ def test_unit_numeric_scaling(unit: Unit, value, operation) -> None:
 def test_unit_scaling_cancellation() -> None:
     unit = Unit('cm')
     scale = 2**54
-    scaled = unit * scale
+    scaled = unit * Factor(scale)
     assert scaled.scale.value == scale
     assert (scaled / Unit('s')).factor == Factor(Fraction(scale, 100))
     assert ((scaled ** Fraction(1, 2)) ** 2) == scaled
     assert (PI * unit / PI) == unit
-    for result in (scaled / scale, unit / scale * scale, unit * 1, unit / 1):
+    for result in (
+        scaled / Factor(scale),
+        unit / Factor(scale) * Factor(scale),
+        unit * ONE,
+        unit / ONE,
+    ):
         assert type(result) is ScaledUnit
         assert result.scale == ONE
         assert result.factor == unit.factor
@@ -96,17 +101,17 @@ def test_unit_quantity_grouping() -> None:
     assert type(left) is type(right) is Quantity
     assert left.value == 6
     assert left.unit is metre
-    assert right.value == 3
-    assert right.unit == ScaledUnit(metre, Factor(2))
+    assert right.value == 6
+    assert right.unit is metre
     assert left == right
     assert hash(left) == hash(right)
     half = 3 * (metre / 2)
-    assert half.value == 3
+    assert half.value == Fraction(3, 2)
     assert half.to(metre).value == Fraction(3, 2)
     assert type(half.to(metre).value) is Fraction
 
 
-@pytest.mark.parametrize('unit', [Unit('cm'), Unit('cm') * 2])
+@pytest.mark.parametrize('unit', [Unit('cm'), Factor(2) * Unit('cm')])
 def test_unit_quantity_dispatch(unit: Unit) -> None:
     quantity = Quantity(Fraction(3, 2), 's')
     for product in (unit * quantity, quantity * unit):
@@ -119,28 +124,50 @@ def test_unit_quantity_dispatch(unit: Unit) -> None:
     assert quotient.unit == unit / quantity.unit
 
 
-@pytest.mark.parametrize('operation', [operator.mul, operator.truediv])
-@pytest.mark.parametrize('unit', [Unit('cm'), Unit('cm') * 2])
-def test_unit_scaling_warning(unit: Unit, operation) -> None:
-    with pytest.warns(InexactFloatWarning, match='0.1') as recorded:
-        result = operation(unit, 0.1)
-    assert len(recorded) == 1
-    assert recorded[0].filename == __file__
-    assert recorded[0].lineno == test_unit_scaling_warning.__code__.co_firstlineno + 4
-    assert result == operation(unit, Fraction(1, 10))
+@pytest.mark.parametrize('unit', [Unit('cm'), ScaledUnit('cm', PI)])
+@pytest.mark.parametrize(
+    'value', [0, -2, 2**60 + 1, Fraction(7, 3), Decimal('1.2345'), 0.1, 1e-300]
+)
+def test_unit_multiplication_symmetry(unit: Unit, value) -> None:
     with warnings.catch_warnings():
         warnings.simplefilter('error', InexactFloatWarning)
-        with pytest.raises(InexactFloatWarning, match='0.1'):
-            operation(unit, 0.1)
+        left, right = value * unit, unit * value
+    assert type(left) is type(right) is Quantity
+    assert left.value is right.value is value
+    assert left.unit is right.unit is unit
+    assert left == right
+    assert hash(left) == hash(right)
 
 
-@pytest.mark.parametrize('operation', [operator.mul, operator.truediv])
-def test_unit_scaling_underflow(operation) -> None:
-    unit = Unit('m')
-    with pytest.warns(InexactFloatWarning, match='1e-10') as recorded:
-        with pytest.raises(ValueError, match='Factor must be positive'):
-            operation(unit, 1e-10)
-    assert len(recorded) == 1
+@pytest.mark.parametrize('unit', [Unit('deg'), ScaledUnit('deg', PI)])
+@pytest.mark.parametrize('divisor', [60, 2**60 + 1, -60, Fraction(7, 3), Decimal('1.2345')])
+def test_unit_division_exact(unit: Unit, divisor) -> None:
+    with localcontext() as context:
+        context.prec = 2
+        result = unit / divisor
+    assert type(result) is Quantity
+    assert type(result.value) is Fraction
+    assert result.value == 1 / Fraction(divisor)
+    assert result.unit is unit
+    assert (result * divisor) == 1 * unit
+
+
+def test_unit_division_arcminute() -> None:
+    degree = Unit('deg')
+    arcmin = degree / 60
+    assert arcmin.value == Fraction(1, 60)
+    assert arcmin.unit is degree
+    assert arcmin.to('arcmin').value == 1
+    assert arcmin.to('arcmin').to(degree).value == Fraction(1, 60)
+
+
+@pytest.mark.parametrize('value', [0.1, 1e-300, -0.5])
+def test_unit_division_float(value: float) -> None:
+    with warnings.catch_warnings():
+        warnings.simplefilter('error', InexactFloatWarning)
+        result = Unit('m') / value
+    assert type(result.value) is float
+    assert result.value == 1 / value
 
 
 @pytest.mark.parametrize(
@@ -417,37 +444,18 @@ def test_unit_invalid_operands(value: object) -> None:
         unit / value  # pyright: ignore[reportUnusedExpression, reportOperatorIssue]
 
 
-@pytest.mark.parametrize('unit', [Unit('m'), ScaledUnit('m', scale=Factor(2))])
-@pytest.mark.parametrize('value', [0, -2, 0.0, -0.5, Fraction(-1, 2), Decimal('-1.5')])
-@pytest.mark.parametrize('operation', [operator.mul, operator.truediv])
-def test_unit_invalid_scale(unit: Unit, value, operation) -> None:
-    before = (repr(unit), unit.factor, hash(unit))
-    with pytest.raises(ValueError, match='Factor must be positive'):
-        operation(unit, value)
-    assert (repr(unit), unit.factor, hash(unit)) == before
+@pytest.mark.parametrize('unit', [Unit('m'), ScaledUnit('m', Factor(2))])
+@pytest.mark.parametrize('divisor', [0, 0.0, Fraction(0), Decimal(0)])
+def test_unit_division_invalid(unit: Unit, divisor) -> None:
+    with pytest.raises(ZeroDivisionError):
+        unit / divisor
 
 
-@pytest.mark.parametrize('unit', [Unit('m'), Unit('m') * 2])
+@pytest.mark.parametrize('unit', [Unit('m'), ScaledUnit('m', Factor(2))])
 @pytest.mark.parametrize('operation', [operator.mul, operator.truediv])
 @pytest.mark.parametrize('value', [True, False])
-def test_unit_invalid_boolean_scale(unit: Unit, value: bool, operation) -> None:
-    with pytest.raises(TypeError, match='Factor must be a number'):
-        operation(unit, value)
-
-
-@pytest.mark.parametrize('unit', [Unit('m'), Unit('m') * 2])
-@pytest.mark.parametrize('operation', [operator.mul, operator.truediv])
-@pytest.mark.parametrize('value', [float('nan'), Decimal('NaN')])
-def test_unit_invalid_nan_scale(unit: Unit, value, operation) -> None:
-    with pytest.raises(ValueError, match='cannot convert NaN'):
-        operation(unit, value)
-
-
-@pytest.mark.parametrize('unit', [Unit('m'), Unit('m') * 2])
-@pytest.mark.parametrize('operation', [operator.mul, operator.truediv])
-@pytest.mark.parametrize('value', [float('inf'), -float('inf'), Decimal('Infinity')])
-def test_unit_invalid_infinite_scale(unit: Unit, value, operation) -> None:
-    with pytest.raises(OverflowError, match='cannot convert Infinity'):
+def test_unit_invalid_boolean(unit: Unit, value: bool, operation) -> None:
+    with pytest.raises(TypeError, match='Boolean numeric operands'):
         operation(unit, value)
 
 
@@ -567,11 +575,16 @@ def test_scaled_unit_exact_power() -> None:
 @pytest.mark.parametrize(
     ('base', 'scale', 'expected'),
     [
-        ('s', Factor(60), '60 s'),
+        ('s', Factor(60), '60⋅s'),
         ('', Factor(2), '2'),
         ('1/s', Factor(2), '2/s'),
         ('1/(m*s)', Factor(2), '2/(m⋅s)'),
         ('cm', ONE, 'cm'),
+        ('J*s', 1 / (2 * PI), 'J⋅s/(2⋅π)'),
+        ('m/s', PI / 180, 'π⋅m/(180⋅s)'),
+        ('1/(m*s)', 1 / (2 * PI), '1/(2⋅π⋅m⋅s)'),
+        ('s', Factor(5040) ** Fraction(1, 2), '12⋅35¹ᐟ²⋅s'),
+        ('m^(1/2)/s', PI ** Fraction(1, 2), 'π¹ᐟ²⋅m¹ᐟ²/s'),
     ],
 )
 def test_scaled_unit_str(base: str, scale: Factor, expected: str) -> None:
@@ -597,7 +610,7 @@ def test_scaled_unit_repr_roundtrip(text: str, scale: Factor | SymbolicConstant)
         ScaledUnit('cm', scale=ONE),
         ScaledUnit('cm^(1/2)/s', scale=PI / 180),
         ScaledUnit('', scale=Factor(2) ** Fraction(1, 2)),
-        Unit('cm') * 3 / 2,
+        Unit('cm') * Factor(Fraction(3, 2)),
     ],
 )
 def test_scaled_unit_copy(unit: ScaledUnit, rebuild) -> None:
@@ -613,7 +626,9 @@ def test_scaled_unit_copy(unit: ScaledUnit, rebuild) -> None:
 
 
 @pytest.mark.parametrize('protocol', range(2, pickle.HIGHEST_PROTOCOL + 1))
-@pytest.mark.parametrize('unit', [ScaledUnit('cm^(1/2)/s', scale=PI / 180), Unit('cm') * 3 / 2])
+@pytest.mark.parametrize(
+    'unit', [ScaledUnit('cm^(1/2)/s', scale=PI / 180), Unit('cm') * Factor(Fraction(3, 2))]
+)
 def test_scaled_unit_pickle(protocol: int, unit: ScaledUnit) -> None:
     rebuilt = pickle.loads(pickle.dumps(unit, protocol=protocol))
     assert type(rebuilt) is ScaledUnit

{unitx-0.6.0 → unitx-0.6.2}/tests/typing/check_quantity.py

@@ -84,14 +84,26 @@ def test_scaled_unit_construction() -> None:
 
 
 def test_unit_numeric_scaling(unit: Unit, scaled: ScaledUnit) -> None:
-    for value in (2, 0.5, Fraction(3, 2), Decimal('1.5'), Factor(2), PI):
+    for value in (Factor(2), PI):
         assert_type(unit * value, ScaledUnit)
         assert_type(unit / value, ScaledUnit)
         assert_type(scaled * value, ScaledUnit)
         assert_type(scaled / value, ScaledUnit)
-    assert_type(unit * 2 / 3, ScaledUnit)
+    assert_type(unit * 2, Quantity[int])
+    assert_type(unit * 0.1, Quantity[float])
+    assert_type(unit * Fraction(1, 3), Quantity[Fraction])
+    assert_type(unit * Decimal('0.1'), Quantity[Decimal])
+    assert_type(scaled * 2, Quantity[int])
+    assert_type(scaled * Decimal('0.1'), Quantity[Decimal])
+    assert_type(unit / 60, Quantity[Fraction])
+    assert_type(unit / Fraction(3, 2), Quantity[Fraction])
+    assert_type(unit / Decimal('0.1'), Quantity[Fraction])
+    assert_type(unit / 0.1, Quantity[float])
+    assert_type(scaled / 60, Quantity[Fraction])
+    assert_type(scaled / 0.1, Quantity[float])
+    assert_type(unit * 2 / 3, Quantity[float])
     assert_type(3 * (unit * 2), Quantity[int])
-    assert_type(Decimal(3) * (unit / 2), Quantity[Decimal])
+    assert_type(Decimal(3) * (unit / 2), Quantity[Real])
     assert_type(Factor(2) * unit, ScaledUnit)
     assert_type(PI * scaled, ScaledUnit)
     assert_type(unit * Quantity(2, 's'), Quantity[int])
@@ -131,6 +143,19 @@ def test_quantity_unit_operations[T: Magnitude](value: T) -> Quantity[T]:
     return quantity
 
 
+def test_quantity_factor_operations[T: Magnitude](value: T) -> Quantity[T]:
+    quantity = Quantity(value, 'm')
+    for factor in (Factor(2), PI):
+        assert_type(quantity * factor, Quantity[T])
+        assert_type(factor * quantity, Quantity[T])
+        assert_type(quantity / factor, Quantity[T])
+        assert_type(factor / quantity, Quantity[Magnitude])
+        assert_type(Factor(2) / Quantity(2, 's'), Quantity[float])
+        assert_type(PI / Quantity(Decimal(2), 's'), Quantity[Real])
+    assert_type(Quantity(Decimal(2), 's') / (2 * PI), Quantity[Decimal])
+    return quantity
+
+
 def test_quantity_numeric_operations() -> None:
     integer = Quantity(1, 'm')
     rational = Quantity(Fraction(1), 'm')

{unitx-0.6.0 → unitx-0.6.2}/tests/typing/check_si.py

@@ -20,5 +20,6 @@ def test_si_unit_types() -> None:
 def test_si_constant_types() -> None:
     assert_type(SI.c, Quantity[int])
     assert_type(SI.h, Quantity[Decimal])
+    assert_type(SI.hbar, Quantity[Real])
     assert_type(SI.e, Quantity[Decimal])
     assert_type(SI.h.to(si.J * si.s), Quantity[Real])