qnty 0.0.8__py3-none-any.whl → 0.1.0__py3-none-any.whl

qnty/dimension.py

@@ -1,186 +0,0 @@
-"""
-Dimension System
-================
-
-Compile-time dimensional analysis using type system for ultra-fast operations.
-"""
-
-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
-    TIME = 5
-    CURRENT = 7
-    TEMPERATURE = 11
-    AMOUNT = 13
-    LUMINOSITY = 17
-    DIMENSIONLESS = 1  # Must be 1 to act as multiplicative identity
-
-
-@final
-@dataclass(frozen=True)
-class DimensionSignature:
-    """Immutable dimension signature for zero-cost dimensional analysis."""
-    
-    # Store as bit pattern for ultra-fast comparison
-    _signature: int | float = 1
-    
-    @classmethod
-    def create(cls, length=0, mass=0, time=0, current=0, temp=0, amount=0, luminosity=0):
-        """Create dimension from exponents."""
-        signature = 1
-        if length != 0:
-            signature *= BaseDimension.LENGTH ** length
-        if mass != 0:
-            signature *= BaseDimension.MASS ** mass
-        if time != 0:
-            signature *= BaseDimension.TIME ** time
-        if current != 0:
-            signature *= BaseDimension.CURRENT ** current
-        if temp != 0:
-            signature *= BaseDimension.TEMPERATURE ** temp
-        if amount != 0:
-            signature *= BaseDimension.AMOUNT ** amount
-        if luminosity != 0:
-            signature *= BaseDimension.LUMINOSITY ** luminosity
-        
-        return cls(signature)
-    
-    def __mul__(self, other):
-        return DimensionSignature(self._signature * other._signature)
-    
-    def __truediv__(self, other):
-        return DimensionSignature(self._signature / other._signature)
-    
-    def __pow__(self, power):
-        return DimensionSignature(self._signature ** power)
-    
-    def is_compatible(self, other):
-        """Ultra-fast dimensional compatibility check."""
-        return self._signature == other._signature
-    
-    def __eq__(self, other):
-        """Fast equality check for dimensions."""
-        return isinstance(other, DimensionSignature) and self._signature == other._signature
-    
-    def __hash__(self):
-        """Enable dimensions as dictionary keys."""
-        return hash(self._signature)
-
-
-# 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(BaseDimension.DIMENSIONLESS)  # Dimensionless
-ANGLE_SOLID = DimensionSignature(BaseDimension.DIMENSIONLESS)  # 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(BaseDimension.DIMENSIONLESS)  # 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(BaseDimension.DIMENSIONLESS)  # 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(BaseDimension.DIMENSIONLESS)  # 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
-PERCENT = DimensionSignature(BaseDimension.DIMENSIONLESS)  # Dimensionless
-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(BaseDimension.DIMENSIONLESS)  # 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(BaseDimension.DIMENSIONLESS)  # Dimensionless
-WAVENUMBER = DimensionSignature.create(length=-1)  # L^-1

qnty/equation.py

@@ -1,297 +0,0 @@
-"""
-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 _discover_variables_from_scope(self) -> dict[str, TypeSafeVariable]:
-        """Automatically discover variables from the calling scope."""
-        import inspect
-        
-        # Get the frame that called this method (skip through __str__ calls)
-        frame = inspect.currentframe()
-        try:
-            # Skip frames until we find one outside the equation system
-            while frame and (
-                frame.f_code.co_filename.endswith(('equation.py', 'expression.py')) or
-                frame.f_code.co_name in ['__str__', '__repr__']
-            ):
-                frame = frame.f_back
-            
-            if not frame:
-                return {}
-                
-            # Combine local and global variables
-            all_vars = {**frame.f_globals, **frame.f_locals}
-            
-            # Find TypeSafeVariable objects that match our required variables
-            required_vars = self.variables
-            discovered = {}
-            
-            for var_name in required_vars:
-                for name, obj in all_vars.items():
-                    if hasattr(obj, 'symbol') and obj.symbol == var_name:
-                        discovered[var_name] = obj
-                        break
-                    elif hasattr(obj, 'name') and obj.name == var_name:
-                        discovered[var_name] = obj
-                        break
-            
-            return discovered
-            
-        finally:
-            del frame
-    
-    def _can_auto_solve(self) -> tuple[bool, str, dict[str, TypeSafeVariable]]:
-        """Check if equation can be auto-solved from scope."""
-        try:
-            discovered = self._discover_variables_from_scope()
-            
-            # Check if this is a simple assignment equation (one unknown)
-            unknowns = []
-            knowns = []
-            
-            for var_name in self.variables:
-                if var_name in discovered:
-                    var = discovered[var_name]
-                    if hasattr(var, 'is_known') and not var.is_known:
-                        unknowns.append(var_name)
-                    elif hasattr(var, 'quantity') and var.quantity is not None:
-                        knowns.append(var_name)
-                    else:
-                        unknowns.append(var_name)  # Assume unknown if no quantity
-                else:
-                    return False, "", {}  # Missing variable
-            
-            # Can only auto-solve if there's exactly one unknown
-            if len(unknowns) == 1:
-                return True, unknowns[0], discovered
-            
-            return False, "", {}
-            
-        except Exception:
-            return False, "", {}
-    
-    def _try_auto_solve(self) -> bool:
-        """Try to automatically solve the equation if possible."""
-        try:
-            can_solve, target_var, variables = self._can_auto_solve()
-            if can_solve:
-                self.solve_for(target_var, variables)
-                return True
-            return False
-        except Exception:
-            return False
-    
-    def __str__(self) -> str:
-        # Try to auto-solve if possible before displaying
-        self._try_auto_solve()
-        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})"