qnty 0.0.1__py3-none-any.whl → 0.0.3__py3-none-any.whl

qnty/__init__.py

@@ -0,0 +1,175 @@
+"""
+Qnty - High-Performance Unit System for Engineering
+====================================================
+
+A fast, type-safe unit system library for Python with dimensional safety
+and optimized unit conversions for engineering calculations.
+"""
+
+from .dimension import BaseDimension, DimensionSignature
+from .equation import Equation
+from .expression import Expression
+from .unit import registry
+from .units import register_all_units
+from .variable import FastQuantity, TypeSafeSetter, TypeSafeVariable
+from .variables import (
+    AbsorbedDose,
+    Acceleration,
+    ActivationEnergy,
+    AmountOfSubstance,
+    AnglePlane,
+    AngleSolid,
+    AngularAcceleration,
+    AngularMomentum,
+    Area,
+    AreaPerUnitVolume,
+    AtomicWeight,
+    Concentration,
+    DynamicFluidity,
+    ElectricCapacitance,
+    ElectricCharge,
+    ElectricCurrentIntensity,
+    ElectricDipoleMoment,
+    ElectricFieldStrength,
+    ElectricInductance,
+    ElectricPotential,
+    ElectricResistance,
+    ElectricalConductance,
+    ElectricalPermittivity,
+    ElectricalResistivity,
+    EnergyFlux,
+    EnergyHeatWork,
+    EnergyPerUnitArea,
+    Force,
+    ForceBody,
+    ForcePerUnitMass,
+    FrequencyVoltageRatio,
+    FuelConsumption,
+    HeatOfCombustion,
+    HeatOfFusion,
+    HeatOfVaporization,
+    HeatTransferCoefficient,
+    Illuminance,
+    KineticEnergyOfTurbulence,
+    Length,
+    LinearMassDensity,
+    LinearMomentum,
+    LuminanceSelf,
+    LuminousFlux,
+    LuminousIntensity,
+    MagneticField,
+    MagneticFlux,
+    MagneticInductionFieldStrength,
+    MagneticMoment,
+    MagneticPermeability,
+    MagnetomotiveForce,
+    Mass,
+    MassDensity,
+    MassFlowRate,
+    MassFlux,
+    MassFractionOfI,
+    MassTransferCoefficient,
+    MolalityOfSoluteI,
+    MolarConcentrationByMass,
+    MolarFlowRate,
+    MolarFlux,
+    MolarHeatCapacity,
+    MolarityOfI,
+    MoleFractionOfI,
+    MomentOfInertia,
+    MomentumFlowRate,
+    MomentumFlux,
+    NormalityOfSolution,
+    ParticleDensity,
+    Permeability,
+    PhotonEmissionRate,
+    PowerPerUnitMass,
+    PowerPerUnitVolume,
+    PowerThermalDuty,
+    Pressure,
+    RadiationDoseEquivalent,
+    RadiationExposure,
+    Radioactivity,
+    SecondMomentOfArea,
+    SecondRadiationConstantPlanck,
+    SpecificEnthalpy,
+    SpecificGravity,
+    SpecificHeatCapacityConstantPressure,
+    SpecificLength,
+    SpecificSurface,
+    SpecificVolume,
+    Stress,
+    SurfaceMassDensity,
+    SurfaceTension,
+    Temperature,
+    ThermalConductivity,
+    Time,
+    Torque,
+    TurbulenceEnergyDissipationRate,
+    VelocityAngular,
+    VelocityLinear,
+    ViscosityDynamic,
+    ViscosityKinematic,
+    Volume,
+    VolumeFractionOfI,
+    VolumetricCalorificHeatingValue,
+    VolumetricCoefficientOfExpansion,
+    VolumetricFlowRate,
+    VolumetricFlux,
+    VolumetricMassFlowRate,
+    Wavenumber
+)
+
+# Register all units to the global registry
+register_all_units(registry)
+
+# Finalize registry after all registrations
+registry.finalize_registration()
+
+# Version information
+__version__ = "0.0.3"
+
+# Define public API
+__all__ = [
+    # Core variable types (most commonly used)
+    "Length", "Pressure", "Temperature", "Time", "Mass", "Volume", "Area",
+    "Force", "EnergyHeatWork", "PowerThermalDuty",
+
+    # Core classes for advanced usage
+    "FastQuantity", "TypeSafeVariable", "TypeSafeSetter",
+    "DimensionSignature", "BaseDimension",
+    "Expression", "Equation",
+
+    # All other variable types (95 additional types)
+    "AbsorbedDose", "Acceleration", "ActivationEnergy", "AmountOfSubstance",
+    "AnglePlane", "AngleSolid", "AngularAcceleration", "AngularMomentum",
+    "AreaPerUnitVolume", "AtomicWeight", "Concentration", "DynamicFluidity",
+    "ElectricCapacitance", "ElectricCharge", "ElectricCurrentIntensity",
+    "ElectricDipoleMoment", "ElectricFieldStrength", "ElectricInductance",
+    "ElectricPotential", "ElectricResistance", "ElectricalConductance",
+    "ElectricalPermittivity", "ElectricalResistivity", "EnergyFlux",
+    "EnergyPerUnitArea", "ForceBody", "ForcePerUnitMass",
+    "FrequencyVoltageRatio", "FuelConsumption", "HeatOfCombustion",
+    "HeatOfFusion", "HeatOfVaporization", "HeatTransferCoefficient",
+    "Illuminance", "KineticEnergyOfTurbulence", "LinearMassDensity",
+    "LinearMomentum", "LuminanceSelf", "LuminousFlux", "LuminousIntensity",
+    "MagneticField", "MagneticFlux", "MagneticInductionFieldStrength",
+    "MagneticMoment", "MagneticPermeability", "MagnetomotiveForce",
+    "MassDensity", "MassFlowRate", "MassFlux", "MassFractionOfI",
+    "MassTransferCoefficient", "MolalityOfSoluteI", "MolarConcentrationByMass",
+    "MolarFlowRate", "MolarFlux", "MolarHeatCapacity", "MolarityOfI",
+    "MoleFractionOfI", "MomentOfInertia", "MomentumFlowRate", "MomentumFlux",
+    "NormalityOfSolution", "ParticleDensity", "Permeability",
+    "PhotonEmissionRate", "PowerPerUnitMass", "PowerPerUnitVolume",
+    "RadiationDoseEquivalent", "RadiationExposure", "Radioactivity",
+    "SecondMomentOfArea", "SecondRadiationConstantPlanck", "SpecificEnthalpy",
+    "SpecificGravity", "SpecificHeatCapacityConstantPressure",
+    "SpecificLength", "SpecificSurface", "SpecificVolume", "Stress",
+    "SurfaceMassDensity", "SurfaceTension", "ThermalConductivity", "Torque",
+    "TurbulenceEnergyDissipationRate", "VelocityAngular", "VelocityLinear",
+    "ViscosityDynamic", "ViscosityKinematic", "VolumeFractionOfI",
+    "VolumetricCalorificHeatingValue", "VolumetricCoefficientOfExpansion",
+    "VolumetricFlowRate", "VolumetricFlux", "VolumetricMassFlowRate",
+    "Wavenumber",
+]
+

qnty/dimension.py

@@ -5,14 +5,15 @@ Dimension System
 Compile-time dimensional analysis using type system for ultra-fast operations.
 """
 
-from typing import final
 from dataclasses import dataclass
 from enum import IntEnum
+from typing import final
+
 
 class BaseDimension(IntEnum):
     """Base dimensions as prime numbers for efficient bit operations."""
     LENGTH = 2
-    MASS = 3  
+    MASS = 3
     TIME = 5
     CURRENT = 7
     TEMPERATURE = 11
@@ -71,15 +72,113 @@ class DimensionSignature:
         return hash(self._signature)
 
 
-# Pre-defined dimension constants
-DIMENSIONLESS = DimensionSignature.create()
-LENGTH = DimensionSignature.create(length=1)
-MASS = DimensionSignature.create(mass=1) 
-TIME = DimensionSignature.create(time=1)
-AREA = DimensionSignature.create(length=2)
-VOLUME = DimensionSignature.create(length=3)
-VELOCITY = DimensionSignature.create(length=1, time=-1)
-ACCELERATION = DimensionSignature.create(length=1, time=-2)
-FORCE = DimensionSignature.create(mass=1, length=1, time=-2)
-PRESSURE = DimensionSignature.create(mass=1, length=-1, time=-2)
-ENERGY = DimensionSignature.create(mass=1, length=2, time=-2)
+# Pre-defined dimension constants (alphabetically ordered)
+ABSORBED_DOSE = DimensionSignature.create(length=2, time=-2)  # L^2 T^-2
+ACCELERATION = DimensionSignature.create(length=1, time=-2)  # L T^-2
+ACTIVATION_ENERGY = DimensionSignature.create(amount=-1, length=2, time=-2)  # N^-1 L^2 T^-2
+AMOUNT = DimensionSignature.create(amount=1)  # N
+AMOUNT_OF_SUBSTANCE = DimensionSignature.create(amount=1)  # N
+ANGLE_PLANE = DimensionSignature.create()  # Dimensionless
+ANGLE_SOLID = DimensionSignature.create()  # Dimensionless
+ANGULAR_ACCELERATION = DimensionSignature.create(time=-2)  # T^-2
+ANGULAR_MOMENTUM = DimensionSignature.create(length=2, mass=1, time=-1)  # L^2 M T^-1
+AREA = DimensionSignature.create(length=2)  # L^2
+AREA_PER_UNIT_VOLUME = DimensionSignature.create(length=-1)  # L^-1
+ATOMIC_WEIGHT = DimensionSignature.create(amount=-1, mass=1)  # N^-1 M
+CONCENTRATION = DimensionSignature.create(length=-3, mass=1)  # L^-3 M
+CURRENT = DimensionSignature.create(current=1)  # A
+DIMENSIONLESS = DimensionSignature.create()  # Dimensionless
+DYNAMIC_FLUIDITY = DimensionSignature.create(length=1, mass=-1, time=1)  # L M^-1 T
+ELECTRICAL_CONDUCTANCE = DimensionSignature.create(current=2, length=-2, mass=-1, time=3)  # A^2 L^-2 M^-1 T^3
+ELECTRICAL_PERMITTIVITY = DimensionSignature.create(current=2, length=-3, mass=-1, time=4)  # A^2 L^-3 M^-1 T^4
+ELECTRICAL_RESISTIVITY = DimensionSignature.create(current=-2, length=3, mass=1, time=-3)  # A^-2 L^3 M T^-3
+ELECTRIC_CAPACITANCE = DimensionSignature.create(current=2, length=-2, mass=-1, time=4)  # A^2 L^-2 M^-1 T^4
+ELECTRIC_CHARGE = DimensionSignature.create(amount=-1, current=1, time=1)  # N^-1 A T
+ELECTRIC_CURRENT_INTENSITY = DimensionSignature.create(current=1)  # A
+ELECTRIC_DIPOLE_MOMENT = DimensionSignature.create(current=1, length=1, time=1)  # A L T
+ELECTRIC_FIELD_STRENGTH = DimensionSignature.create(current=-1, length=1, mass=1, time=-3)  # A^-1 L M T^-3
+ELECTRIC_INDUCTANCE = DimensionSignature.create(current=-2, length=2, mass=1, time=-2)  # A^-2 L^2 M T^-2
+ELECTRIC_POTENTIAL = DimensionSignature.create(current=-1, length=2, mass=1, time=-3)  # A^-1 L^2 M T^-3
+ELECTRIC_RESISTANCE = DimensionSignature.create(current=-2, length=2, mass=1, time=-3)  # A^-2 L^2 M T^-3
+ENERGY_FLUX = DimensionSignature.create(mass=1, time=-3)  # M T^-3
+ENERGY_HEAT_WORK = DimensionSignature.create(length=2, mass=1, time=-2)  # L^2 M T^-2
+ENERGY_PER_UNIT_AREA = DimensionSignature.create(mass=1, time=-2)  # M T^-2
+FORCE = DimensionSignature.create(length=1, mass=1, time=-2)  # L M T^-2
+FORCE_BODY = DimensionSignature.create(length=-2, mass=1, time=-2)  # L^-2 M T^-2
+FORCE_PER_UNIT_MASS = DimensionSignature.create(length=1, time=-2)  # L T^-2
+FREQUENCY_VOLTAGE_RATIO = DimensionSignature.create(current=1, length=-2, mass=-1, time=3)  # A L^-2 M^-1 T^3
+FUEL_CONSUMPTION = DimensionSignature.create(length=-2)  # L^-2
+HEAT_OF_COMBUSTION = DimensionSignature.create(length=2, time=-2)  # L^2 T^-2
+HEAT_OF_FUSION = DimensionSignature.create(length=2, time=-2)  # L^2 T^-2
+HEAT_OF_VAPORIZATION = DimensionSignature.create(length=2, time=-2)  # L^2 T^-2
+HEAT_TRANSFER_COEFFICIENT = DimensionSignature.create(mass=1, temp=-1, time=-3)  # M Θ^-1 T^-3
+ILLUMINANCE = DimensionSignature.create(length=-2, luminosity=1)  # L^-2 J
+KINETIC_ENERGY_OF_TURBULENCE = DimensionSignature.create(length=2, time=-2)  # L^2 T^-2
+LENGTH = DimensionSignature.create(length=1)  # L
+LINEAR_MASS_DENSITY = DimensionSignature.create(length=-1, mass=1)  # L^-1 M
+LINEAR_MOMENTUM = DimensionSignature.create(length=1, mass=1, time=-1)  # L M T^-1
+LUMINANCE_SELF = DimensionSignature.create(length=-2, luminosity=1)  # L^-2 J
+LUMINOSITY = DimensionSignature.create(luminosity=1)  # J
+LUMINOUS_FLUX = DimensionSignature.create(luminosity=1)  # J
+LUMINOUS_INTENSITY = DimensionSignature.create(luminosity=1)  # J
+MAGNETIC_FIELD = DimensionSignature.create(current=1, length=-1)  # A L^-1
+MAGNETIC_FLUX = DimensionSignature.create(current=-1, length=2, mass=1, time=-2)  # A^-1 L^2 M T^-2
+MAGNETIC_INDUCTION_FIELD_STRENGTH = DimensionSignature.create(current=-1, mass=1, time=-2)  # A^-1 M T^-2
+MAGNETIC_MOMENT = DimensionSignature.create(current=1, length=2)  # A L^2
+MAGNETIC_PERMEABILITY = DimensionSignature.create(current=-2, length=2, mass=1, time=-2)  # A^-2 L^2 M T^-2
+MAGNETOMOTIVE_FORCE = DimensionSignature.create(current=1)  # A
+MASS = DimensionSignature.create(mass=1)  # M
+MASS_DENSITY = DimensionSignature.create(length=-3, mass=1)  # L^-3 M
+MASS_FLOW_RATE = DimensionSignature.create(mass=1, time=-1)  # M T^-1
+MASS_FLUX = DimensionSignature.create(length=-2, mass=1, time=-1)  # L^-2 M T^-1
+MASS_FRACTION_OF_I = DimensionSignature.create()  # Dimensionless
+MASS_TRANSFER_COEFFICIENT = DimensionSignature.create(length=-2, mass=1, time=-1)  # L^-2 M T^-1
+MOLALITY_OF_SOLUTE_I = DimensionSignature.create(amount=1, mass=-1)  # N M^-1
+MOLARITY_OF_I = DimensionSignature.create(amount=1, length=-3)  # N L^-3
+MOLAR_CONCENTRATION_BY_MASS = DimensionSignature.create(amount=1)  # N
+MOLAR_FLOW_RATE = DimensionSignature.create(amount=1, time=-1)  # N T^-1
+MOLAR_FLUX = DimensionSignature.create(amount=1, length=-2, time=-1)  # N L^-2 T^-1
+MOLAR_HEAT_CAPACITY = DimensionSignature.create(amount=-1, length=2, temp=-1, time=-2)  # N^-1 L^2 Θ^-1 T^-2
+MOLE_FRACTION_OF_I = DimensionSignature.create()  # Dimensionless
+MOMENTUM_FLOW_RATE = DimensionSignature.create(length=1, mass=1, time=-2)  # L M T^-2
+MOMENTUM_FLUX = DimensionSignature.create(length=-1, mass=1, time=-2)  # L^-1 M T^-2
+MOMENT_OF_INERTIA = DimensionSignature.create(length=2, mass=1)  # L^2 M
+NORMALITY_OF_SOLUTION = DimensionSignature.create(amount=1, length=-3)  # N L^-3
+PARTICLE_DENSITY = DimensionSignature.create(length=-3)  # L^-3
+PERMEABILITY = DimensionSignature.create(length=2)  # L^2
+PHOTON_EMISSION_RATE = DimensionSignature.create(length=-2, time=-1)  # L^-2 T^-1
+POWER_PER_UNIT_MASS = DimensionSignature.create(length=2, time=-3)  # L^2 T^-3
+POWER_PER_UNIT_VOLUME = DimensionSignature.create(length=-1, mass=1, time=-3)  # L^-1 M T^-3
+POWER_THERMAL_DUTY = DimensionSignature.create(length=2, mass=1, time=-3)  # L^2 M T^-3
+PRESSURE = DimensionSignature.create(length=-1, mass=1, time=-2)  # L^-1 M T^-2
+RADIATION_DOSE_EQUIVALENT = DimensionSignature.create(length=2, time=-2)  # L^2 T^-2
+RADIATION_EXPOSURE = DimensionSignature.create(current=1, mass=-1, time=1)  # A M^-1 T
+RADIOACTIVITY = DimensionSignature.create(time=-1)  # T^-1
+SECOND_MOMENT_OF_AREA = DimensionSignature.create(length=4)  # L^4
+SECOND_RADIATION_CONSTANT_PLANCK = DimensionSignature.create(length=1, temp=1)  # L Θ
+SPECIFIC_ENTHALPY = DimensionSignature.create(length=2, time=-2)  # L^2 T^-2
+SPECIFIC_GRAVITY = DimensionSignature.create()  # Dimensionless
+SPECIFIC_HEAT_CAPACITY_CONSTANT_PRESSURE = DimensionSignature.create(length=2, mass=1, temp=-1, time=-2)  # L^2 M Θ^-1 T^-2
+SPECIFIC_LENGTH = DimensionSignature.create(length=1, mass=-1)  # L M^-1
+SPECIFIC_SURFACE = DimensionSignature.create(length=2, mass=-1)  # L^2 M^-1
+SPECIFIC_VOLUME = DimensionSignature.create(length=3, mass=-1)  # L^3 M^-1
+STRESS = DimensionSignature.create(length=-1, mass=1, time=-2)  # L^-1 M T^-2
+SURFACE_MASS_DENSITY = DimensionSignature.create(length=-2, mass=1)  # L^-2 M
+SURFACE_TENSION = DimensionSignature.create(mass=1, time=-2)  # M T^-2
+TEMPERATURE = DimensionSignature.create(temp=1)  # Θ
+THERMAL_CONDUCTIVITY = DimensionSignature.create(length=1, mass=1, temp=1, time=-3)  # L M Θ T^-3
+TIME = DimensionSignature.create(time=1)  # T
+TORQUE = DimensionSignature.create(length=2, mass=1, time=-2)  # L^2 M T^-2
+TURBULENCE_ENERGY_DISSIPATION_RATE = DimensionSignature.create(length=2, time=-3)  # L^2 T^-3
+VELOCITY_ANGULAR = DimensionSignature.create(time=-1)  # T^-1
+VELOCITY_LINEAR = DimensionSignature.create(length=1, time=-1)  # L T^-1
+VISCOSITY_DYNAMIC = DimensionSignature.create(length=-1, mass=1, time=-1)  # L^-1 M T^-1
+VISCOSITY_KINEMATIC = DimensionSignature.create(length=2, time=-1)  # L^2 T^-1
+VOLUME = DimensionSignature.create(length=3)  # L^3
+VOLUMETRIC_CALORIFIC_HEATING_VALUE = DimensionSignature.create(length=-1, mass=1, time=-2)  # L^-1 M T^-2
+VOLUMETRIC_COEFFICIENT_OF_EXPANSION = DimensionSignature.create(length=-3, mass=1, temp=-1)  # L^-3 M Θ^-1
+VOLUMETRIC_FLOW_RATE = DimensionSignature.create(length=3, time=-1)  # L^3 T^-1
+VOLUMETRIC_FLUX = DimensionSignature.create(length=1, time=-1)  # L T^-1
+VOLUMETRIC_MASS_FLOW_RATE = DimensionSignature.create(length=-3, mass=1, time=-1)  # L^-3 M T^-1
+VOLUME_FRACTION_OF_I = DimensionSignature.create()  # Dimensionless
+WAVENUMBER = DimensionSignature.create(length=-1)  # L^-1

qnty/equation.py

@@ -0,0 +1,216 @@
+"""
+Equation System
+===============
+
+Mathematical equations for qnty variables with solving capabilities.
+"""
+
+from __future__ import annotations
+
+from typing import cast
+
+from .expression import Expression, VariableReference
+from .variable import TypeSafeVariable
+
+
+class Equation:
+    """Represents a mathematical equation with left-hand side equal to right-hand side."""
+    
+    def __init__(self, name: str, lhs: TypeSafeVariable | Expression, rhs: Expression):
+        self.name = name
+        
+        # Convert Variable to VariableReference if needed
+        # Use duck typing to avoid circular import
+        if hasattr(lhs, 'name') and hasattr(lhs, 'quantity') and hasattr(lhs, 'is_known'):
+            # It's a TypeSafeVariable-like object
+            self.lhs = VariableReference(cast('TypeSafeVariable', lhs))
+        else:
+            # It's already an Expression
+            self.lhs = cast(Expression, lhs)
+            
+        self.rhs = rhs
+        self.variables = self.get_all_variables()
+    
+    def get_all_variables(self) -> set[str]:
+        """Get all variable names used in this equation."""
+        # Both lhs and rhs should be Expressions after __init__ conversion
+        lhs_vars = self.lhs.get_variables()
+        rhs_vars = self.rhs.get_variables()
+        return lhs_vars | rhs_vars
+    
+    def get_unknown_variables(self, known_vars: set[str]) -> set[str]:
+        """Get variables that are unknown (not in known_vars set)."""
+        return self.variables - known_vars
+    
+    def get_known_variables(self, known_vars: set[str]) -> set[str]:
+        """Get variables that are known (in known_vars set)."""
+        return self.variables & known_vars
+    
+    def can_solve_for(self, target_var: str, known_vars: set[str]) -> bool:
+        """Check if this equation can solve for target_var given known_vars."""
+        if target_var not in self.variables:
+            return False
+        # Direct assignment case: lhs is the variable
+        if isinstance(self.lhs, VariableReference) and self.lhs.name == target_var:
+            rhs_vars = self.rhs.get_variables()
+            return rhs_vars.issubset(known_vars)
+        unknown_vars = self.get_unknown_variables(known_vars)
+        # Can solve if target_var is the only unknown
+        return unknown_vars == {target_var}
+    
+    def solve_for(self, target_var: str, variable_values: dict[str, TypeSafeVariable]) -> TypeSafeVariable:
+        """
+        Solve the equation for target_var.
+        Returns the target variable with updated quantity.
+        """
+        if target_var not in self.variables:
+            raise ValueError(f"Variable '{target_var}' not found in equation")
+        
+        # Handle direct assignment: target = expression
+        if isinstance(self.lhs, VariableReference) and self.lhs.name == target_var:
+            # Direct assignment: target_var = rhs
+            result_qty = self.rhs.evaluate(variable_values)
+            
+            # Update existing variable object to preserve references
+            var_obj = variable_values.get(target_var)
+            if var_obj is not None:
+                # Convert result to the target variable's original unit if it had one
+                if var_obj.quantity is not None and var_obj.quantity.unit is not None:
+                    # Convert to the target variable's defined unit
+                    try:
+                        result_qty = result_qty.to(var_obj.quantity.unit)
+                    except Exception:
+                        # If conversion fails, keep the calculated unit
+                        pass
+                
+                var_obj.quantity = result_qty
+                var_obj.is_known = True
+                return var_obj
+            
+            # Create new variable if not found - this shouldn't happen in normal usage
+            raise ValueError(f"Variable '{target_var}' not found in variable_values")
+        
+        # For more complex equations, we would need algebraic manipulation
+        # Currently focusing on direct assignment which covers most engineering cases
+        raise NotImplementedError(f"Cannot solve for {target_var} in equation {self}. "
+                                f"Only direct assignment equations (var = expression) are supported.")
+    
+    def check_residual(self, variable_values: dict[str, TypeSafeVariable], tolerance: float = 1e-10) -> bool:
+        """
+        Check if equation is satisfied by evaluating residual (LHS - RHS).
+        Returns True if |residual| < tolerance, accounting for units.
+        """
+        try:
+            # Both lhs and rhs should be Expressions after __init__ conversion
+            lhs_value = self.lhs.evaluate(variable_values)
+            rhs_value = self.rhs.evaluate(variable_values)
+            
+            # Check dimensional compatibility
+            if lhs_value._dimension_sig != rhs_value._dimension_sig:
+                return False
+            
+            # Convert to same units for comparison
+            rhs_converted = rhs_value.to(lhs_value.unit)
+            residual = abs(lhs_value.value - rhs_converted.value)
+            
+            return residual < tolerance
+        except Exception:
+            return False
+    
+    def __str__(self) -> str:
+        return f"{self.lhs} = {self.rhs}"
+    
+    def __repr__(self) -> str:
+        return f"Equation(name='{self.name}', lhs={self.lhs!r}, rhs={self.rhs!r})"
+
+
+class EquationSystem:
+    """System of equations that can be solved together."""
+    
+    def __init__(self, equations: list[Equation] | None = None):
+        self.equations = equations or []
+        self.variables = {}  # Dict[str, TypeSafeVariable]
+    
+    def add_equation(self, equation: Equation):
+        """Add an equation to the system."""
+        self.equations.append(equation)
+    
+    def add_variable(self, variable: TypeSafeVariable):
+        """Add a variable to the system."""
+        self.variables[variable.name] = variable
+    
+    def get_known_variables(self) -> set[str]:
+        """Get names of all known variables."""
+        return {name for name, var in self.variables.items() if var.is_known and var.quantity is not None}
+    
+    def get_unknown_variables(self) -> set[str]:
+        """Get names of all unknown variables."""
+        return {name for name, var in self.variables.items() if not var.is_known or var.quantity is None}
+    
+    def can_solve_any(self) -> bool:
+        """Check if any equation can be solved with current known variables."""
+        known_vars = self.get_known_variables()
+        unknown_vars = self.get_unknown_variables()
+        
+        for equation in self.equations:
+            for unknown_var in unknown_vars:
+                if equation.can_solve_for(unknown_var, known_vars):
+                    return True
+        return False
+    
+    def solve_step(self) -> bool:
+        """Solve one step - find and solve one equation. Returns True if progress made."""
+        known_vars = self.get_known_variables()
+        unknown_vars = self.get_unknown_variables()
+        
+        # Find an equation that can be solved
+        for equation in self.equations:
+            for unknown_var in unknown_vars:
+                if equation.can_solve_for(unknown_var, known_vars):
+                    # Solve for this variable
+                    equation.solve_for(unknown_var, self.variables)
+                    return True  # Progress made
+        
+        return False  # No progress possible
+    
+    def solve(self, max_iterations: int = 100) -> bool:
+        """Solve the system iteratively. Returns True if fully solved."""
+        for _ in range(max_iterations):
+            if not self.can_solve_any():
+                break
+            if not self.solve_step():
+                break
+        
+        # Check if all variables are known
+        unknown_vars = self.get_unknown_variables()
+        return len(unknown_vars) == 0
+    
+    def get_solving_order(self) -> list[str]:
+        """Get the order in which variables can be solved."""
+        order = []
+        temp_system = EquationSystem(self.equations.copy())
+        temp_system.variables = self.variables.copy()
+        
+        while temp_system.can_solve_any():
+            known_vars = temp_system.get_known_variables()
+            unknown_vars = temp_system.get_unknown_variables()
+            
+            # Find next solvable variable
+            for equation in temp_system.equations:
+                for unknown_var in unknown_vars:
+                    if equation.can_solve_for(unknown_var, known_vars):
+                        order.append(unknown_var)
+                        # Mark as known for next iteration
+                        temp_system.variables[unknown_var].is_known = True
+                        break
+                else:
+                    continue
+                break
+        
+        return order
+    
+    def __str__(self) -> str:
+        return f"EquationSystem({len(self.equations)} equations, {len(self.variables)} variables)"
+    
+    def __repr__(self) -> str:
+        return f"EquationSystem(equations={self.equations!r})"