ucon 0.3.1rc1__py3-none-any.whl

tests/ucon/test_unit.py

@@ -0,0 +1,143 @@
+
+
+from unittest import TestCase
+
+from ucon.dimension import Dimension
+from ucon.unit import Unit
+
+
+class TestUnit(TestCase):
+
+    unit_name = 'second'
+    unit_type = 'time'
+    unit_aliases = ('seconds', 'secs', 's', 'S')
+    unit = Unit(*unit_aliases, name=unit_name, dimension=Dimension.time)
+
+    def test___repr__(self):
+        self.assertEqual(f'<{self.unit_type} | {self.unit_name}>', str(self.unit))
+
+
+class TestUnitEdgeCases(TestCase):
+
+    # --- Initialization & representation -----------------------------------
+
+    def test_default_unit_is_dimensionless(self):
+        u = Unit()
+        self.assertEqual(u.dimension, Dimension.none)
+        self.assertEqual(u.name, '')
+        self.assertEqual(u.aliases, ())
+        self.assertEqual(u.shorthand, '')
+        self.assertEqual(repr(u), '<none>')
+
+    def test_unit_with_aliases_and_name(self):
+        u = Unit('m', 'M', name='meter', dimension=Dimension.length)
+        self.assertEqual(u.shorthand, 'm')
+        self.assertIn('m', u.aliases)
+        self.assertIn('M', u.aliases)
+        self.assertIn('length', repr(u))
+        self.assertIn('meter', repr(u))
+
+    def test_hash_and_equality_consistency(self):
+        u1 = Unit('m', name='meter', dimension=Dimension.length)
+        u2 = Unit('m', name='meter', dimension=Dimension.length)
+        u3 = Unit('s', name='second', dimension=Dimension.time)
+        self.assertEqual(u1, u2)
+        self.assertEqual(hash(u1), hash(u2))
+        self.assertNotEqual(u1, u3)
+        self.assertNotEqual(hash(u1), hash(u3))
+
+    def test_units_with_same_name_but_different_dimension_not_equal(self):
+        u1 = Unit(name='amp', dimension=Dimension.current)
+        u2 = Unit(name='amp', dimension=Dimension.time)
+        self.assertNotEqual(u1, u2)
+
+    # --- generate_name edge cases -----------------------------------------
+
+    def test_generate_name_both_have_shorthand(self):
+        u1 = Unit('m', name='meter', dimension=Dimension.length)
+        u2 = Unit('s', name='second', dimension=Dimension.time)
+        result = u1.generate_name(u2, '*')
+        self.assertEqual(result, '(m*s)')
+
+    def test_generate_name_missing_left_shorthand(self):
+        u1 = Unit(name='unitless', dimension=Dimension.none)
+        u2 = Unit('s', name='second', dimension=Dimension.time)
+        self.assertEqual(u1.generate_name(u2, '/'), 'second')
+
+    def test_generate_name_missing_right_shorthand(self):
+        u1 = Unit('m', name='meter', dimension=Dimension.length)
+        u2 = Unit(name='none', dimension=Dimension.none)
+        self.assertEqual(u1.generate_name(u2, '*'), 'meter')
+
+    def test_generate_name_no_aliases_on_either_side(self):
+        u1 = Unit(name='foo', dimension=Dimension.length)
+        u2 = Unit(name='bar', dimension=Dimension.time)
+        self.assertEqual(u1.generate_name(u2, '*'), '(foo*bar)')
+
+    # --- arithmetic behavior ----------------------------------------------
+
+    def test_multiplication_produces_composite_unit(self):
+        m = Unit('m', name='meter', dimension=Dimension.length)
+        s = Unit('s', name='second', dimension=Dimension.time)
+        v = m / s
+        self.assertIsInstance(v, Unit)
+        self.assertEqual(v.dimension, Dimension.velocity)
+        self.assertIn('/', v.name)
+
+    def test_division_with_dimensionless_denominator_returns_self(self):
+        m = Unit('m', name='meter', dimension=Dimension.length)
+        none = Unit(name='none', dimension=Dimension.none)
+        result = m / none
+        self.assertEqual(result, m)
+
+    def test_division_of_identical_units_returns_dimensionless(self):
+        m1 = Unit('m', name='meter', dimension=Dimension.length)
+        m2 = Unit('m', name='meter', dimension=Dimension.length)
+        result = m1 / m2
+        self.assertEqual(result.dimension, Dimension.none)
+        self.assertEqual(result.name, '')
+
+    def test_multiplying_with_dimensionless_returns_self(self):
+        m = Unit('m', name='meter', dimension=Dimension.length)
+        none = Unit(name='none', dimension=Dimension.none)
+        result = m * none
+        self.assertEqual(result.dimension, Dimension.length)
+        self.assertIn('m', result.name)
+
+    def test_invalid_dimension_combinations_raise_value_error(self):
+        m = Unit('m', name='meter', dimension=Dimension.length)
+        c = Unit('C', name='coulomb', dimension=Dimension.charge)
+        # The result of dividing these is undefined (no such Dimension)
+        with self.assertRaises(ValueError):
+            _ = m / c
+        with self.assertRaises(ValueError):
+            _ = c * m
+
+    # --- equality, hashing, immutability ----------------------------------
+
+    def test_equality_with_non_unit(self):
+        with self.assertRaises(TypeError):
+            Unit('m', name='meter', dimension=Dimension.length) == 'meter'
+
+    def test_hash_stability_in_collections(self):
+        m1 = Unit('m', name='meter', dimension=Dimension.length)
+        s = set([m1])
+        self.assertIn(Unit('m', name='meter', dimension=Dimension.length), s)
+
+    def test_operations_do_not_mutate_operands(self):
+        m = Unit('m', name='meter', dimension=Dimension.length)
+        s = Unit('s', name='second', dimension=Dimension.time)
+        _ = m / s
+        self.assertEqual(m.dimension, Dimension.length)
+        self.assertEqual(s.dimension, Dimension.time)
+
+    # --- operator edge cases ----------------------------------------------
+
+    def test_generate_name_handles_empty_names_and_aliases(self):
+        a = Unit()
+        b = Unit()
+        self.assertEqual(a.generate_name(b, '*'), '')
+
+    def test_repr_contains_dimension_name_even_without_name(self):
+        u = Unit(dimension=Dimension.force)
+        self.assertIn('force', repr(u))

tests/ucon/test_units.py

@@ -0,0 +1,21 @@
+
+
+from unittest import TestCase
+
+from ucon import units
+from ucon.dimension import Dimension
+from ucon.unit import Unit
+
+
+class TestUnits(TestCase):
+
+    def test_has_expected_basic_units(self):
+        expected_basic_units = {'none', 'volt', 'liter', 'gram', 'second', 'kelvin', 'mole', 'coulomb'}
+        missing = {name for name in expected_basic_units if not units.have(name)}
+        assert not missing, f"Missing expected units: {missing}"
+
+    def test___truediv__(self):
+        self.assertEqual(units.none, units.gram / units.gram)
+        self.assertEqual(units.gram, units.gram / units.none)
+
+        self.assertEqual(Unit(name='(g/L)', dimension=Dimension.density), units.gram / units.liter)

ucon/__init__.py

@@ -0,0 +1,49 @@
+"""
+ucon
+====
+
+*ucon* (Unit Conversion & Dimensional Analysis) is a lightweight,
+introspective library for reasoning about physical quantities.
+
+Unlike conventional unit libraries that focus purely on arithmetic convenience,
+*ucon* models the **semantics** of measurement-—exposing the algebra of
+dimensions and the structure of compound units.
+
+Overview
+--------
+*ucon* is organized into a small set of composable modules:
+
+- :mod:`ucon.dimension` — defines the algebra of physical dimensions using
+  exponent vectors. Provides the foundation for all dimensional reasoning.
+- :mod:`ucon.unit` — defines the :class:`Unit` abstraction, representing a
+  measurable quantity with an associated dimension, factor, and offset.
+- :mod:`ucon.core` — implements numeric handling via :class:`Number`,
+  :class:`Scale`, and :class:`Ratio`, along with unified conversion logic.
+- :mod:`ucon.units` — declares canonical SI base and derived units for immediate use.
+
+Design Philosophy
+-----------------
+*ucon* treats unit conversion not as a lookup problem but as an **algebra**:
+
+- **Dimensional Algebra** — all physical quantities are represented as
+  exponent vectors over the seven SI bases, ensuring strict composability.
+- **Explicit Semantics** — units, dimensions, and scales are first-class
+  objects, not strings or tokens.
+- **Unified Conversion Model** — all conversions are expressed through one
+  data-driven framework that is generalizable to arbitrary unit systems.
+"""
+from ucon import units
+from ucon.unit import Unit
+from ucon.core import Exponent, Number, Scale, Ratio
+from ucon.dimension import Dimension
+
+
+__all__ = [
+    'Exponent',
+    'Dimension',
+    'Number',
+    'Ratio',
+    'Scale',
+    'Unit',
+    'units',
+]

ucon/core.py

@@ -0,0 +1,293 @@
+"""
+ucon.core
+==========
+
+Implements the **quantitative core** of the *ucon* system — the machinery that
+manages numeric quantities, scaling prefixes, and dimensional relationships.
+
+Classes
+-------
+- :class:`Exponent` — Represents an exponential base/power pair (e.g., 10³).
+- :class:`Scale` — Enumerates SI and binary magnitude prefixes (kilo, milli, etc.).
+- :class:`Number` — Couples a numeric value with a unit and scale.
+- :class:`Ratio` — Represents a ratio between two :class:`Number` objects.
+
+Together, these classes allow full arithmetic, conversion, and introspection
+of physical quantities with explicit dimensional semantics.
+"""
+from enum import Enum
+from functools import reduce, total_ordering
+from math import log2
+from math import log10
+from typing import Tuple, Union
+
+from ucon import units
+from ucon.unit import Unit
+
+
+# TODO -- consider using a dataclass
+@total_ordering
+class Exponent:
+    """
+    Represents a **base–exponent pair** (e.g., 10³ or 2¹⁰).
+
+    Provides comparison and division semantics used internally to represent
+    magnitude prefixes (e.g., kilo, mega, micro).
+    """
+    bases = {2: log2, 10: log10}
+
+    __slots__ = ("base", "power")
+
+    def __init__(self, base: int, power: Union[int, float]):
+        if base not in self.bases.keys():
+            raise ValueError(f'Only the following bases are supported: {reduce(lambda a,b: f"{a}, {b}", self.bases.keys())}')
+        self.base = base
+        self.power = power
+
+    @property
+    def evaluated(self) -> float:
+        """Return the numeric value of base ** power."""
+        return self.base ** self.power
+
+    def parts(self) -> Tuple[int, Union[int, float]]:
+        """Return (base, power) tuple, used for Scale lookups."""
+        return self.base, self.power
+
+    def __eq__(self, other: 'Exponent'):
+        if not isinstance(other, Exponent):
+            raise TypeError(f'Cannot compare Exponent to non-Exponent type: {type(other)}')
+        return self.evaluated == other.evaluated
+
+    def __lt__(self, other: 'Exponent'):
+        if not isinstance(other, Exponent):
+            return NotImplemented
+        return self.evaluated < other.evaluated
+
+    def __hash__(self):
+        # Hash by rounded numeric equivalence to maintain cross-base consistency
+        return hash(round(self.evaluated, 15))
+
+    # ---------- Arithmetic Semantics ----------
+
+    def __truediv__(self, other: 'Exponent'):
+        """
+        Divide two Exponents.
+        - If bases match, returns a relative Exponent.
+        - If bases differ, returns a numeric ratio (float).
+        """
+        if not isinstance(other, Exponent):
+            return NotImplemented
+        if self.base == other.base:
+            return Exponent(self.base, self.power - other.power)
+        return self.evaluated / other.evaluated
+
+    def __mul__(self, other: 'Exponent'):
+        if not isinstance(other, Exponent):
+            return NotImplemented
+        if self.base == other.base:
+            return Exponent(self.base, self.power + other.power)
+        return float(self.evaluated * other.evaluated)
+
+    # ---------- Conversion Utilities ----------
+
+    def to_base(self, new_base: int) -> "Exponent":
+        """
+        Convert this Exponent to another base representation.
+
+        Example:
+            Exponent(2, 10).to_base(10)
+            # → Exponent(base=10, power=3.010299956639812)
+        """
+        if new_base not in self.bases:
+            supported = ", ".join(map(str, self.bases))
+            raise ValueError(f"Unsupported base {new_base!r}. Supported bases: {supported}")
+        new_power = self.bases[new_base](self.evaluated)
+        return Exponent(new_base, new_power)
+
+    # ---------- Numeric Interop ----------
+
+    def __float__(self) -> float:
+        return float(self.evaluated)
+
+    def __int__(self) -> int:
+        return int(self.evaluated)
+
+    # ---------- Representation ----------
+
+    def __repr__(self) -> str:
+        return f"Exponent(base={self.base}, power={self.power})"
+
+    def __str__(self) -> str:
+        return f"{self.base}^{self.power}"
+
+
+class Scale(Enum):
+    """
+    Enumerates common **magnitude prefixes** for units and quantities.
+
+    Examples include:
+    - Binary prefixes (kibi, mebi)
+    - Decimal prefixes (milli, kilo, mega)
+
+    Each entry stores its numeric scaling factor (e.g., `kilo = 10³`).
+    """
+    mebi  = Exponent(2, 20)
+    kibi  = Exponent(2, 10)
+    mega  = Exponent(10, 6)
+    kilo  = Exponent(10, 3)
+    hecto = Exponent(10, 2)
+    deca  = Exponent(10, 1)
+    one   = Exponent(10, 0)
+    deci  = Exponent(10,-1)
+    centi = Exponent(10,-2)
+    milli = Exponent(10,-3)
+    micro = Exponent(10,-6)
+    _kibi = Exponent(2,-10)
+    _mebi = Exponent(2,-20)
+
+    @staticmethod
+    def all():
+        return dict(map(lambda x: ((x.value.base, x.value.power), x.name), Scale))
+
+    @staticmethod
+    def by_value():
+        return dict(map(lambda x: (x.value.evaluated, x.name), Scale))
+
+    def __truediv__(self, another_scale):
+        power_diff = self.value.power - another_scale.value.power
+        if self.value == another_scale.value:
+            return Scale.one
+        if self.value.base == another_scale.value.base:
+            return Scale[Scale.all()[Exponent(self.value.base, power_diff).parts()]]
+
+        base_quotient = self.value.base / another_scale.value.base
+        exp_quotient = round((base_quotient ** another_scale.value.power) * (self.value.base ** power_diff), 15)
+
+        if Scale.one in [self, another_scale]:
+            power = Exponent.bases[2](exp_quotient)
+            return Scale[Scale.all()[Exponent(2, int(power)).parts()]]
+        else:
+            scale_exp_values = [Scale[Scale.all()[pair]].value.evaluated for pair in Scale.all().keys()]
+            closest_val = min(scale_exp_values, key=lambda val: abs(val - exp_quotient))
+            return Scale[Scale.by_value()[closest_val]]
+
+    def __lt__(self, another_scale):
+        return self.value < another_scale.value
+
+    def __gt__(self, another_scale):
+        return self.value > another_scale.value
+
+    def __eq__(self, another_scale):
+        return self.value == another_scale.value
+
+
+# TODO -- consider using a dataclass
+class Number:
+    """
+    Represents a **numeric quantity** with an associated :class:`Unit` and :class:`Scale`.
+
+    Combines magnitude, unit, and scale into a single, composable object that
+    supports dimensional arithmetic and conversion:
+
+        >>> from ucon import core, units
+        >>> length = core.Number(unit=units.meter, quantity=5)
+        >>> time = core.Number(unit=units.second, quantity=2)
+        >>> speed = length / time
+        >>> speed
+        <2.5 (m/s)>
+    """
+    def __init__(self, unit: Unit = units.none, scale: Scale = Scale.one, quantity = 1):
+        self.unit = unit
+        self.scale = scale
+        self.quantity = quantity
+        self.value = round(self.quantity * self.scale.value.evaluated, 15)
+
+    def simplify(self):
+        return Number(unit=self.unit, quantity=self.value)
+
+    def to(self, new_scale: Scale):
+        new_quantity = self.quantity / new_scale.value.evaluated
+        return Number(unit=self.unit, scale=new_scale, quantity=new_quantity)
+
+    def as_ratio(self):
+        return Ratio(self)
+
+    def __mul__(self, another_number: 'Number') -> 'Number':
+        return Number(
+            unit=self.unit * another_number.unit,
+            scale=self.scale,
+            quantity=self.quantity * another_number.quantity,
+        )
+
+    def __truediv__(self, another_number: 'Number') -> 'Number':
+        unit = self.unit / another_number.unit
+        scale = self.scale / another_number.scale
+        quantity = self.quantity / another_number.quantity
+        return Number(unit, scale, quantity)
+
+    def __eq__(self, another_number):
+        if isinstance(another_number, Number):
+            return (self.unit == another_number.unit) and \
+                   (self.quantity == another_number.quantity) and \
+                   (self.value == another_number.value)
+        elif isinstance(another_number, Ratio):
+            return self == another_number.evaluate()
+        else:
+            raise ValueError(f'"{another_number}" is not a Number or Ratio. Comparison not possible.')
+
+    def __repr__(self):
+        return f'<{self.quantity} {"" if self.scale.name == "one" else self.scale.name}{self.unit.name}>'
+
+
+# TODO -- consider using a dataclass
+class Ratio:
+    """
+    Represents a **ratio of two Numbers**, preserving their unit semantics.
+
+    Useful for expressing physical relationships like efficiency, density,
+    or dimensionless comparisons:
+
+        >>> ratio = Ratio(length, time)
+        >>> ratio.evaluate()
+        <2.5 (m/s)>
+    """
+    def __init__(self, numerator: Number = Number(), denominator: Number = Number()):
+        self.numerator = numerator
+        self.denominator = denominator
+
+    def reciprocal(self) -> 'Ratio':
+        return Ratio(numerator=self.denominator, denominator=self.numerator)
+
+    def evaluate(self) -> Number:
+        return self.numerator / self.denominator
+
+    def __mul__(self, another_ratio: 'Ratio') -> 'Ratio':
+        if self.numerator.unit == another_ratio.denominator.unit:
+            factor = self.numerator / another_ratio.denominator
+            numerator, denominator = factor * another_ratio.numerator, self.denominator
+        elif self.denominator.unit == another_ratio.numerator.unit:
+            factor = another_ratio.numerator / self.denominator
+            numerator, denominator = factor * self.numerator, another_ratio.denominator
+        else:
+            factor = Number()
+            another_number = another_ratio.evaluate()
+            numerator, denominator = self.numerator * another_number, self.denominator
+        return Ratio(numerator=numerator, denominator=denominator)
+
+    def __truediv__(self, another_ratio: 'Ratio') -> 'Ratio':
+        return Ratio(
+            numerator=self.numerator * another_ratio.denominator,
+            denominator=self.denominator * another_ratio.numerator,
+        )
+
+    def __eq__(self, another_ratio: 'Ratio') -> bool:
+        if isinstance(another_ratio, Ratio):
+            return self.evaluate() == another_ratio.evaluate()
+        elif isinstance(another_ratio, Number):
+            return self.evaluate() == another_ratio
+        else:
+            raise ValueError(f'"{another_ratio}" is not a Ratio or Number. Comparison not possible.')
+
+    def __repr__(self):
+        # TODO -- resolve int/float inconsistency
+        return f'{self.evaluate()}' if self.numerator == self.denominator else f'{self.numerator} / {self.denominator}'

ucon/dimension.py

@@ -0,0 +1,172 @@
+"""
+ucon.dimension
+===============
+
+Defines the algebra of **physical dimensions**--the foundation of all unit
+relationships and dimensional analysis in *ucon*.
+
+Each :class:`Dimension` represents a physical quantity (time, mass, length, etc.)
+expressed as a 7-element exponent vector following the SI base system:
+
+    (T, L, M, I, Θ, J, N) :: (s * m * kg * A * K * cd * mol)
+     time, length, mass, current, temperature, luminous intensity, substance
+
+Derived dimensions are expressed as algebraic sums or differences of these base
+vectors (e.g., `velocity = length / time`, `force = mass * acceleration`).
+
+Classes
+-------
+- :class:`Vector` — Represents the exponent vector of a physical quantity.
+- :class:`Dimension` — Enum of known physical quantities, each with a `Vector`
+  value and operator overloads for dimensional algebra.
+"""
+from dataclasses import dataclass
+from enum import Enum
+from functools import partial, reduce
+from operator import __sub__ as subtraction
+from typing import Callable, Iterable, Iterator
+
+
+diff: Callable[[Iterable], int] = partial(reduce, subtraction)
+
+@dataclass
+class Vector:
+    """
+    Represents the **exponent vector** of a physical quantity.
+
+    Each component corresponds to the power of a base dimension in the SI system:
+    time (T), length (L), mass (M), current (I), temperature (Θ),
+    luminous intensity (J), and amount of substance (N).
+
+    Arithmetic operations correspond to dimensional composition:
+    - Addition (`+`) → multiplication of quantities
+    - Subtraction (`-`) → division of quantities
+
+    e.g.
+    Vector(T=1, L=0, M=0, I=0, Θ=0, J=0, N=0)   => "time"
+    Vector(T=0, L=2, M=0, I=0, Θ=0, J=0, N=0)   => "area"
+    Vector(T=-2, L=1, M=1, I=0, Θ=0, J=0, N=0)  => "force"
+    """
+    T: int = 0  # time
+    L: int = 0  # length
+    M: int = 0  # mass
+    I: int = 0  # current
+    Θ: int = 0  # temperature
+    J: int = 0  # luminous intensity
+    N: int = 0  # amount of substance
+
+    def __iter__(self) -> Iterator[int]:
+        yield self.T
+        yield self.L
+        yield self.M
+        yield self.I
+        yield self.Θ
+        yield self.J
+        yield self.N
+
+    def __len__(self) -> int:
+        return sum(tuple(1 for x in self))
+
+    def __add__(self, vector: 'Vector') -> 'Vector':
+        """
+        Addition, here, comes from the multiplication of base quantities
+
+        e.g. F = m * a
+        F =
+            (s^-2 * m^1 * kg   * A * K * cd * mol) +
+            (s    * m   * kg^1 * A * K * cd * mol)
+        """
+        values = tuple(sum(pair) for pair in zip(tuple(self), tuple(vector)))
+        return Vector(*values)
+
+    def __sub__(self, vector: 'Vector') -> 'Vector':
+        """
+        Subtraction, here, comes from the division of base quantities
+        """
+        values = tuple(diff(pair) for pair in zip(tuple(self), tuple(vector)))
+        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 __hash__(self) -> int:
+        # Hash based on the string because tuples have been shown to collide
+        # Not the most performant, but effective
+        return hash(str(tuple(self)))
+
+
+class Dimension(Enum):
+    """
+    Represents a **physical dimension** defined by a :class:`Vector`.
+
+    Each dimension corresponds to a distinct combination of base exponents.
+    Dimensions are algebraically composable via multiplication and division:
+
+        >>> Dimension.length / Dimension.time
+        <Dimension.velocity: Vector(T=-1, L=1, M=0, I=0, Θ=0, J=0, N=0)>
+
+    This algebra forms the foundation for unit compatibility and conversion.
+    """
+    none = Vector()
+
+    # -- BASIS ---------------------------------------
+    time                = Vector(1, 0, 0, 0, 0, 0, 0)
+    length              = Vector(0, 1, 0, 0, 0, 0, 0)
+    mass                = Vector(0, 0, 1, 0, 0, 0, 0)
+    current             = Vector(0, 0, 0, 1, 0, 0, 0)
+    temperature         = Vector(0, 0, 0, 0, 1, 0, 0)
+    luminous_intensity  = Vector(0, 0, 0, 0, 0, 1, 0)
+    amount_of_substance = Vector(0, 0, 0, 0, 0, 0, 1)
+    # ------------------------------------------------
+
+    acceleration = Vector(-2, 1, 0, 0, 0, 0, 0)
+    angular_momentum = Vector(-1, 2, 1, 0, 0, 0, 0)
+    area = Vector(0, 2, 0, 0, 0, 0, 0)
+    capacitance = Vector(4, -2, -1, 2, 0, 0, 0)
+    charge = Vector(1, 0, 0, 1, 0, 0, 0)
+    conductance = Vector(3, -2, -1, 2, 0, 0, 0)
+    conductivity = Vector(3, -3, -1, 2, 0, 0, 0)
+    density = Vector(0, -3, 1, 0, 0, 0, 0)
+    electric_field_strength = Vector(-3, 1, 1, -1, 0, 0, 0)
+    energy = Vector(-2, 2, 1, 0, 0, 0, 0)
+    entropy = Vector(-2, 2, 1, 0, -1, 0, 0)
+    force = Vector(-2, 1, 1, 0, 0, 0, 0)
+    frequency = Vector(-1, 0, 0, 0, 0, 0, 0)
+    gravitation = Vector(-2, 3, -1, 0, 0, 0, 0)
+    illuminance = Vector(0, -2, 0, 0, 0, 1, 0)
+    inductance = Vector(-2, 2, 1, -2, 0, 0, 0)
+    magnetic_flux = Vector(-2, 2, 1, -1, 0, 0, 0)
+    magnetic_flux_density = Vector(-2, 0, 1, -1, 0, 0, 0)
+    magnetic_permeability = Vector(-2, 1, 1, -2, 0, 0, 0)
+    molar_mass = Vector(0, 0, 1, 0, 0, 0, -1)
+    molar_volume = Vector(0, 3, 0, 0, 0, 0, -1)
+    momentum = Vector(-1, 1, 1, 0, 0, 0, 0)
+    permittivity = Vector(4, -3, -1, 2, 0, 0, 0)
+    power = Vector(-3, 2, 1, 0, 0, 0, 0)
+    pressure = Vector(-2, -1, 1, 0, 0, 0, 0)
+    resistance = Vector(-3, 2, 1, -2, 0, 0, 0)
+    resistivity = Vector(-3, 3, 1, -2, 0, 0, 0)
+    specific_heat_capacity = Vector(-2, 2, 0, 0, -1, 0, 0)
+    thermal_conductivity = Vector(-3, 1, 1, 0, -1, 0, 0)
+    velocity = Vector(-1, 1, 0, 0, 0, 0, 0)
+    voltage = Vector(-3, 2, 1, -1, 0, 0, 0)
+    volume = Vector(0, 3, 0, 0, 0, 0, 0)
+
+    def __truediv__(self, dimension: 'Dimension') -> 'Dimension':
+        if not isinstance(dimension, Dimension):
+            raise TypeError(f"Cannot divide Dimension by non-Dimension type: {type(dimension)}")
+        return Dimension(self.value - dimension.value)
+
+    def __mul__(self, dimension: 'Dimension') -> 'Dimension':
+        if not isinstance(dimension, Dimension):
+            raise TypeError(f"Cannot multiply Dimension by non-Dimension type: {type(dimension)}")
+        return Dimension(self.value + dimension.value)
+
+    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
+
+    def __hash__(self) -> int:
+        return hash(self.value)