hartreez 0.1.0__tar.gz

hartreez-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Thomas Plé
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

hartreez-0.1.0/PKG-INFO

@@ -0,0 +1,156 @@
+Metadata-Version: 2.4
+Name: hartreez
+Version: 0.1.0
+Summary: Dependency-free atomistic unit conversion for numerical Python code
+Keywords: units,unit-conversion,atomic-units,atomistic,molecular-dynamics,physical-constants,hartree
+Author: Thomas Plé
+Author-email: Thomas Plé <thomas.ple@sorbonne-universite.fr>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Scientific/Engineering :: Chemistry
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: Typing :: Typed
+Requires-Dist: pydantic>=2 ; extra == 'pydantic'
+Requires-Python: >=3.10
+Project-URL: Documentation, https://github.com/thomasple/hartreez/tree/main/docs
+Project-URL: Issues, https://github.com/thomasple/hartreez/issues
+Project-URL: Repository, https://github.com/thomasple/hartreez
+Provides-Extra: pydantic
+Description-Content-Type: text/markdown
+
+# hartreez
+
+`hartreez` provides unit conversion and coherent working systems for atomistic
+calculations. Convert lengths, energies, forces, and other quantities using
+familiar units such as angstrom, bohr, eV, and Hartree. Values remain ordinary
+numbers and arrays, with no quantity wrappers or core runtime dependencies.
+
+## Install
+
+```sh
+pip install hartreez
+```
+
+Requires Python 3.10 or newer. For optional Pydantic v2 input validation:
+
+```sh
+pip install 'hartreez[pydantic]'
+```
+
+## Work in atomic units
+
+Choose a working system, convert input values into it, and express results in
+the units you need. The built-in `au` system uses bohr for length and Hartree
+for energy:
+
+```python
+from hartreez import au
+
+energy_eV = 1.25
+force_eV_per_angstrom = -0.4
+
+energy_au = energy_eV * au.EV
+force_au = au.to_internal(force_eV_per_angstrom, "eV/angstrom")
+
+# Express values from the working system in external units.
+energy_out_eV = au.from_internal(energy_au, "eV")
+force_out_eV_per_angstrom = au.from_internal(force_au, "eV/angstrom")
+```
+
+Factors are ordinary floats; a named factor is one external unit expressed
+in the active system, so multiply the external value by it. `to_internal`
+multiplies by this factor; `from_internal` applies its reciprocal.
+Array-like inputs keep control of their arithmetic through scalar
+multiplication; the core neither imports nor coerces NumPy, PyTorch, or other
+array libraries.
+
+## Choose a working system
+
+Define a coherent system by choosing exactly three mechanical units from
+length, time, energy, and mass. `hartreez` derives the fourth using
+`E = M L^2 / T^2`. For example, choose angstrom, picosecond, and kcal/mol;
+mass is derived:
+
+```python
+from hartreez import UnitSystem
+
+units = UnitSystem(length="angstrom", time="ps", energy="kcal/mol")
+
+energy = units.to_internal(2.0, "eV")
+time_ps = units.to_internal(0.5, "fs")
+energy_out_eV = units.from_internal(energy, "eV")
+thermal_energy = 300.0 * units.K_B  # kcal/mol at 300 K
+```
+
+`units.K_B` is Boltzmann's constant in this system. Other physical constants,
+such as `au.HBAR`, are available on the corresponding system as ordinary
+floats; see [physical constants](https://github.com/thomasple/hartreez/blob/main/docs/constants.md).
+
+## Unit conventions
+
+- `mol` represents Avogadro's particle count and is dimensionless, so
+  `kcal/mol` and `kJ/mol` are energy units.
+- Spectroscopic `cm1` is cyclic frequency (`f = c*wavenumber`). Use `1/cm`
+  or `cm^-1` for geometric inverse length; multiply by `2*pi` when angular
+  frequency is needed.
+
+See the [unit reference](https://github.com/thomasple/hartreez/blob/main/docs/units.md) for supported names, expression syntax,
+and details of these conventions.
+
+## Convert mappings
+
+Convert unit-annotated values in an input mapping into your working system:
+
+```python
+from hartreez import UnitSystem, convert_mapping
+
+units = UnitSystem(length="angstrom", time="ps", energy="kcal/mol")
+inputs = convert_mapping({"time[fs]": 0.5, "energy[eV]": 2.0}, units)
+assert inputs["time"] == 0.0005
+```
+
+See [mapping conversion](https://github.com/thomasple/hartreez/blob/main/docs/mappings.md) for nested data and dimensional
+checks.
+
+## Validate inputs with Pydantic
+
+If you use Pydantic to describe calculation inputs, the optional integration
+converts unit-annotated values and checks their dimensions before validating
+field types and constraints. Define your input model with `UnitAwareModel`
+and supply the working system when validating:
+
+```python
+from typing import Annotated
+
+from hartreez import UnitDimension, au
+from hartreez.pydantic import UnitAwareModel
+
+
+class CalculationInput(UnitAwareModel):
+    energy: Annotated[float, UnitDimension("eV")]
+
+
+inputs = CalculationInput.model_validate(
+    {"energy[eV]": 2.0}, context={"unit_system": au}
+)
+```
+
+Here, `UnitDimension("eV")` requires an energy value, and the supplied `au`
+system makes `inputs.energy` a value in Hartree. See the
+[Pydantic integration guide](https://github.com/thomasple/hartreez/blob/main/docs/pydantic.md) for nested models and validation
+details.
+
+## Use the command line
+
+```sh
+hartreez convert 1 eV Ha --verbose
+```
+
+See the [CLI guide](https://github.com/thomasple/hartreez/blob/main/docs/cli.md) for unit factors, constants, and vocabulary
+queries.

hartreez-0.1.0/README.md

@@ -0,0 +1,130 @@
+# hartreez
+
+`hartreez` provides unit conversion and coherent working systems for atomistic
+calculations. Convert lengths, energies, forces, and other quantities using
+familiar units such as angstrom, bohr, eV, and Hartree. Values remain ordinary
+numbers and arrays, with no quantity wrappers or core runtime dependencies.
+
+## Install
+
+```sh
+pip install hartreez
+```
+
+Requires Python 3.10 or newer. For optional Pydantic v2 input validation:
+
+```sh
+pip install 'hartreez[pydantic]'
+```
+
+## Work in atomic units
+
+Choose a working system, convert input values into it, and express results in
+the units you need. The built-in `au` system uses bohr for length and Hartree
+for energy:
+
+```python
+from hartreez import au
+
+energy_eV = 1.25
+force_eV_per_angstrom = -0.4
+
+energy_au = energy_eV * au.EV
+force_au = au.to_internal(force_eV_per_angstrom, "eV/angstrom")
+
+# Express values from the working system in external units.
+energy_out_eV = au.from_internal(energy_au, "eV")
+force_out_eV_per_angstrom = au.from_internal(force_au, "eV/angstrom")
+```
+
+Factors are ordinary floats; a named factor is one external unit expressed
+in the active system, so multiply the external value by it. `to_internal`
+multiplies by this factor; `from_internal` applies its reciprocal.
+Array-like inputs keep control of their arithmetic through scalar
+multiplication; the core neither imports nor coerces NumPy, PyTorch, or other
+array libraries.
+
+## Choose a working system
+
+Define a coherent system by choosing exactly three mechanical units from
+length, time, energy, and mass. `hartreez` derives the fourth using
+`E = M L^2 / T^2`. For example, choose angstrom, picosecond, and kcal/mol;
+mass is derived:
+
+```python
+from hartreez import UnitSystem
+
+units = UnitSystem(length="angstrom", time="ps", energy="kcal/mol")
+
+energy = units.to_internal(2.0, "eV")
+time_ps = units.to_internal(0.5, "fs")
+energy_out_eV = units.from_internal(energy, "eV")
+thermal_energy = 300.0 * units.K_B  # kcal/mol at 300 K
+```
+
+`units.K_B` is Boltzmann's constant in this system. Other physical constants,
+such as `au.HBAR`, are available on the corresponding system as ordinary
+floats; see [physical constants](https://github.com/thomasple/hartreez/blob/main/docs/constants.md).
+
+## Unit conventions
+
+- `mol` represents Avogadro's particle count and is dimensionless, so
+  `kcal/mol` and `kJ/mol` are energy units.
+- Spectroscopic `cm1` is cyclic frequency (`f = c*wavenumber`). Use `1/cm`
+  or `cm^-1` for geometric inverse length; multiply by `2*pi` when angular
+  frequency is needed.
+
+See the [unit reference](https://github.com/thomasple/hartreez/blob/main/docs/units.md) for supported names, expression syntax,
+and details of these conventions.
+
+## Convert mappings
+
+Convert unit-annotated values in an input mapping into your working system:
+
+```python
+from hartreez import UnitSystem, convert_mapping
+
+units = UnitSystem(length="angstrom", time="ps", energy="kcal/mol")
+inputs = convert_mapping({"time[fs]": 0.5, "energy[eV]": 2.0}, units)
+assert inputs["time"] == 0.0005
+```
+
+See [mapping conversion](https://github.com/thomasple/hartreez/blob/main/docs/mappings.md) for nested data and dimensional
+checks.
+
+## Validate inputs with Pydantic
+
+If you use Pydantic to describe calculation inputs, the optional integration
+converts unit-annotated values and checks their dimensions before validating
+field types and constraints. Define your input model with `UnitAwareModel`
+and supply the working system when validating:
+
+```python
+from typing import Annotated
+
+from hartreez import UnitDimension, au
+from hartreez.pydantic import UnitAwareModel
+
+
+class CalculationInput(UnitAwareModel):
+    energy: Annotated[float, UnitDimension("eV")]
+
+
+inputs = CalculationInput.model_validate(
+    {"energy[eV]": 2.0}, context={"unit_system": au}
+)
+```
+
+Here, `UnitDimension("eV")` requires an energy value, and the supplied `au`
+system makes `inputs.energy` a value in Hartree. See the
+[Pydantic integration guide](https://github.com/thomasple/hartreez/blob/main/docs/pydantic.md) for nested models and validation
+details.
+
+## Use the command line
+
+```sh
+hartreez convert 1 eV Ha --verbose
+```
+
+See the [CLI guide](https://github.com/thomasple/hartreez/blob/main/docs/cli.md) for unit factors, constants, and vocabulary
+queries.

hartreez-0.1.0/pyproject.toml

@@ -0,0 +1,65 @@
+[project]
+name = "hartreez"
+version = "0.1.0"
+description = "Dependency-free atomistic unit conversion for numerical Python code"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [
+    { name = "Thomas Plé", email = "thomas.ple@sorbonne-universite.fr" }
+]
+requires-python = ">=3.10"
+dependencies = []
+keywords = [
+    "units",
+    "unit-conversion",
+    "atomic-units",
+    "atomistic",
+    "molecular-dynamics",
+    "physical-constants",
+    "hartree",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Topic :: Scientific/Engineering :: Chemistry",
+    "Topic :: Scientific/Engineering :: Physics",
+    "Typing :: Typed",
+]
+
+[project.urls]
+Repository = "https://github.com/thomasple/hartreez"
+Issues = "https://github.com/thomasple/hartreez/issues"
+Documentation = "https://github.com/thomasple/hartreez/tree/main/docs"
+
+[dependency-groups]
+dev = [
+    "pyright>=1.1.414",
+    "pytest>=9.1.1",
+    "pydantic>=2",
+]
+
+[project.scripts]
+hartreez = "hartreez:main"
+
+[project.optional-dependencies]
+pydantic = [
+    "pydantic>=2",
+]
+
+[build-system]
+requires = ["uv_build>=0.8.17,<0.9.0"]
+build-backend = "uv_build"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "-ra"
+
+[tool.pyright]
+include = ["src", "tests"]
+pythonVersion = "3.10"
+typeCheckingMode = "strict"

hartreez-0.1.0/src/hartreez/__init__.py

@@ -0,0 +1,78 @@
+"""Small, dependency-free SI unit parsing and conversion for numeric code.
+
+Importing :mod:`hartreez` only loads its small standard-library registry. No
+optional numerical or validation packages are imported.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from hartreez.constants import constant_names
+from hartreez.dimensions import Dimensions
+from hartreez.errors import (
+    IncompatibleUnitsError,
+    MappingConversionError,
+    ReferenceUnitsError,
+    UnitError,
+    UnitSyntaxError,
+    UnitSystemError,
+    UnknownUnitError,
+)
+from hartreez.mapping import convert_mapping
+from hartreez.metadata import UnitDimension
+from hartreez.parser import parse_unit
+from hartreez.systems import UnitSystem, au
+from hartreez.units import Unit, canonical_unit_names, unit_aliases, unit_names
+
+
+def convert(value: Any, from_unit: str | Unit, to_unit: str | Unit) -> Any:
+    """Convert ``value`` between compatible units by multiplying by a float.
+
+    Values are not wrapped or coerced. The caller's value must support
+    multiplication by a Python ``float``.
+    """
+
+    source = parse_unit(from_unit) if isinstance(from_unit, str) else from_unit
+    destination = parse_unit(to_unit) if isinstance(to_unit, str) else to_unit
+    if type(source) is not Unit:
+        raise TypeError("from_unit must be a unit expression or Unit")
+    if type(destination) is not Unit:
+        raise TypeError("to_unit must be a unit expression or Unit")
+    if source.dimensions != destination.dimensions:
+        raise IncompatibleUnitsError(
+            f"cannot convert from dimensions {source.dimensions} to {destination.dimensions}"
+        )
+    return value * (source.scale / destination.scale)
+
+
+def main() -> int:
+    """Run the standard-library command line interface."""
+
+    from hartreez.cli import main as cli_main
+
+    return cli_main()
+
+
+__all__ = [
+    "Dimensions",
+    "IncompatibleUnitsError",
+    "MappingConversionError",
+    "ReferenceUnitsError",
+    "Unit",
+    "UnitDimension",
+    "UnitError",
+    "UnitSyntaxError",
+    "UnitSystem",
+    "UnitSystemError",
+    "UnknownUnitError",
+    "au",
+    "canonical_unit_names",
+    "constant_names",
+    "convert",
+    "convert_mapping",
+    "main",
+    "parse_unit",
+    "unit_aliases",
+    "unit_names",
+]

hartreez-0.1.0/src/hartreez/cli.py

@@ -0,0 +1,81 @@
+"""Standard-library command line interface for hartreez."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from collections.abc import Sequence
+
+from hartreez import au, canonical_unit_names, constant_names, convert, unit_aliases
+from hartreez.errors import UnitError
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="hartreez",
+        description="Convert atomistic units and query atomic-unit factors and constants.",
+    )
+    commands = parser.add_subparsers(dest="command", required=True)
+
+    conversion = commands.add_parser("convert", help="convert a numeric value between units")
+    conversion.add_argument("value", type=float, help="numeric value to convert")
+    conversion.add_argument("from_unit", help="source unit expression")
+    conversion.add_argument("to_unit", help="destination unit expression")
+    conversion.add_argument(
+        "--verbose", "-v", action="store_true", help="show a readable conversion equality"
+    )
+
+    factor = commands.add_parser("factor", help="query one unit expressed in atomic units")
+    factor.add_argument("unit", help="unit expression")
+
+    constant = commands.add_parser("constant", help="query a physical constant in atomic units")
+    constant.add_argument("name", help="constant name, for example K_B or HBAR")
+
+    commands.add_parser("units", help="list canonical unit spellings")
+    commands.add_parser(
+        "aliases", help="list aliases and their canonical spellings or equivalent expressions"
+    )
+    commands.add_parser("constants", help="list supported physical constant names")
+    return parser
+
+
+def _number(value: float) -> str:
+    return format(value, ".15g")
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    """Run the CLI and return a process status code."""
+
+    parser = _parser()
+    args = parser.parse_args(argv)
+
+    try:
+        if args.command == "convert":
+            result = convert(args.value, args.from_unit, args.to_unit)
+            if args.verbose:
+                print(
+                    f"{_number(args.value)} {args.from_unit} = "
+                    f"{_number(result)} {args.to_unit}"
+                )
+            else:
+                print(result)
+        elif args.command == "factor":
+            print(au.factor_from(args.unit))
+        elif args.command == "constant":
+            print(au.constant(args.name))
+        elif args.command == "units":
+            print("\n".join(canonical_unit_names()))
+        elif args.command == "aliases":
+            print("\n".join(f"{alias} -> {canonical}" for alias, canonical in sorted(unit_aliases().items())))
+        elif args.command == "constants":
+            print("\n".join(constant_names()))
+        else:  # pragma: no cover - argparse enforces the command set
+            parser.error("a command is required")
+    except (UnitError, ValueError, TypeError) as error:
+        print(f"hartreez: error: {error}", file=sys.stderr)
+        return 2
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

hartreez-0.1.0/src/hartreez/constants.py

@@ -0,0 +1,79 @@
+"""Source physical constants, independent of the unit registry.
+
+Measured inputs are central values from CODATA 2022. Exact SI defining
+constants are kept exact. Derived atomic units share these inputs so that
+their identities remain internally consistent.
+"""
+
+from dataclasses import dataclass
+from math import pi
+from types import MappingProxyType
+from typing import Mapping
+
+from hartreez.dimensions import Dimensions
+
+# Exact SI defining constants.
+C_LIGHT = 299_792_458.0  # m s^-1
+PLANCK = 6.626_070_15e-34  # J s
+E_CHARGE = 1.602_176_634e-19  # C
+K_B = 1.380_649e-23  # J K^-1
+N_A = 6.022_140_76e23  # mol^-1; exposed as a dimensionless count
+
+# CODATA 2022 measured central values.
+ALPHA = 7.297_352_5643e-3
+M_E = 9.109_383_7139e-31  # kg
+M_P = 1.672_621_92595e-27  # kg
+M_U = 1.660_539_06892e-27  # kg, atomic mass constant (Dalton)
+
+# Derived values use the shared source inputs above.
+HBAR = PLANCK / (2.0 * pi)
+BOHR_RADIUS = HBAR / (M_E * C_LIGHT * ALPHA)  # m
+HARTREE_ENERGY = ALPHA**2 * M_E * C_LIGHT**2  # J
+ATOMIC_TIME = HBAR / HARTREE_ENERGY  # s
+RYDBERG_ENERGY = HARTREE_ENERGY / 2.0  # J
+DEBYE = 1.0e-21 / C_LIGHT  # C m; exact SI conversion under definition
+SPECTROSCOPIC_CM1 = C_LIGHT * 100.0  # Hz per cm^-1 of wavenumber
+
+# Dimensions use the package's independent SI bases M, L, T, Q, and Θ.
+_MASS = Dimensions(mass=1)
+_LENGTH = Dimensions(length=1)
+_TIME = Dimensions(time=1)
+_CHARGE = Dimensions(charge=1)
+_TEMPERATURE = Dimensions(temperature=1)
+_ENERGY = _MASS * (_LENGTH**2) / (_TIME**2)
+_DIMENSIONLESS = Dimensions()
+
+EPSILON_0 = E_CHARGE**2 / (4.0 * pi * ALPHA * HBAR * C_LIGHT)  # F m^-1
+K_E = 1.0 / (4.0 * pi * EPSILON_0)  # N m^2 C^-2
+
+
+@dataclass(frozen=True, slots=True)
+class PhysicalConstant:
+    """A central SI value and its physical dimensions."""
+
+    value: float
+    dimensions: Dimensions
+
+
+CONSTANTS: Mapping[str, PhysicalConstant] = MappingProxyType(
+    {
+        "K_B": PhysicalConstant(K_B, _ENERGY / _TEMPERATURE),
+        "HBAR": PhysicalConstant(HBAR, _ENERGY * _TIME),
+        "PLANCK": PhysicalConstant(PLANCK, _ENERGY * _TIME),
+        "C_LIGHT": PhysicalConstant(C_LIGHT, _LENGTH / _TIME),
+        "ALPHA": PhysicalConstant(ALPHA, _DIMENSIONLESS),
+        "M_E": PhysicalConstant(M_E, _MASS),
+        "M_P": PhysicalConstant(M_P, _MASS),
+        "E_CHARGE": PhysicalConstant(E_CHARGE, _CHARGE),
+        # This is a particle count and remains dimensionless in every system.
+        "N_A": PhysicalConstant(N_A, _DIMENSIONLESS),
+        "EPSILON_0": PhysicalConstant(EPSILON_0, (_CHARGE**2) / _ENERGY / _LENGTH),
+        "K_E": PhysicalConstant(K_E, _ENERGY * _LENGTH / (_CHARGE**2)),
+    }
+)
+
+
+def constant_names() -> tuple[str, ...]:
+    """Return the curated physical constant names alphabetically."""
+
+    return tuple(sorted(CONSTANTS))

hartreez-0.1.0/src/hartreez/dimensions.py

@@ -0,0 +1,65 @@
+"""Exact physical dimensions for the five independent hartreez dimensions."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from fractions import Fraction
+def _fraction(value: int | float | str | Fraction) -> Fraction:
+    if isinstance(value, Fraction):
+        return value
+    if isinstance(value, int):
+        return Fraction(value)
+    if isinstance(value, float):
+        return Fraction(str(value))
+    return Fraction(value)
+
+
+@dataclass(frozen=True, slots=True, init=False)
+class Dimensions:
+    """Exponents of mass, length, time, charge, and temperature.
+
+    Exponents are normalized to :class:`fractions.Fraction`, so dimensional
+    equality is exact even when units are raised to fractional powers.
+    """
+
+    mass: Fraction = Fraction(0)
+    length: Fraction = Fraction(0)
+    time: Fraction = Fraction(0)
+    charge: Fraction = Fraction(0)
+    temperature: Fraction = Fraction(0)
+
+    def __init__(
+        self,
+        mass: int | float | str | Fraction = 0,
+        length: int | float | str | Fraction = 0,
+        time: int | float | str | Fraction = 0,
+        charge: int | float | str | Fraction = 0,
+        temperature: int | float | str | Fraction = 0,
+    ) -> None:
+        object.__setattr__(self, "mass", _fraction(mass))
+        object.__setattr__(self, "length", _fraction(length))
+        object.__setattr__(self, "time", _fraction(time))
+        object.__setattr__(self, "charge", _fraction(charge))
+        object.__setattr__(self, "temperature", _fraction(temperature))
+
+    def __mul__(self, other: Dimensions) -> Dimensions:
+        if type(other) is not Dimensions:
+            return NotImplemented
+        return Dimensions(*(a + b for a, b in zip(self._exponents(), other._exponents())))
+
+    def __truediv__(self, other: Dimensions) -> Dimensions:
+        if type(other) is not Dimensions:
+            return NotImplemented
+        return Dimensions(*(a - b for a, b in zip(self._exponents(), other._exponents())))
+
+    def __pow__(self, exponent: int | float | str | Fraction) -> Dimensions:
+        power = _fraction(exponent)
+        return Dimensions(*(value * power for value in self._exponents()))
+
+    def _exponents(self) -> tuple[Fraction, Fraction, Fraction, Fraction, Fraction]:
+        return self.mass, self.length, self.time, self.charge, self.temperature
+
+    def __str__(self) -> str:
+        labels = ("M", "L", "T", "Q", "Θ")
+        terms = [f"{label}^{value}" for label, value in zip(labels, self._exponents()) if value]
+        return "1" if not terms else " ".join(terms)