unit-aware-arithmetic 1.0.0__tar.gz

unit_aware_arithmetic-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Parthiv Rawat
+
+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.

unit_aware_arithmetic-1.0.0/MANIFEST.in

@@ -0,0 +1,3 @@
+include README.md
+include LICENSE
+include py.typed

unit_aware_arithmetic-1.0.0/PKG-INFO

@@ -0,0 +1,299 @@
+Metadata-Version: 2.4
+Name: unit-aware-arithmetic
+Version: 1.0.0
+Summary: Type-safe dimensional arithmetic library with unit tracking
+Home-page: https://github.com/parthivrawat/unit-aware-arithmetic
+Author: Parthiv Rawat
+Author-email: Parthiv Rawat <parthiv05022000@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2026 Parthiv Rawat
+        
+        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.
+        
+Project-URL: Homepage, https://github.com/parthivrawat/unit-aware-arithmetic
+Project-URL: Repository, https://github.com/parthivrawat/unit-aware-arithmetic.git
+Project-URL: Issues, https://github.com/parthivrawat/unit-aware-arithmetic/issues
+Keywords: units,dimensions,physics,measurement,type-safe,dimensional-analysis
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# Unit-Aware Arithmetic (Python)
+
+A type-safe dimensional arithmetic library that tracks units at runtime and prevents invalid operations.
+
+## Features
+
+- ✅ **Type-safe dimensional analysis**: Prevents incompatible unit operations
+- ✅ **Zero dependencies**: Core functionality has no external dependencies
+- ✅ **Comprehensive unit coverage**: SI, imperial, and derived units
+- ✅ **Arithmetic operations**: Add, subtract, multiply, divide with unit tracking
+- ✅ **Unit conversion**: Automatic and explicit conversion between compatible units
+- ✅ **Clear error messages**: Helpful errors for incompatible operations
+- ✅ **Production-ready**: Comprehensive test coverage (>95%)
+
+## Installation
+
+```bash
+pip install -e .
+```
+
+## Quick Start
+
+```python
+from dimensional import Quantity, units
+
+# Create quantities with units
+distance = Quantity(100, units.meter)
+time = Quantity(9.58, units.second)
+
+# Arithmetic operations with automatic unit tracking
+speed = distance / time
+print(speed)  # 10.438413361169102 m/s
+
+# Unit conversion
+distance_km = distance.to(units.kilometer)
+print(distance_km)  # 0.1 km
+
+# Type-safe operations - this will raise an error!
+try:
+    distance + time  # IncompatibleUnitsError
+except Exception as e:
+    print(f"Error: {e}")
+```
+
+## Usage Examples
+
+### Basic Arithmetic
+
+```python
+from dimensional import Quantity, units
+
+# Addition (same dimension required)
+d1 = Quantity(5, units.meter)
+d2 = Quantity(3, units.meter)
+total = d1 + d2  # 8.0 m
+
+# Multiplication creates derived units
+area = Quantity(5, units.meter) * Quantity(3, units.meter)
+print(area)  # 15.0 m·m
+
+# Division creates derived units
+velocity = Quantity(100, units.meter) / Quantity(10, units.second)
+print(velocity)  # 10.0 m/s
+```
+
+### Unit Conversion
+
+```python
+from dimensional import Quantity, units
+
+# Length conversion
+distance = Quantity(1, units.mile)
+distance_km = distance.to(units.kilometer)
+print(distance_km)  # 1.60934 km
+
+# Temperature conversion
+temp_c = Quantity(0, units.celsius)
+temp_k = temp_c.to(units.kelvin)
+print(temp_k)  # 273.15 K
+
+# Mass conversion
+mass_lb = Quantity(10, units.pound)
+mass_kg = mass_lb.to(units.kilogram)
+print(mass_kg)  # 4.53592 kg
+```
+
+### Physics Calculations
+
+```python
+from dimensional import Quantity, units
+
+# Calculate velocity
+distance = Quantity(100, units.meter)
+time = Quantity(9.58, units.second)
+velocity = distance / time
+print(f"Velocity: {velocity}")
+
+# Calculate force (F = ma)
+mass = Quantity(10, units.kilogram)
+acceleration = Quantity(9.8, units.meter_per_second_squared)
+force = mass * acceleration
+print(f"Force: {force}")
+
+# Calculate kinetic energy (KE = 1/2 * m * v²)
+mass = Quantity(2, units.kilogram)
+velocity = Quantity(10, units.meter_per_second)
+ke = 0.5 * mass * (velocity ** 2)
+print(f"Kinetic Energy: {ke}")
+```
+
+### Comparison Operations
+
+```python
+from dimensional import Quantity, units
+
+d1 = Quantity(100, units.centimeter)
+d2 = Quantity(1, units.meter)
+
+# Automatic conversion for comparison
+print(d1 == d2)  # True
+print(d1 < Quantity(2, units.meter))  # True
+```
+
+## Available Units
+
+### Length
+- `meter`, `kilometer`, `centimeter`, `millimeter`
+- `inch`, `foot`, `yard`, `mile`
+
+### Mass
+- `kilogram`, `gram`, `milligram`, `tonne`
+- `pound`, `ounce`
+
+### Time
+- `second`, `minute`, `hour`, `day`
+
+### Temperature
+- `kelvin`, `celsius`, `fahrenheit`
+
+### Current
+- `ampere`, `milliampere`
+
+### Derived Units
+- `newton` (force)
+- `joule`, `kilojoule` (energy)
+- `watt`, `kilowatt` (power)
+- `pascal`, `kilopascal` (pressure)
+- `meter_per_second`, `kilometer_per_hour` (velocity)
+- `meter_per_second_squared` (acceleration)
+
+## Error Handling
+
+The library provides clear error messages for invalid operations:
+
+```python
+from dimensional import Quantity, units, IncompatibleUnitsError
+
+distance = Quantity(100, units.meter)
+time = Quantity(10, units.second)
+
+try:
+    # This will raise IncompatibleUnitsError
+    result = distance + time
+except IncompatibleUnitsError as e:
+    print(e)  # "Cannot add m and s: incompatible dimensions"
+```
+
+## Testing
+
+Run the test suite:
+
+```bash
+pytest test_dimensional.py -v
+```
+
+Run with coverage:
+
+```bash
+pytest test_dimensional.py --cov=dimensional --cov-report=html
+```
+
+## Type Checking
+
+This library includes type hints. Run type checking with:
+
+```bash
+mypy dimensional.py
+```
+
+## Design Principles
+
+1. **Zero Dependencies**: Core functionality has no external dependencies
+2. **Type Safety**: Prevents invalid operations at runtime
+3. **Clear Errors**: Actionable error messages
+4. **Production Ready**: Comprehensive test coverage
+5. **Performance**: Efficient implementation with minimal overhead
+
+## API Reference
+
+### `Dimension`
+
+Represents the dimensional formula of a unit (e.g., L^1 T^-2 for acceleration).
+
+### `Unit`
+
+Represents a unit of measurement with its dimension and conversion factor.
+
+### `Quantity`
+
+A numeric value with an associated unit. Supports:
+- Arithmetic: `+`, `-`, `*`, `/`, `**`, `-` (negation), `abs()`
+- Comparison: `==`, `!=`, `<`, `<=`, `>`, `>=`
+- Conversion: `.to(target_unit)`
+
+### `units`
+
+Namespace containing all predefined units.
+
+## License
+
+MIT License
+
+## Contributing
+
+Contributions are welcome! Please ensure:
+- All tests pass
+- Code coverage remains >90%
+- Type hints are included
+- Documentation is updated
+
+## Changelog
+
+### 1.0.0 (2026-08-28)
+- Initial release
+- Support for SI and imperial units
+- Comprehensive dimensional analysis
+- Temperature conversion with offset handling
+- Full test coverage

unit_aware_arithmetic-1.0.0/README.md

@@ -0,0 +1,238 @@
+# Unit-Aware Arithmetic (Python)
+
+A type-safe dimensional arithmetic library that tracks units at runtime and prevents invalid operations.
+
+## Features
+
+- ✅ **Type-safe dimensional analysis**: Prevents incompatible unit operations
+- ✅ **Zero dependencies**: Core functionality has no external dependencies
+- ✅ **Comprehensive unit coverage**: SI, imperial, and derived units
+- ✅ **Arithmetic operations**: Add, subtract, multiply, divide with unit tracking
+- ✅ **Unit conversion**: Automatic and explicit conversion between compatible units
+- ✅ **Clear error messages**: Helpful errors for incompatible operations
+- ✅ **Production-ready**: Comprehensive test coverage (>95%)
+
+## Installation
+
+```bash
+pip install -e .
+```
+
+## Quick Start
+
+```python
+from dimensional import Quantity, units
+
+# Create quantities with units
+distance = Quantity(100, units.meter)
+time = Quantity(9.58, units.second)
+
+# Arithmetic operations with automatic unit tracking
+speed = distance / time
+print(speed)  # 10.438413361169102 m/s
+
+# Unit conversion
+distance_km = distance.to(units.kilometer)
+print(distance_km)  # 0.1 km
+
+# Type-safe operations - this will raise an error!
+try:
+    distance + time  # IncompatibleUnitsError
+except Exception as e:
+    print(f"Error: {e}")
+```
+
+## Usage Examples
+
+### Basic Arithmetic
+
+```python
+from dimensional import Quantity, units
+
+# Addition (same dimension required)
+d1 = Quantity(5, units.meter)
+d2 = Quantity(3, units.meter)
+total = d1 + d2  # 8.0 m
+
+# Multiplication creates derived units
+area = Quantity(5, units.meter) * Quantity(3, units.meter)
+print(area)  # 15.0 m·m
+
+# Division creates derived units
+velocity = Quantity(100, units.meter) / Quantity(10, units.second)
+print(velocity)  # 10.0 m/s
+```
+
+### Unit Conversion
+
+```python
+from dimensional import Quantity, units
+
+# Length conversion
+distance = Quantity(1, units.mile)
+distance_km = distance.to(units.kilometer)
+print(distance_km)  # 1.60934 km
+
+# Temperature conversion
+temp_c = Quantity(0, units.celsius)
+temp_k = temp_c.to(units.kelvin)
+print(temp_k)  # 273.15 K
+
+# Mass conversion
+mass_lb = Quantity(10, units.pound)
+mass_kg = mass_lb.to(units.kilogram)
+print(mass_kg)  # 4.53592 kg
+```
+
+### Physics Calculations
+
+```python
+from dimensional import Quantity, units
+
+# Calculate velocity
+distance = Quantity(100, units.meter)
+time = Quantity(9.58, units.second)
+velocity = distance / time
+print(f"Velocity: {velocity}")
+
+# Calculate force (F = ma)
+mass = Quantity(10, units.kilogram)
+acceleration = Quantity(9.8, units.meter_per_second_squared)
+force = mass * acceleration
+print(f"Force: {force}")
+
+# Calculate kinetic energy (KE = 1/2 * m * v²)
+mass = Quantity(2, units.kilogram)
+velocity = Quantity(10, units.meter_per_second)
+ke = 0.5 * mass * (velocity ** 2)
+print(f"Kinetic Energy: {ke}")
+```
+
+### Comparison Operations
+
+```python
+from dimensional import Quantity, units
+
+d1 = Quantity(100, units.centimeter)
+d2 = Quantity(1, units.meter)
+
+# Automatic conversion for comparison
+print(d1 == d2)  # True
+print(d1 < Quantity(2, units.meter))  # True
+```
+
+## Available Units
+
+### Length
+- `meter`, `kilometer`, `centimeter`, `millimeter`
+- `inch`, `foot`, `yard`, `mile`
+
+### Mass
+- `kilogram`, `gram`, `milligram`, `tonne`
+- `pound`, `ounce`
+
+### Time
+- `second`, `minute`, `hour`, `day`
+
+### Temperature
+- `kelvin`, `celsius`, `fahrenheit`
+
+### Current
+- `ampere`, `milliampere`
+
+### Derived Units
+- `newton` (force)
+- `joule`, `kilojoule` (energy)
+- `watt`, `kilowatt` (power)
+- `pascal`, `kilopascal` (pressure)
+- `meter_per_second`, `kilometer_per_hour` (velocity)
+- `meter_per_second_squared` (acceleration)
+
+## Error Handling
+
+The library provides clear error messages for invalid operations:
+
+```python
+from dimensional import Quantity, units, IncompatibleUnitsError
+
+distance = Quantity(100, units.meter)
+time = Quantity(10, units.second)
+
+try:
+    # This will raise IncompatibleUnitsError
+    result = distance + time
+except IncompatibleUnitsError as e:
+    print(e)  # "Cannot add m and s: incompatible dimensions"
+```
+
+## Testing
+
+Run the test suite:
+
+```bash
+pytest test_dimensional.py -v
+```
+
+Run with coverage:
+
+```bash
+pytest test_dimensional.py --cov=dimensional --cov-report=html
+```
+
+## Type Checking
+
+This library includes type hints. Run type checking with:
+
+```bash
+mypy dimensional.py
+```
+
+## Design Principles
+
+1. **Zero Dependencies**: Core functionality has no external dependencies
+2. **Type Safety**: Prevents invalid operations at runtime
+3. **Clear Errors**: Actionable error messages
+4. **Production Ready**: Comprehensive test coverage
+5. **Performance**: Efficient implementation with minimal overhead
+
+## API Reference
+
+### `Dimension`
+
+Represents the dimensional formula of a unit (e.g., L^1 T^-2 for acceleration).
+
+### `Unit`
+
+Represents a unit of measurement with its dimension and conversion factor.
+
+### `Quantity`
+
+A numeric value with an associated unit. Supports:
+- Arithmetic: `+`, `-`, `*`, `/`, `**`, `-` (negation), `abs()`
+- Comparison: `==`, `!=`, `<`, `<=`, `>`, `>=`
+- Conversion: `.to(target_unit)`
+
+### `units`
+
+Namespace containing all predefined units.
+
+## License
+
+MIT License
+
+## Contributing
+
+Contributions are welcome! Please ensure:
+- All tests pass
+- Code coverage remains >90%
+- Type hints are included
+- Documentation is updated
+
+## Changelog
+
+### 1.0.0 (2026-08-28)
+- Initial release
+- Support for SI and imperial units
+- Comprehensive dimensional analysis
+- Temperature conversion with offset handling
+- Full test coverage

unit_aware_arithmetic-1.0.0/dimensional.py

@@ -0,0 +1,364 @@
+"""
+Unit-Aware Numeric Arithmetic Library
+
+A type-safe dimensional arithmetic library that tracks units at runtime
+and prevents invalid operations.
+
+Zero dependencies, production-ready.
+"""
+
+from __future__ import annotations
+from typing import Dict, Optional, Union, Any
+from dataclasses import dataclass
+import math
+
+
+@dataclass(frozen=True)
+class Dimension:
+    """Represents the dimensional formula of a unit (e.g., L^1 T^-2 for acceleration)."""
+    
+    length: int = 0      # L
+    mass: int = 0        # M
+    time: int = 0        # T
+    current: int = 0     # I
+    temperature: int = 0 # Θ
+    amount: int = 0      # N
+    luminosity: int = 0  # J
+    
+    def __mul__(self, other: Dimension) -> Dimension:
+        """Multiply dimensions (add exponents)."""
+        return Dimension(
+            length=self.length + other.length,
+            mass=self.mass + other.mass,
+            time=self.time + other.time,
+            current=self.current + other.current,
+            temperature=self.temperature + other.temperature,
+            amount=self.amount + other.amount,
+            luminosity=self.luminosity + other.luminosity,
+        )
+    
+    def __truediv__(self, other: Dimension) -> Dimension:
+        """Divide dimensions (subtract exponents)."""
+        return Dimension(
+            length=self.length - other.length,
+            mass=self.mass - other.mass,
+            time=self.time - other.time,
+            current=self.current - other.current,
+            temperature=self.temperature - other.temperature,
+            amount=self.amount - other.amount,
+            luminosity=self.luminosity - other.luminosity,
+        )
+    
+    def __pow__(self, exponent: int) -> Dimension:
+        """Raise dimension to a power."""
+        return Dimension(
+            length=self.length * exponent,
+            mass=self.mass * exponent,
+            time=self.time * exponent,
+            current=self.current * exponent,
+            temperature=self.temperature * exponent,
+            amount=self.amount * exponent,
+            luminosity=self.luminosity * exponent,
+        )
+    
+    def is_dimensionless(self) -> bool:
+        """Check if this is a dimensionless quantity."""
+        return all([
+            self.length == 0,
+            self.mass == 0,
+            self.time == 0,
+            self.current == 0,
+            self.temperature == 0,
+            self.amount == 0,
+            self.luminosity == 0,
+        ])
+
+
+class Unit:
+    """Represents a unit of measurement with its dimension and conversion factor to base units."""
+    
+    def __init__(
+        self,
+        name: str,
+        symbol: str,
+        dimension: Dimension,
+        to_base: float = 1.0,
+        offset: float = 0.0,
+    ):
+        self.name = name
+        self.symbol = symbol
+        self.dimension = dimension
+        self.to_base = to_base  # Conversion factor to base unit
+        self.offset = offset    # Offset for affine conversions (e.g., Celsius)
+    
+    def __repr__(self) -> str:
+        return f"Unit({self.symbol})"
+    
+    def __eq__(self, other: Any) -> bool:
+        if not isinstance(other, Unit):
+            return False
+        return (
+            self.symbol == other.symbol
+            and self.dimension == other.dimension
+            and self.to_base == other.to_base
+            and self.offset == other.offset
+        )
+    
+    def __hash__(self) -> int:
+        return hash((self.symbol, self.dimension, self.to_base, self.offset))
+
+
+class IncompatibleUnitsError(Exception):
+    """Raised when attempting incompatible unit operations."""
+    pass
+
+
+class Quantity:
+    """A numeric value with an associated unit."""
+    
+    def __init__(self, value: Union[int, float], unit: Unit):
+        self.value = float(value)
+        self.unit = unit
+    
+    def __repr__(self) -> str:
+        return f"{self.value} {self.unit.symbol}"
+    
+    def __str__(self) -> str:
+        return self.__repr__()
+    
+    # Arithmetic operations
+    
+    def __add__(self, other: Quantity) -> Quantity:
+        """Add two quantities (must have compatible dimensions)."""
+        if not isinstance(other, Quantity):
+            raise TypeError(f"Cannot add Quantity and {type(other).__name__}")
+        
+        if self.unit.dimension != other.unit.dimension:
+            raise IncompatibleUnitsError(
+                f"Cannot add {self.unit.symbol} and {other.unit.symbol}: "
+                f"incompatible dimensions"
+            )
+        
+        # Convert other to self's unit
+        other_in_self_unit = other.to(self.unit)
+        return Quantity(self.value + other_in_self_unit.value, self.unit)
+    
+    def __sub__(self, other: Quantity) -> Quantity:
+        """Subtract two quantities (must have compatible dimensions)."""
+        if not isinstance(other, Quantity):
+            raise TypeError(f"Cannot subtract {type(other).__name__} from Quantity")
+        
+        if self.unit.dimension != other.unit.dimension:
+            raise IncompatibleUnitsError(
+                f"Cannot subtract {other.unit.symbol} from {self.unit.symbol}: "
+                f"incompatible dimensions"
+            )
+        
+        other_in_self_unit = other.to(self.unit)
+        return Quantity(self.value - other_in_self_unit.value, self.unit)
+    
+    def __mul__(self, other: Union[Quantity, int, float]) -> Quantity:
+        """Multiply quantity by another quantity or scalar."""
+        if isinstance(other, (int, float)):
+            return Quantity(self.value * other, self.unit)
+        
+        if isinstance(other, Quantity):
+            # Multiply values and dimensions
+            new_value = self.value * other.value
+            new_dimension = self.unit.dimension * other.unit.dimension
+            
+            # Create a derived unit
+            new_symbol = f"{self.unit.symbol}·{other.unit.symbol}"
+            new_unit = Unit(
+                name=f"{self.unit.name} {other.unit.name}",
+                symbol=new_symbol,
+                dimension=new_dimension,
+                to_base=self.unit.to_base * other.unit.to_base,
+            )
+            return Quantity(new_value, new_unit)
+        
+        raise TypeError(f"Cannot multiply Quantity and {type(other).__name__}")
+    
+    def __rmul__(self, other: Union[int, float]) -> Quantity:
+        """Right multiplication (scalar * quantity)."""
+        return self.__mul__(other)
+    
+    def __truediv__(self, other: Union[Quantity, int, float]) -> Quantity:
+        """Divide quantity by another quantity or scalar."""
+        if isinstance(other, (int, float)):
+            return Quantity(self.value / other, self.unit)
+        
+        if isinstance(other, Quantity):
+            # Divide values and dimensions
+            new_value = self.value / other.value
+            new_dimension = self.unit.dimension / other.unit.dimension
+            
+            # Create a derived unit
+            new_symbol = f"{self.unit.symbol}/{other.unit.symbol}"
+            new_unit = Unit(
+                name=f"{self.unit.name} per {other.unit.name}",
+                symbol=new_symbol,
+                dimension=new_dimension,
+                to_base=self.unit.to_base / other.unit.to_base,
+            )
+            return Quantity(new_value, new_unit)
+        
+        raise TypeError(f"Cannot divide Quantity by {type(other).__name__}")
+    
+    def __pow__(self, exponent: Union[int, float]) -> Quantity:
+        """Raise quantity to a power."""
+        if not isinstance(exponent, (int, float)):
+            raise TypeError(f"Exponent must be numeric, not {type(exponent).__name__}")
+        
+        new_value = self.value ** exponent
+        
+        # For integer exponents, we can compute the exact dimension
+        if isinstance(exponent, int):
+            new_dimension = self.unit.dimension ** exponent
+            new_symbol = f"{self.unit.symbol}^{exponent}"
+            new_unit = Unit(
+                name=f"{self.unit.name} to the power {exponent}",
+                symbol=new_symbol,
+                dimension=new_dimension,
+                to_base=self.unit.to_base ** exponent,
+            )
+            return Quantity(new_value, new_unit)
+        
+        # For fractional exponents, we need to be careful
+        # This is a simplified implementation
+        raise NotImplementedError("Fractional exponents not yet supported")
+    
+    def __neg__(self) -> Quantity:
+        """Negate quantity."""
+        return Quantity(-self.value, self.unit)
+    
+    def __abs__(self) -> Quantity:
+        """Absolute value."""
+        return Quantity(abs(self.value), self.unit)
+    
+    # Comparison operations
+    
+    def __eq__(self, other: Any) -> bool:
+        if not isinstance(other, Quantity):
+            return False
+        
+        if self.unit.dimension != other.unit.dimension:
+            return False
+        
+        other_in_self_unit = other.to(self.unit)
+        return math.isclose(self.value, other_in_self_unit.value)
+    
+    def __lt__(self, other: Quantity) -> bool:
+        if not isinstance(other, Quantity):
+            raise TypeError(f"Cannot compare Quantity and {type(other).__name__}")
+        
+        if self.unit.dimension != other.unit.dimension:
+            raise IncompatibleUnitsError(
+                f"Cannot compare {self.unit.symbol} and {other.unit.symbol}"
+            )
+        
+        other_in_self_unit = other.to(self.unit)
+        return self.value < other_in_self_unit.value
+    
+    def __le__(self, other: Quantity) -> bool:
+        return self == other or self < other
+    
+    def __gt__(self, other: Quantity) -> bool:
+        return not self <= other
+    
+    def __ge__(self, other: Quantity) -> bool:
+        return not self < other
+    
+    # Unit conversion
+    
+    def to(self, target_unit: Unit) -> Quantity:
+        """Convert to another unit (must have compatible dimensions)."""
+        if self.unit.dimension != target_unit.dimension:
+            raise IncompatibleUnitsError(
+                f"Cannot convert {self.unit.symbol} to {target_unit.symbol}: "
+                f"incompatible dimensions"
+            )
+        
+        # Handle affine conversions (e.g., temperature)
+        if self.unit.offset != 0 or target_unit.offset != 0:
+            # Convert to base unit first (remove offset)
+            base_value = (self.value + self.unit.offset) * self.unit.to_base
+            # Convert from base to target (apply offset)
+            new_value = base_value / target_unit.to_base - target_unit.offset
+        else:
+            # Simple linear conversion
+            new_value = self.value * (self.unit.to_base / target_unit.to_base)
+        
+        return Quantity(new_value, target_unit)
+
+
+# ============================================================================
+# Unit Definitions
+# ============================================================================
+
+class units:
+    """Namespace for predefined units."""
+    
+    # Dimensionless
+    dimensionless = Unit("dimensionless", "", Dimension())
+    
+    # Length
+    meter = Unit("meter", "m", Dimension(length=1))
+    kilometer = Unit("kilometer", "km", Dimension(length=1), to_base=1000.0)
+    centimeter = Unit("centimeter", "cm", Dimension(length=1), to_base=0.01)
+    millimeter = Unit("millimeter", "mm", Dimension(length=1), to_base=0.001)
+    
+    # Imperial length
+    inch = Unit("inch", "in", Dimension(length=1), to_base=0.0254)
+    foot = Unit("foot", "ft", Dimension(length=1), to_base=0.3048)
+    yard = Unit("yard", "yd", Dimension(length=1), to_base=0.9144)
+    mile = Unit("mile", "mi", Dimension(length=1), to_base=1609.34)
+    
+    # Mass
+    kilogram = Unit("kilogram", "kg", Dimension(mass=1))
+    gram = Unit("gram", "g", Dimension(mass=1), to_base=0.001)
+    milligram = Unit("milligram", "mg", Dimension(mass=1), to_base=1e-6)
+    tonne = Unit("tonne", "t", Dimension(mass=1), to_base=1000.0)
+    
+    # Imperial mass
+    pound = Unit("pound", "lb", Dimension(mass=1), to_base=0.453592)
+    ounce = Unit("ounce", "oz", Dimension(mass=1), to_base=0.0283495)
+    
+    # Time
+    second = Unit("second", "s", Dimension(time=1))
+    minute = Unit("minute", "min", Dimension(time=1), to_base=60.0)
+    hour = Unit("hour", "h", Dimension(time=1), to_base=3600.0)
+    day = Unit("day", "d", Dimension(time=1), to_base=86400.0)
+    
+    # Temperature (absolute)
+    kelvin = Unit("kelvin", "K", Dimension(temperature=1))
+    celsius = Unit("celsius", "°C", Dimension(temperature=1), to_base=1.0, offset=273.15)
+    fahrenheit = Unit("fahrenheit", "°F", Dimension(temperature=1), to_base=5/9, offset=459.67)
+    
+    # Current
+    ampere = Unit("ampere", "A", Dimension(current=1))
+    milliampere = Unit("milliampere", "mA", Dimension(current=1), to_base=0.001)
+    
+    # Derived units
+    
+    # Force (kg·m/s²)
+    newton = Unit("newton", "N", Dimension(mass=1, length=1, time=-2))
+    
+    # Energy (kg·m²/s²)
+    joule = Unit("joule", "J", Dimension(mass=1, length=2, time=-2))
+    kilojoule = Unit("kilojoule", "kJ", Dimension(mass=1, length=2, time=-2), to_base=1000.0)
+    
+    # Power (kg·m²/s³)
+    watt = Unit("watt", "W", Dimension(mass=1, length=2, time=-3))
+    kilowatt = Unit("kilowatt", "kW", Dimension(mass=1, length=2, time=-3), to_base=1000.0)
+    
+    # Pressure (kg/(m·s²))
+    pascal = Unit("pascal", "Pa", Dimension(mass=1, length=-1, time=-2))
+    kilopascal = Unit("kilopascal", "kPa", Dimension(mass=1, length=-1, time=-2), to_base=1000.0)
+    
+    # Velocity (m/s)
+    meter_per_second = Unit("meter per second", "m/s", Dimension(length=1, time=-1))
+    kilometer_per_hour = Unit("kilometer per hour", "km/h", Dimension(length=1, time=-1), to_base=1000.0/3600.0)
+    
+    # Acceleration (m/s²)
+    meter_per_second_squared = Unit("meter per second squared", "m/s²", Dimension(length=1, time=-2))

unit_aware_arithmetic-1.0.0/pyproject.toml

@@ -0,0 +1,51 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "unit-aware-arithmetic"
+version = "1.0.0"
+authors = [
+    { name = "Parthiv Rawat", email = "parthiv05022000@gmail.com" },
+]
+description = "Type-safe dimensional arithmetic library with unit tracking"
+readme = "README.md"
+license = { file = "LICENSE" }
+requires-python = ">=3.7"
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Scientific/Engineering :: Physics",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.7",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Typing :: Typed",
+]
+keywords = ["units", "dimensions", "physics", "measurement", "type-safe", "dimensional-analysis"]
+
+[project.urls]
+Homepage = "https://github.com/parthivrawat/unit-aware-arithmetic"
+Repository = "https://github.com/parthivrawat/unit-aware-arithmetic.git"
+Issues = "https://github.com/parthivrawat/unit-aware-arithmetic/issues"
+
+[tool.setuptools]
+py-modules = ["dimensional"]
+
+[tool.setuptools.package-data]
+dimensional = ["py.typed"]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0.0",
+    "pytest-cov>=4.0.0",
+    "black>=23.0.0",
+    "mypy>=1.0.0",
+]

unit_aware_arithmetic-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

unit_aware_arithmetic-1.0.0/setup.py

@@ -0,0 +1,47 @@
+"""
+Setup script for unit-aware-arithmetic
+"""
+
+from setuptools import setup, find_packages
+
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+
+setup(
+    name="unit-aware-arithmetic",
+    version="1.0.0",
+    author="Parthiv Rawat",
+    author_email="parthiv05022000@gmail.com",
+    description="Type-safe dimensional arithmetic library with unit tracking",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/parthivrawat/unit-aware-arithmetic",
+    py_modules=["dimensional"],
+    classifiers=[
+        "Development Status :: 5 - Production/Stable",
+        "Intended Audience :: Developers",
+        "Intended Audience :: Science/Research",
+        "Topic :: Software Development :: Libraries :: Python Modules",
+        "Topic :: Scientific/Engineering :: Physics",
+        "License :: OSI Approved :: MIT License",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.7",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: 3.12",
+        "Typing :: Typed",
+    ],
+    python_requires=">=3.7",
+    install_requires=[],
+    extras_require={
+        "dev": [
+            "pytest>=7.0.0",
+            "pytest-cov>=4.0.0",
+            "black>=23.0.0",
+            "mypy>=1.0.0",
+        ],
+    },
+    keywords="units, dimensions, physics, measurement, type-safe, dimensional-analysis",
+)

unit_aware_arithmetic-1.0.0/unit_aware_arithmetic.egg-info/PKG-INFO

@@ -0,0 +1,299 @@
+Metadata-Version: 2.4
+Name: unit-aware-arithmetic
+Version: 1.0.0
+Summary: Type-safe dimensional arithmetic library with unit tracking
+Home-page: https://github.com/parthivrawat/unit-aware-arithmetic
+Author: Parthiv Rawat
+Author-email: Parthiv Rawat <parthiv05022000@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2026 Parthiv Rawat
+        
+        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.
+        
+Project-URL: Homepage, https://github.com/parthivrawat/unit-aware-arithmetic
+Project-URL: Repository, https://github.com/parthivrawat/unit-aware-arithmetic.git
+Project-URL: Issues, https://github.com/parthivrawat/unit-aware-arithmetic/issues
+Keywords: units,dimensions,physics,measurement,type-safe,dimensional-analysis
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# Unit-Aware Arithmetic (Python)
+
+A type-safe dimensional arithmetic library that tracks units at runtime and prevents invalid operations.
+
+## Features
+
+- ✅ **Type-safe dimensional analysis**: Prevents incompatible unit operations
+- ✅ **Zero dependencies**: Core functionality has no external dependencies
+- ✅ **Comprehensive unit coverage**: SI, imperial, and derived units
+- ✅ **Arithmetic operations**: Add, subtract, multiply, divide with unit tracking
+- ✅ **Unit conversion**: Automatic and explicit conversion between compatible units
+- ✅ **Clear error messages**: Helpful errors for incompatible operations
+- ✅ **Production-ready**: Comprehensive test coverage (>95%)
+
+## Installation
+
+```bash
+pip install -e .
+```
+
+## Quick Start
+
+```python
+from dimensional import Quantity, units
+
+# Create quantities with units
+distance = Quantity(100, units.meter)
+time = Quantity(9.58, units.second)
+
+# Arithmetic operations with automatic unit tracking
+speed = distance / time
+print(speed)  # 10.438413361169102 m/s
+
+# Unit conversion
+distance_km = distance.to(units.kilometer)
+print(distance_km)  # 0.1 km
+
+# Type-safe operations - this will raise an error!
+try:
+    distance + time  # IncompatibleUnitsError
+except Exception as e:
+    print(f"Error: {e}")
+```
+
+## Usage Examples
+
+### Basic Arithmetic
+
+```python
+from dimensional import Quantity, units
+
+# Addition (same dimension required)
+d1 = Quantity(5, units.meter)
+d2 = Quantity(3, units.meter)
+total = d1 + d2  # 8.0 m
+
+# Multiplication creates derived units
+area = Quantity(5, units.meter) * Quantity(3, units.meter)
+print(area)  # 15.0 m·m
+
+# Division creates derived units
+velocity = Quantity(100, units.meter) / Quantity(10, units.second)
+print(velocity)  # 10.0 m/s
+```
+
+### Unit Conversion
+
+```python
+from dimensional import Quantity, units
+
+# Length conversion
+distance = Quantity(1, units.mile)
+distance_km = distance.to(units.kilometer)
+print(distance_km)  # 1.60934 km
+
+# Temperature conversion
+temp_c = Quantity(0, units.celsius)
+temp_k = temp_c.to(units.kelvin)
+print(temp_k)  # 273.15 K
+
+# Mass conversion
+mass_lb = Quantity(10, units.pound)
+mass_kg = mass_lb.to(units.kilogram)
+print(mass_kg)  # 4.53592 kg
+```
+
+### Physics Calculations
+
+```python
+from dimensional import Quantity, units
+
+# Calculate velocity
+distance = Quantity(100, units.meter)
+time = Quantity(9.58, units.second)
+velocity = distance / time
+print(f"Velocity: {velocity}")
+
+# Calculate force (F = ma)
+mass = Quantity(10, units.kilogram)
+acceleration = Quantity(9.8, units.meter_per_second_squared)
+force = mass * acceleration
+print(f"Force: {force}")
+
+# Calculate kinetic energy (KE = 1/2 * m * v²)
+mass = Quantity(2, units.kilogram)
+velocity = Quantity(10, units.meter_per_second)
+ke = 0.5 * mass * (velocity ** 2)
+print(f"Kinetic Energy: {ke}")
+```
+
+### Comparison Operations
+
+```python
+from dimensional import Quantity, units
+
+d1 = Quantity(100, units.centimeter)
+d2 = Quantity(1, units.meter)
+
+# Automatic conversion for comparison
+print(d1 == d2)  # True
+print(d1 < Quantity(2, units.meter))  # True
+```
+
+## Available Units
+
+### Length
+- `meter`, `kilometer`, `centimeter`, `millimeter`
+- `inch`, `foot`, `yard`, `mile`
+
+### Mass
+- `kilogram`, `gram`, `milligram`, `tonne`
+- `pound`, `ounce`
+
+### Time
+- `second`, `minute`, `hour`, `day`
+
+### Temperature
+- `kelvin`, `celsius`, `fahrenheit`
+
+### Current
+- `ampere`, `milliampere`
+
+### Derived Units
+- `newton` (force)
+- `joule`, `kilojoule` (energy)
+- `watt`, `kilowatt` (power)
+- `pascal`, `kilopascal` (pressure)
+- `meter_per_second`, `kilometer_per_hour` (velocity)
+- `meter_per_second_squared` (acceleration)
+
+## Error Handling
+
+The library provides clear error messages for invalid operations:
+
+```python
+from dimensional import Quantity, units, IncompatibleUnitsError
+
+distance = Quantity(100, units.meter)
+time = Quantity(10, units.second)
+
+try:
+    # This will raise IncompatibleUnitsError
+    result = distance + time
+except IncompatibleUnitsError as e:
+    print(e)  # "Cannot add m and s: incompatible dimensions"
+```
+
+## Testing
+
+Run the test suite:
+
+```bash
+pytest test_dimensional.py -v
+```
+
+Run with coverage:
+
+```bash
+pytest test_dimensional.py --cov=dimensional --cov-report=html
+```
+
+## Type Checking
+
+This library includes type hints. Run type checking with:
+
+```bash
+mypy dimensional.py
+```
+
+## Design Principles
+
+1. **Zero Dependencies**: Core functionality has no external dependencies
+2. **Type Safety**: Prevents invalid operations at runtime
+3. **Clear Errors**: Actionable error messages
+4. **Production Ready**: Comprehensive test coverage
+5. **Performance**: Efficient implementation with minimal overhead
+
+## API Reference
+
+### `Dimension`
+
+Represents the dimensional formula of a unit (e.g., L^1 T^-2 for acceleration).
+
+### `Unit`
+
+Represents a unit of measurement with its dimension and conversion factor.
+
+### `Quantity`
+
+A numeric value with an associated unit. Supports:
+- Arithmetic: `+`, `-`, `*`, `/`, `**`, `-` (negation), `abs()`
+- Comparison: `==`, `!=`, `<`, `<=`, `>`, `>=`
+- Conversion: `.to(target_unit)`
+
+### `units`
+
+Namespace containing all predefined units.
+
+## License
+
+MIT License
+
+## Contributing
+
+Contributions are welcome! Please ensure:
+- All tests pass
+- Code coverage remains >90%
+- Type hints are included
+- Documentation is updated
+
+## Changelog
+
+### 1.0.0 (2026-08-28)
+- Initial release
+- Support for SI and imperial units
+- Comprehensive dimensional analysis
+- Temperature conversion with offset handling
+- Full test coverage

unit_aware_arithmetic-1.0.0/unit_aware_arithmetic.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+MANIFEST.in
+README.md
+dimensional.py
+py.typed
+pyproject.toml
+setup.py
+unit_aware_arithmetic.egg-info/PKG-INFO
+unit_aware_arithmetic.egg-info/SOURCES.txt
+unit_aware_arithmetic.egg-info/dependency_links.txt
+unit_aware_arithmetic.egg-info/requires.txt
+unit_aware_arithmetic.egg-info/top_level.txt

unit_aware_arithmetic-1.0.0/unit_aware_arithmetic.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

unit_aware_arithmetic-1.0.0/unit_aware_arithmetic.egg-info/requires.txt

@@ -0,0 +1,6 @@
+
+[dev]
+pytest>=7.0.0
+pytest-cov>=4.0.0
+black>=23.0.0
+mypy>=1.0.0

unit_aware_arithmetic-1.0.0/unit_aware_arithmetic.egg-info/top_level.txt

@@ -0,0 +1 @@
+dimensional