qnty 0.0.9__py3-none-any.whl → 0.1.1__py3-none-any.whl

qnty/solving/solvers/base.py

@@ -1,23 +1,24 @@
 from __future__ import annotations
 
+import logging
 from abc import ABC, abstractmethod
 from dataclasses import dataclass, field
 from typing import Any
 
-from qnty.equations.equation import Equation
-from qnty.quantities import TypeSafeVariable as Variable
-from qnty.solving.order import Order
+from ...equations import Equation
+from ...quantities import FieldQnty
+from ..order import Order
 
 
 class SolveError(Exception):
     """Exception raised when solving fails."""
-    pass
 
 
 @dataclass
 class SolveResult:
     """Result of a solve operation."""
-    variables: dict[str, Variable]
+
+    variables: dict[str, FieldQnty]
     steps: list[dict[str, Any]] = field(default_factory=list)
     success: bool = True
     message: str = ""
@@ -27,66 +28,55 @@ class SolveResult:
 
 class BaseSolver(ABC):
     """Base class for all equation solvers."""
-    
-    def __init__(self, logger=None):
+
+    def __init__(self, logger: logging.Logger | None = None):
         self.logger = logger
-        self.steps = []
-    
+        self.steps: list[dict[str, Any]] = []
+
     @abstractmethod
-    def can_handle(self, equations: list[Equation], unknowns: set[str],
-                   dependency_graph: Order | None = None,
-                   analysis: dict[str, Any] | None = None) -> bool:
+    def can_handle(self, equations: list[Equation], unknowns: set[str], dependency_graph: Order | None = None, analysis: dict[str, Any] | None = None) -> bool:
         """
         Check if this solver can handle the given problem.
-        
+
         Args:
             equations: List of equations to solve
             unknowns: Set of unknown variable symbols
             dependency_graph: Optional dependency graph for analysis
             analysis: Optional system analysis results
-            
+
         Returns:
             True if this solver can handle the problem
         """
-        pass
-    
+        ...
+
     @abstractmethod
-    def solve(self, equations: list[Equation], variables: dict[str, Variable],
-              dependency_graph: Order | None = None,
-              max_iterations: int = 100, tolerance: float = 1e-10) -> SolveResult:
+    def solve(self, equations: list[Equation], variables: dict[str, FieldQnty], dependency_graph: Order | None = None, max_iterations: int = 100, tolerance: float = 1e-10) -> SolveResult:
         """
         Solve the system of equations.
-        
+
         Args:
             equations: List of equations to solve
             variables: Dictionary of all variables (known and unknown)
             dependency_graph: Optional dependency graph
             max_iterations: Maximum number of iterations
             tolerance: Convergence tolerance
-            
+
         Returns:
             SolveResult containing the solution
         """
-        pass
-    
-    def _log_step(self, iteration: int, variable: str, equation: str,
-                  result: str, method: str | None = None):
+        ...
+
+    def _log_step(self, iteration: int, variable: str, equation: str, result: str, method: str | None = None):
         """Log a solving step."""
-        step = {
-            'iteration': iteration,
-            'variable': variable,
-            'equation': equation,
-            'result': result,
-            'method': method or self.__class__.__name__
-        }
+        step = {"iteration": iteration, "variable": variable, "equation": equation, "result": result, "method": method or self.__class__.__name__}
         self.steps.append(step)
         if self.logger:
-            self.logger.debug(f"Solved {variable} = {result}")
-    
-    def _get_known_variables(self, variables: dict[str, Variable]) -> set[str]:
+            self.logger.debug("Solved %s = %s", variable, result)
+
+    def _get_known_variables(self, variables: dict[str, FieldQnty]) -> set[str]:
         """Get symbols of known variables."""
         return {s for s, v in variables.items() if v.is_known}
-    
-    def _get_unknown_variables(self, variables: dict[str, Variable]) -> set[str]:
+
+    def _get_unknown_variables(self, variables: dict[str, FieldQnty]) -> set[str]:
         """Get symbols of unknown variables."""
         return {s for s, v in variables.items() if not v.is_known}

qnty/solving/solvers/iterative.py

@@ -1,185 +1,165 @@
 from typing import Any
 
-from qnty.equations.equation import Equation
-from qnty.expressions import VariableReference
-from qnty.quantities import TypeSafeVariable as Variable
-from qnty.solving.order import Order
-
+from ...equations import Equation
+from ...expressions import ConditionalExpression, VariableReference
+from ...quantities.field_qnty import FieldQnty
+from ..order import Order
 from .base import BaseSolver, SolveResult
 
 
 class IterativeSolver(BaseSolver):
     """
     Iterative solver that follows dependency order like solving engineering problems by hand.
-    
+
     This solver works by:
     1. Using dependency graph to determine the correct solving order
     2. Solving variables one by one in dependency order (just like manual solving)
     3. Preserving units throughout with Pint integration
     4. Verifying each solution with residual checking
     5. Repeating until all unknowns are solved
-    
+
     This approach mirrors how engineers solve problems by hand: solve what you can
     with what you know, then use those results to solve the next level of dependencies.
     """
-    
-    def can_handle(self, equations: list[Equation], unknowns: set[str],
-                   dependency_graph: Order | None = None,
-                   analysis: dict[str, Any] | None = None) -> bool:
+
+    def can_handle(self, equations: list[Equation], unknowns: set[str], dependency_graph: Order | None = None, analysis: dict[str, Any] | None = None) -> bool:
         """
-        Can handle any system that doesn't have cycles and has at least one unknown.
+        Can handle any system that has at least one unknown and a dependency graph.
         """
-        if not unknowns:
-            return False
-            
-        # The IterativeSolver can now handle cycles through iterative convergence
-        # if analysis and analysis.get('has_cycles', False):
-        #     return False
-            
-        # If we have a dependency graph, we can try to solve
-        if dependency_graph:
-            return True
-            
-        # As a fallback, we can try to handle any system
-        return len(unknowns) > 0
-    
-    def solve(self, equations: list[Equation], variables: dict[str, Variable],
-              dependency_graph: Order | None = None,
-              max_iterations: int = 100, tolerance: float = 1e-10) -> SolveResult:
+        return bool(unknowns and dependency_graph)
+
+    def solve(self, equations: list[Equation], variables: dict[str, FieldQnty], dependency_graph: Order | None = None, max_iterations: int = 100, tolerance: float = 1e-10) -> SolveResult:
         """
         Solve the system iteratively using dependency graph.
         """
         self.steps = []
-        
+
         if not dependency_graph:
-            return SolveResult(
-                variables=variables,
-                steps=self.steps,
-                success=False,
-                message="Dependency graph required for iterative solving",
-                method="IterativeSolver"
-            )
-        
+            return SolveResult(variables=variables, steps=self.steps, success=False, message="Dependency graph required for iterative solving", method="IterativeSolver")
+
         # Make a copy of variables to work with
         working_vars = dict(variables.items())
         known_vars = self._get_known_variables(working_vars)
-        
+
         if self.logger:
             self.logger.debug(f"Starting iterative solve with {len(known_vars)} known variables")
-        
+
         # Iterative solving
-        iteration = -1  # Initialize to handle case where loop doesn't run
+        iteration = 0
         for iteration in range(max_iterations):
             iteration_start = len(known_vars)
-            
+
             # Get variables that can be solved in this iteration
             solvable = dependency_graph.get_solvable_variables(known_vars)
-            
+
             # Fallback: attempt direct equations for remaining unknowns
             if not solvable:
-                remaining_unknowns = [v for v in self._get_unknown_variables(working_vars)
-                                    if v not in known_vars]
-                for var_symbol in remaining_unknowns:
-                    for eq in equations:
-                        if eq.can_solve_for(var_symbol, known_vars):
-                            solvable.append(var_symbol)
-                            break
-            
+                solvable = self._find_directly_solvable_variables(equations, working_vars, known_vars)
+
+            # Try to break conditional cycles if still no solvable variables
+            if not solvable:
+                solvable = self._solve_conditional_cycles(equations, working_vars, known_vars)
+
             if not solvable:
-                # Try to break conditional cycles
-                remaining_unknowns = [v for v in self._get_unknown_variables(working_vars)
-                                    if v not in known_vars]
-                if remaining_unknowns:
-                    # Look for conditional equations that can be evaluated
-                    for var_symbol in remaining_unknowns:
-                        for eq in equations:
-                            # Check if LHS is a VariableReference with matching name
-                            if (isinstance(eq.lhs, VariableReference) and
-                                eq.lhs.name == var_symbol and
-                                'ConditionalExpression' in str(type(eq.rhs))):
-                                # This is a conditional equation - try to solve it
-                                try:
-                                    solved_var = eq.solve_for(var_symbol, working_vars)
-                                    working_vars[var_symbol] = solved_var
-                                    known_vars.add(var_symbol)
-                                    solvable = [var_symbol]  # Mark as solved this iteration
-                                    if self.logger:
-                                        self.logger.debug(f"Solved conditional cycle: {var_symbol} = {solved_var.quantity}")
-                                    break
-                                except Exception:
-                                    continue
-                        if solvable:
-                            break
-                
-                if not solvable:
-                    break  # No more variables can be solved
-            
+                break  # No more variables can be solved
+
             if self.logger:
                 self.logger.debug(f"Iteration {iteration + 1} solvable: {solvable}")
-            
+
             # Solve for each solvable variable
             for var_symbol in solvable:
-                equation = dependency_graph.get_equation_for_variable(var_symbol, known_vars)
-                if equation is None:
-                    # Try any equation that can solve it
-                    for eq in equations:
-                        if eq.can_solve_for(var_symbol, known_vars):
-                            equation = eq
-                            break
-                
-                if equation is None:
-                    continue
-                    
-                try:
-                    solved_var = equation.solve_for(var_symbol, working_vars)
-                    working_vars[var_symbol] = solved_var
-                    known_vars.add(var_symbol)
-                    
-                    # Verify solution by checking residual (like checking work by hand)
-                    if equation.check_residual(working_vars, tolerance):
-                        if self.logger:
-                            self.logger.debug(f"Solution verified for {var_symbol}")
-                    else:
-                        if self.logger:
-                            self.logger.warning(f"Residual check failed for {var_symbol}")
-                    
-                    self._log_step(
-                        iteration + 1,
-                        var_symbol,
-                        str(equation),
-                        str(solved_var.quantity),
-                        'iterative'
-                    )
-                    
-                except Exception as e:
-                    if self.logger:
-                        self.logger.error(f"Failed to solve for {var_symbol}: {e}")
-                    return SolveResult(
-                        variables=working_vars,
-                        steps=self.steps,
-                        success=False,
-                        message=f"Failed to solve for {var_symbol}: {e}",
-                        method="IterativeSolver",
-                        iterations=iteration + 1
-                    )
-            
+                result = self._solve_single_variable(var_symbol, equations, working_vars, known_vars, dependency_graph, iteration, tolerance)
+                if not result:
+                    return SolveResult(variables=working_vars, steps=self.steps, success=False, message=f"Failed to solve for {var_symbol}", method="IterativeSolver", iterations=iteration + 1)
+
             # Check for progress
             if len(known_vars) == iteration_start:
                 if self.logger:
                     self.logger.warning("No progress made, stopping early")
                 break
-        
+
         # Check if we solved all unknowns
         remaining_unknowns = self._get_unknown_variables(working_vars)
         success = len(remaining_unknowns) == 0
-        
+
         message = "All variables solved" if success else f"Could not solve: {remaining_unknowns}"
-        
-        return SolveResult(
-            variables=working_vars,
-            steps=self.steps,
-            success=success,
-            message=message,
-            method="IterativeSolver",
-            iterations=iteration + 1
-        )
+
+        return SolveResult(variables=working_vars, steps=self.steps, success=success, message=message, method="IterativeSolver", iterations=iteration + 1)
+
+    def _find_directly_solvable_variables(self, equations: list[Equation], working_vars: dict[str, FieldQnty], known_vars: set[str]) -> list[str]:
+        """Find variables that can be directly solved from equations."""
+        solvable = []
+        remaining_unknowns = [v for v in self._get_unknown_variables(working_vars) if v not in known_vars]
+
+        for var_symbol in remaining_unknowns:
+            for eq in equations:
+                if eq.can_solve_for(var_symbol, known_vars):
+                    solvable.append(var_symbol)
+                    break
+
+        return solvable
+
+    def _solve_conditional_cycles(self, equations: list[Equation], working_vars: dict[str, FieldQnty], known_vars: set[str]) -> list[str]:
+        """Attempt to solve conditional cycles in the equation system."""
+        remaining_unknowns = [v for v in self._get_unknown_variables(working_vars) if v not in known_vars]
+
+        for var_symbol in remaining_unknowns:
+            for eq in equations:
+                # Check if this is a conditional equation that can be solved
+                if self._is_conditional_equation(eq, var_symbol):
+                    try:
+                        solved_var = eq.solve_for(var_symbol, working_vars)
+                        working_vars[var_symbol] = solved_var
+                        known_vars.add(var_symbol)
+
+                        if self.logger:
+                            self.logger.debug(f"Solved conditional cycle: {var_symbol} = {solved_var.quantity}")
+
+                        return [var_symbol]  # Return immediately after solving one
+                    except Exception:
+                        continue
+
+        return []
+
+    def _is_conditional_equation(self, equation: Equation, var_symbol: str) -> bool:
+        """Check if equation is a conditional equation for the given variable."""
+        return isinstance(equation.lhs, VariableReference) and equation.lhs.name == var_symbol and isinstance(equation.rhs, ConditionalExpression)
+
+    def _solve_single_variable(
+        self, var_symbol: str, equations: list[Equation], working_vars: dict[str, FieldQnty], known_vars: set[str], dependency_graph: Order, iteration: int, tolerance: float
+    ) -> bool:
+        """Solve for a single variable and update the system state."""
+        # Find equation that can solve for this variable
+        equation = dependency_graph.get_equation_for_variable(var_symbol, known_vars)
+
+        if equation is None:
+            # Try any equation that can solve it
+            for eq in equations:
+                if eq.can_solve_for(var_symbol, known_vars):
+                    equation = eq
+                    break
+
+        if equation is None:
+            return True  # Skip this variable, not a failure
+
+        try:
+            solved_var = equation.solve_for(var_symbol, working_vars)
+            working_vars[var_symbol] = solved_var
+            known_vars.add(var_symbol)
+
+            # Verify solution by checking residual
+            if equation.check_residual(working_vars, tolerance):
+                if self.logger:
+                    self.logger.debug(f"Solution verified for {var_symbol}")
+            else:
+                if self.logger:
+                    self.logger.warning(f"Residual check failed for {var_symbol}")
+
+            self._log_step(iteration + 1, var_symbol, str(equation), str(solved_var.quantity), "iterative")
+
+            return True
+
+        except Exception as e:
+            if self.logger:
+                self.logger.error(f"Failed to solve for {var_symbol}: {e}")
+            return False