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

qnty/solving/manager.py

@@ -1,8 +1,9 @@
+import logging
 
-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 .solvers.base import BaseSolver, SolveResult
 from .solvers.iterative import IterativeSolver
 from .solvers.simultaneous import SimultaneousEquationSolver
@@ -12,79 +13,84 @@ class SolverManager:
     """
     Manages multiple solvers and selects the best one for a given problem.
     """
-    
-    def __init__(self, logger=None):
+
+    def __init__(self, logger: logging.Logger | None = None):
         self.logger = logger
         self.solvers = [
             SimultaneousEquationSolver(logger),  # Try simultaneous first for cyclic systems
-            IterativeSolver(logger),             # Fall back to iterative
+            IterativeSolver(logger),  # Fall back to iterative
         ]
-    
-    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 using the best available solver.
-        
+
         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
         """
         unknowns = {s for s, v in variables.items() if not v.is_known}
-        
+
         if not unknowns:
-            return SolveResult(
-                variables=variables,
-                steps=[],
-                success=True,
-                message="No unknowns to solve",
-                method="NoSolver"
-            )
-        
+            return SolveResult(variables=variables, steps=[], success=True, message="No unknowns to solve", method="NoSolver")
+
         # Get system analysis if we have a dependency graph
         analysis = None
         if dependency_graph:
             known_vars = {s for s, v in variables.items() if v.is_known}
             analysis = dependency_graph.analyze_system(known_vars)
-        
+
         # Try each solver in order of preference
         for solver in self.solvers:
             if solver.can_handle(equations, unknowns, dependency_graph, analysis):
-                if self.logger:
-                    self.logger.debug(f"Using {solver.__class__.__name__} for solving")
-                
-                result = solver.solve(equations, variables, dependency_graph,
-                                    max_iterations, tolerance)
-                
+                result = self._try_solver(solver, equations, variables, dependency_graph, max_iterations, tolerance)
                 if result.success:
                     return result
-                else:
-                    if self.logger:
-                        # Use debug level for expected fallback from SimultaneousEquationSolver
-                        if solver.__class__.__name__ == "SimultaneousEquationSolver":
-                            self.logger.debug(f"{solver.__class__.__name__} failed: {result.message}")
-                        else:
-                            self.logger.warning(f"{solver.__class__.__name__} failed: {result.message}")
-        
+
         # No solver could handle the problem
-        return SolveResult(
-            variables=variables,
-            steps=[],
-            success=False,
-            message="No solver could handle this problem",
-            method="NoSolver"
-        )
-    
+        return SolveResult(variables=variables, steps=[], success=False, message="No solver could handle this problem", method="NoSolver")
+
     def add_solver(self, solver: BaseSolver):
         """Add a custom solver to the manager."""
         self.solvers.insert(0, solver)  # Add to beginning for highest priority
-    
+
     def get_available_solvers(self) -> list[str]:
         """Get list of available solver names."""
         return [solver.__class__.__name__ for solver in self.solvers]
+
+    def _try_solver(self, solver: BaseSolver, equations: list[Equation], variables: dict[str, FieldQnty], dependency_graph: Order | None, max_iterations: int, tolerance: float) -> SolveResult:
+        """
+        Try a specific solver and log results appropriately.
+
+        Args:
+            solver: The solver to try
+            equations: List of equations to solve
+            variables: Dictionary of variables
+            dependency_graph: Optional dependency graph
+            max_iterations: Maximum iterations
+            tolerance: Convergence tolerance
+
+        Returns:
+            SolveResult from the attempted solver
+        """
+        solver_name = solver.__class__.__name__
+
+        if self.logger:
+            self.logger.debug(f"Using {solver_name} for solving")
+
+        result = solver.solve(equations, variables, dependency_graph, max_iterations, tolerance)
+
+        if not result.success and self.logger:
+            # Use debug level for expected fallback from SimultaneousEquationSolver
+            if solver_name == "SimultaneousEquationSolver":
+                self.logger.debug(f"{solver_name} failed: {result.message}")
+            else:
+                self.logger.warning(f"{solver_name} failed: {result.message}")
+
+        return result

qnty/solving/order.py

@@ -1,7 +1,7 @@
 from collections import defaultdict, deque
 from typing import Any
 
-from qnty.equations.equation import Equation
+from ..equations import Equation
 
 
 class Order:
@@ -9,7 +9,7 @@ class Order:
     Manages dependencies between variables in a system of equations.
     Uses topological sorting to determine the correct solving order.
     """
-    
+
     def __init__(self):
         # Graph structure: dependency_source -> [dependent_variables]
         self.graph = defaultdict(list)
@@ -19,64 +19,22 @@ class Order:
         self.variables = set()
         # Equations that can solve for each variable
         self.solvers = defaultdict(list)  # variable -> [equations that can solve it]
-    
+
     def add_equation(self, equation: Equation, known_vars: set[str]):
         """Add an equation to the dependency graph."""
         eq_vars = equation.get_all_variables()
         unknown_vars = equation.get_unknown_variables(known_vars)
-        
+
         # Update variables set
         self.variables.update(eq_vars)
-        
+
         # Analyze equation structure to determine dependencies and solvers
-        # For equations of the form "var = expression", var depends on all variables in expression
-        # Check if LHS is a Variable (has symbol) or Expression (has get_variables)
-        if hasattr(equation.lhs, 'symbol'):
-            # Type guard: this is a Variable
-            lhs_vars = {equation.lhs.symbol}  # type: ignore[attr-defined]
-        elif hasattr(equation.lhs, 'get_variables'):
-            lhs_vars = equation.lhs.get_variables()
-        else:
-            lhs_vars = set()
-        rhs_vars = equation.rhs.get_variables() if hasattr(equation.rhs, 'get_variables') else set()
-        
-        # If LHS is a single variable, it depends on all variables in RHS
-        if len(lhs_vars) == 1:
-            lhs_var = next(iter(lhs_vars))
-            
-            # Only add as solver for the LHS variable (if it's unknown)
-            if lhs_var in unknown_vars:
-                self.solvers[lhs_var].append(equation)
-            
-            # Add dependencies: LHS variable depends on all RHS variables
-            for rhs_var in rhs_vars:
-                if rhs_var != lhs_var:
-                    self.add_dependency(rhs_var, lhs_var)
-                    
-        # If RHS is a single variable, it depends on all variables in LHS
-        elif len(rhs_vars) == 1:
-            rhs_var = next(iter(rhs_vars))
-            
-            # Only add as solver for the RHS variable (if it's unknown)
-            if rhs_var in unknown_vars:
-                self.solvers[rhs_var].append(equation)
-            
-            # Add dependencies: RHS variable depends on all LHS variables
-            for lhs_var in lhs_vars:
-                if lhs_var != rhs_var:
-                    self.add_dependency(lhs_var, rhs_var)
-                    
-        # For more complex cases, use can_solve_for check
-        else:
-            for unknown_var in unknown_vars:
-                if equation.can_solve_for(unknown_var, known_vars):
-                    self.solvers[unknown_var].append(equation)
-                
-                # Add dependencies: unknown_var depends on all other variables in equation
-                for other_var in eq_vars:
-                    if other_var != unknown_var:
-                        self.add_dependency(other_var, unknown_var)
-    
+        lhs_vars = self._extract_variables_from_side(equation.lhs)
+        rhs_vars = self._extract_variables_from_side(equation.rhs)
+
+        # Handle different equation patterns
+        self._process_equation_dependencies(equation, lhs_vars, rhs_vars, unknown_vars, eq_vars, known_vars)
+
     def add_dependency(self, dependency_source: str, dependent_variable: str):
         """
         Add a dependency: dependent_variable depends on dependency_source.
@@ -87,11 +45,11 @@ class Order:
             if dependent_variable not in self.graph[dependency_source]:
                 self.graph[dependency_source].append(dependent_variable)
                 self.in_degree[dependent_variable] += 1
-            
+
             # Ensure both variables are tracked
             self.variables.add(dependency_source)
             self.variables.add(dependent_variable)
-    
+
     def remove_dependency(self, dependency_source: str, dependent_variable: str):
         """Remove a dependency between variables."""
         if dependent_variable in self.graph[dependency_source]:
@@ -106,44 +64,44 @@ class Order:
         # Create a copy of in_degree for this computation
         temp_in_degree = self.in_degree.copy()
         temp_graph = defaultdict(list)
-        
+
         # Initialize temp_graph with copies, ensuring all variables have entries
         for var in self.variables:
             temp_graph[var] = self.graph[var].copy() if var in self.graph else []
-        
+
         # Initialize queue with variables that have no dependencies (already known)
         queue = deque()
-        
+
         # Add known variables to queue first
         for var in known_vars:
             if var in self.variables:
                 queue.append(var)
-        
+
         # Add variables with no remaining dependencies AND have solver equations
         for var in self.variables:
             if var not in known_vars and temp_in_degree[var] == 0 and var in self.solvers:
                 queue.append(var)
-        
+
         solving_order = []
-        
+
         while queue:
             current_var = queue.popleft()
             solving_order.append(current_var)
-            
+
             # Remove this variable's influence on dependent variables
             if current_var in temp_graph:
                 for dependent_var in temp_graph[current_var]:
                     temp_in_degree[dependent_var] -= 1
-                    
+
                     # If dependent variable has no more dependencies AND has solvers, add it to queue
                     if temp_in_degree[dependent_var] == 0 and dependent_var in self.solvers:
                         queue.append(dependent_var)
-        
+
         # Filter out known variables from the result, as they don't need solving
         result = [var for var in solving_order if var not in known_vars]
-        
+
         return result
-    
+
     def detect_cycles(self) -> list[list[str]]:
         """
         Detect cycles in the dependency graph.
@@ -153,7 +111,7 @@ class Order:
         color = defaultdict(int)
         cycles = []
         current_path = []
-        
+
         def dfs_visit(node: str) -> bool:
             """DFS visit with cycle detection. Returns True if cycle found."""
             if color[node] == GRAY:
@@ -162,66 +120,63 @@ class Order:
                 cycle = current_path[cycle_start:] + [node]
                 cycles.append(cycle)
                 return True
-            
+
             if color[node] == BLACK:
                 return False
-            
+
             # Mark as being processed
             color[node] = GRAY
             current_path.append(node)
-            
+
             # Visit neighbors
             for neighbor in self.graph[node]:
                 if dfs_visit(neighbor):
                     return True
-            
+
             # Mark as completely processed
             color[node] = BLACK
             current_path.pop()
             return False
-        
+
         # Check all variables
         for var in self.variables:
             if color[var] == WHITE:
                 dfs_visit(var)
-        
+
         return cycles
-    
+
     def can_solve_system(self, known_vars: set[str]) -> tuple[bool, list[str]]:
         """
         Check if the system can be completely solved given known variables.
         Returns (can_solve, unsolvable_variables).
         """
         all_unknown = self.variables - known_vars
-        
-        # Variables with no solver equations are truly unsolvable
-        truly_unsolvable = []
-        for var in all_unknown:
-            if var not in self.solvers or len(self.solvers[var]) == 0:
-                truly_unsolvable.append(var)
-        
-        # Check if we have enough equations for unknowns
+
+        # Find variables with no solver equations
+        truly_unsolvable = self._find_truly_unsolvable_variables(all_unknown)
+
+        # Check equation-to-variable ratio
         variables_with_solvers = all_unknown - set(truly_unsolvable)
-        unique_equations = {self.solvers[var][0] for var in variables_with_solvers if var in self.solvers and self.solvers[var]}
-        
-        # For now, use simple heuristic: need at least as many equations as unknowns
+        unique_equations = self._get_unique_equations(variables_with_solvers)
+
+        # Simple heuristic: need at least as many equations as unknowns
         can_solve_completely = len(unique_equations) >= len(variables_with_solvers) and len(truly_unsolvable) == 0
-        
-        if not can_solve_completely:
-            # If we can't solve completely, check what would be left unsolvable
-            solving_order = self.get_solving_order(known_vars)
-            solvable = set(solving_order)
-            conditional_unsolvable = all_unknown - solvable
-            unsolvable = list(set(truly_unsolvable) | conditional_unsolvable)
-        else:
-            unsolvable = []
-        
-        return can_solve_completely, unsolvable
-    
+
+        if can_solve_completely:
+            return True, []
+
+        # Find all unsolvable variables
+        solving_order = self.get_solving_order(known_vars)
+        solvable = set(solving_order)
+        conditional_unsolvable = all_unknown - solvable
+        unsolvable = list(set(truly_unsolvable) | conditional_unsolvable)
+
+        return False, unsolvable
+
     def get_solvable_variables(self, known_vars: set[str]) -> list[str]:
         """Get variables that can be solved in the next iteration."""
         solvable = []
-        
+
         for var in self.variables:
             if var not in known_vars:
                 # Check if all dependencies of this variable are known
@@ -230,24 +185,24 @@ class Order:
                     if var in self.graph[dep_source] and dep_source not in known_vars:
                         dependencies_known = False
                         break
-                
+
                 if dependencies_known and var in self.solvers:
                     solvable.append(var)
-        
+
         return solvable
-    
+
     def get_equation_for_variable(self, var: str, known_vars: set[str]) -> Equation | None:
         """Get an equation that can solve for the given variable."""
         if var not in self.solvers:
             return None
-        
+
         # Find the first equation that can solve for this variable
         for equation in self.solvers[var]:
             if equation.can_solve_for(var, known_vars):
                 return equation
-        
+
         return None
-    
+
     def get_strongly_connected_components(self) -> list[set[str]]:
         """
         Find strongly connected components in the dependency graph.
@@ -260,21 +215,21 @@ class Order:
         index = {}
         on_stack = {}
         components = []
-        
+
         def strongconnect(node: str):
             index[node] = index_counter[0]
             lowlinks[node] = index_counter[0]
             index_counter[0] += 1
             stack.append(node)
             on_stack[node] = True
-            
+
             for neighbor in self.graph[node]:
                 if neighbor not in index:
                     strongconnect(neighbor)
                     lowlinks[node] = min(lowlinks[node], lowlinks[neighbor])
                 elif on_stack[neighbor]:
                     lowlinks[node] = min(lowlinks[node], index[neighbor])
-            
+
             if lowlinks[node] == index[node]:
                 component = set()
                 while True:
@@ -284,11 +239,11 @@ class Order:
                     if w == node:
                         break
                 components.append(component)
-        
+
         for node in self.variables:
             if node not in index:
                 strongconnect(node)
-        
+
         # Filter out single-node components (unless they have self-loops)
         significant_components = []
         for component in components:
@@ -298,58 +253,151 @@ class Order:
                 node = next(iter(component))
                 if node in self.graph[node]:  # Self-loop
                     significant_components.append(component)
-        
+
         return significant_components
-    
+
     def analyze_system(self, known_vars: set[str]) -> dict[str, Any]:
         """
         Perform comprehensive analysis of the equation system.
         Returns analysis results including cycles, SCCs, solvability, etc.
         """
         analysis = {}
-        
+
         # Basic info
-        analysis['total_variables'] = len(self.variables)
-        analysis['known_variables'] = len(known_vars)
-        analysis['unknown_variables'] = len(self.variables - known_vars)
-        
+        analysis["total_variables"] = len(self.variables)
+        analysis["known_variables"] = len(known_vars)
+        analysis["unknown_variables"] = len(self.variables - known_vars)
+
         # Solving order
-        analysis['solving_order'] = self.get_solving_order(known_vars)
-        
+        analysis["solving_order"] = self.get_solving_order(known_vars)
+
         # Solvability
         can_solve, unsolvable = self.can_solve_system(known_vars)
-        analysis['can_solve_completely'] = can_solve
-        analysis['unsolvable_variables'] = unsolvable
-        
+        analysis["can_solve_completely"] = can_solve
+        analysis["unsolvable_variables"] = unsolvable
+
         # Cycles and SCCs
-        analysis['cycles'] = self.detect_cycles()
-        analysis['strongly_connected_components'] = self.get_strongly_connected_components()
-        analysis['has_cycles'] = len(analysis['cycles']) > 0
-        
+        analysis["cycles"] = self.detect_cycles()
+        analysis["strongly_connected_components"] = self.get_strongly_connected_components()
+        analysis["has_cycles"] = len(analysis["cycles"]) > 0
+
         # Next solvable variables
-        analysis['immediately_solvable'] = self.get_solvable_variables(known_vars)
-        
+        analysis["immediately_solvable"] = self.get_solvable_variables(known_vars)
+
         return analysis
-    
+
+    def _extract_variables_from_side(self, side: Any) -> set[str]:
+        """
+        Extract variables from either left or right side of an equation.
+
+        Args:
+            side: The equation side (Variable or Expression)
+
+        Returns:
+            Set of variable names found in this side
+        """
+        # Check if it's a Variable with a symbol attribute
+        if hasattr(side, "symbol") and hasattr(side, "name"):
+            return {str(side.symbol) if side.symbol else str(side.name)}
+        # Check if it's an Expression with get_variables method
+        elif hasattr(side, "get_variables") and callable(side.get_variables):
+            return side.get_variables()  # type: ignore[return-value]
+        else:
+            return set()
+
+    def _process_equation_dependencies(self, equation: Equation, lhs_vars: set[str], rhs_vars: set[str], unknown_vars: set[str], eq_vars: set[str], known_vars: set[str]):
+        """
+        Process dependencies and solvers for an equation based on its structure.
+
+        Args:
+            equation: The equation to process
+            lhs_vars: Variables on left-hand side
+            rhs_vars: Variables on right-hand side
+            unknown_vars: Unknown variables in the equation
+            eq_vars: All variables in the equation
+            known_vars: Set of known variables
+        """
+        # If LHS is a single variable, it depends on all variables in RHS
+        if len(lhs_vars) == 1:
+            lhs_var = next(iter(lhs_vars))
+            if lhs_var in unknown_vars:
+                self.solvers[lhs_var].append(equation)
+            # Add dependencies: LHS variable depends on all RHS variables
+            for rhs_var in rhs_vars:
+                if rhs_var != lhs_var:
+                    self.add_dependency(rhs_var, lhs_var)
+
+        # If RHS is a single variable, it depends on all variables in LHS
+        elif len(rhs_vars) == 1:
+            rhs_var = next(iter(rhs_vars))
+            if rhs_var in unknown_vars:
+                self.solvers[rhs_var].append(equation)
+            # Add dependencies: RHS variable depends on all LHS variables
+            for lhs_var in lhs_vars:
+                if lhs_var != rhs_var:
+                    self.add_dependency(lhs_var, rhs_var)
+
+        # For more complex cases, use can_solve_for check
+        else:
+            for unknown_var in unknown_vars:
+                if equation.can_solve_for(unknown_var, known_vars):
+                    self.solvers[unknown_var].append(equation)
+                # Add dependencies: unknown_var depends on all other variables in equation
+                for other_var in eq_vars:
+                    if other_var != unknown_var:
+                        self.add_dependency(other_var, unknown_var)
+
+    def _find_truly_unsolvable_variables(self, all_unknown: set[str]) -> list[str]:
+        """
+        Find variables that have no solver equations.
+
+        Args:
+            all_unknown: Set of all unknown variables
+
+        Returns:
+            List of variables with no solver equations
+        """
+        truly_unsolvable = []
+        for var in all_unknown:
+            if var not in self.solvers or len(self.solvers[var]) == 0:
+                truly_unsolvable.append(var)
+        return truly_unsolvable
+
+    def _get_unique_equations(self, variables_with_solvers: set[str]) -> set[Equation]:
+        """
+        Get unique equations that can solve variables.
+
+        Args:
+            variables_with_solvers: Variables that have solver equations
+
+        Returns:
+            Set of unique equations
+        """
+        unique_equations = set()
+        for var in variables_with_solvers:
+            if var in self.solvers and self.solvers[var]:
+                unique_equations.add(self.solvers[var][0])
+        return unique_equations
+
     def visualize_dependencies(self) -> str:
         """Create a text representation of the dependency graph."""
         lines = ["Dependency Graph:"]
         lines.append("=" * 20)
-        
+
         for source_var in sorted(self.graph.keys()):
             if self.graph[source_var]:
                 dependents = ", ".join(sorted(self.graph[source_var]))
                 lines.append(f"{source_var} -> [{dependents}]")
-        
+
         lines.append("")
         lines.append("In-degrees:")
         for var in sorted(self.variables):
             lines.append(f"{var}: {self.in_degree[var]}")
-        
+
         return "\n".join(lines)
-    
+
     def __str__(self) -> str:
         return f"DependencyGraph(variables={len(self.variables)}, equations={len(self.solvers)})"
-    
+
     def __repr__(self) -> str:
         return self.__str__()

qnty/solving/solvers/__init__.py

@@ -5,16 +5,9 @@ This package contains different solver implementations for solving systems
 of engineering equations.
 """
 
+from ..manager import SolverManager
 from .base import BaseSolver, SolveError, SolveResult
 from .iterative import IterativeSolver
-from ..manager import SolverManager
 from .simultaneous import SimultaneousEquationSolver
 
-__all__ = [
-    'BaseSolver',
-    'SolveResult',
-    'SolveError',
-    'IterativeSolver',
-    'SimultaneousEquationSolver',
-    'SolverManager'
-]
+__all__ = ["BaseSolver", "SolveResult", "SolveError", "IterativeSolver", "SimultaneousEquationSolver", "SolverManager"]