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

qnty/solving/solvers/simultaneous.py

@@ -2,11 +2,19 @@ from typing import Any
 
 import numpy as np
 
-from qnty.equations.equation import Equation
-from qnty.quantities import Quantity as Qty
-from qnty.quantities import TypeSafeVariable as Variable
+try:
+    from scipy.linalg import solve as scipy_solve  # type: ignore[import-untyped]
+
+    HAS_SCIPY = True
+except ImportError:
+    HAS_SCIPY = False
+    scipy_solve = None
+
 from qnty.solving.order import Order
 
+from ...equations import Equation
+from ...quantities import Quantity
+from ...quantities.field_qnty import FieldQnty
 from .base import BaseSolver, SolveResult
 
 
@@ -44,9 +52,7 @@ class SimultaneousEquationSolver(BaseSolver):
     LARGE_SYSTEM_THRESHOLD = 100  # Switch to optimized algorithms for n > 100
     SPARSE_THRESHOLD = 0.1  # Use sparse matrices if density < 10%
 
-    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:
         """
         Determine if this solver can handle the given system.
 
@@ -64,7 +70,7 @@ class SimultaneousEquationSolver(BaseSolver):
         """
         # dependency_graph parameter unused but required for interface compatibility
         _ = dependency_graph
-        
+
         system_size = len(equations)
         num_unknowns = len(unknowns)
 
@@ -75,17 +81,10 @@ class SimultaneousEquationSolver(BaseSolver):
         # Only handle systems with cycles (mutual dependencies)
         if analysis is None:
             return False
-        has_cycles = analysis.get('has_cycles', False)
+        has_cycles = analysis.get("has_cycles", False)
         return bool(has_cycles)
 
-    def solve(
-        self,
-        equations: list[Equation],
-        variables: dict[str, Variable],
-        dependency_graph: Order | None = None,
-        max_iterations: int = 100,
-        tolerance: float = DEFAULT_TOLERANCE
-    ) -> SolveResult:
+    def solve(self, equations: list[Equation], variables: dict[str, FieldQnty], dependency_graph: Order | None = None, max_iterations: int = 100, tolerance: float = DEFAULT_TOLERANCE) -> SolveResult:
         """
         Solve the n×n simultaneous system using matrix operations.
 
@@ -116,49 +115,24 @@ class SimultaneousEquationSolver(BaseSolver):
 
         # Step 2: Extract and solve matrix system
         try:
-            solution_vector = self._solve_matrix_system(
-                equations, unknown_variable_names, working_variables
-            )
+            solution_vector = self._solve_matrix_system(equations, unknown_variable_names, working_variables)
             if solution_vector is None:
-                return SolveResult(
-                    variables=working_variables,
-                    steps=self.steps,
-                    success=False,
-                    message="Failed to solve matrix system",
-                    method="SimultaneousEquationSolver"
-                )
+                return SolveResult(variables=working_variables, steps=self.steps, success=False, message="Failed to solve matrix system", method="SimultaneousEquationSolver")
 
             # Step 3: Update variables with solutions
-            self._apply_solution_to_variables(
-                unknown_variable_names, solution_vector, working_variables
-            )
+            self._apply_solution_to_variables(unknown_variable_names, solution_vector, working_variables)
 
             # Step 4: Verify solution quality
-            verification_result = self._verify_solution_quality(
-                equations, working_variables, tolerance
-            )
+            verification_result = self._verify_solution_quality(equations, working_variables, tolerance)
 
             return SolveResult(
-                variables=working_variables,
-                steps=self.steps,
-                success=verification_result.success,
-                message=verification_result.message,
-                method="SimultaneousEquationSolver",
-                iterations=1
+                variables=working_variables, steps=self.steps, success=verification_result.success, message=verification_result.message, method="SimultaneousEquationSolver", iterations=1
             )
 
         except Exception as general_error:
-            return SolveResult(
-                variables=working_variables,
-                steps=self.steps,
-                success=False,
-                message=f"Simultaneous solving failed: {general_error}",
-                method="SimultaneousEquationSolver"
-            )
+            return SolveResult(variables=working_variables, steps=self.steps, success=False, message=f"Simultaneous solving failed: {general_error}", method="SimultaneousEquationSolver")
 
-    def _validate_system(
-        self, equations: list[Equation], variables: dict[str, Variable]
-    ) -> SolveResult:
+    def _validate_system(self, equations: list[Equation], variables: dict[str, FieldQnty]) -> SolveResult:
         """
         Validate that the system meets requirements for simultaneous solving.
 
@@ -176,24 +150,15 @@ class SimultaneousEquationSolver(BaseSolver):
                 steps=self.steps,
                 success=False,
                 message=f"Simultaneous solver requires n×n system (got {num_equations} equations, {num_unknowns} unknowns)",
-                method="SimultaneousEquationSolver"
+                method="SimultaneousEquationSolver",
             )
 
         if self.logger:
-            self.logger.debug(
-                f"Attempting {num_unknowns}×{num_unknowns} simultaneous solution for {unknown_variable_names}"
-            )
+            self.logger.debug(f"Attempting {num_unknowns}×{num_unknowns} simultaneous solution for {unknown_variable_names}")
 
-        return SolveResult(
-            variables=variables,
-            steps=self.steps,
-            success=True,
-            message="System validation passed",
-            method="SimultaneousEquationSolver"
-        )
+        return SolveResult(variables=variables, steps=self.steps, success=True, message="System validation passed", method="SimultaneousEquationSolver")
 
-    def _solve_matrix_system(self, equations: list[Equation], unknown_variables: list[str],
-                           working_variables: dict[str, Variable]) -> np.ndarray | None:
+    def _solve_matrix_system(self, equations: list[Equation], unknown_variables: list[str], working_variables: dict[str, FieldQnty]) -> np.ndarray | None:
         """
         Extract coefficient matrix and solve the linear system.
 
@@ -230,8 +195,7 @@ class SimultaneousEquationSolver(BaseSolver):
                 self.logger.error(f"Linear algebra error: {linear_algebra_error}")
             return None
 
-    def _solve_optimized_system(self, coefficient_matrix: np.ndarray, constant_vector: np.ndarray,
-                              system_size: int) -> np.ndarray:
+    def _solve_optimized_system(self, coefficient_matrix: np.ndarray, constant_vector: np.ndarray, system_size: int) -> np.ndarray:
         """
         Solve the matrix system using optimized algorithms based on system characteristics.
 
@@ -267,41 +231,19 @@ class SimultaneousEquationSolver(BaseSolver):
 
     def _solve_sparse_system(self, coefficient_matrix: np.ndarray, constant_vector: np.ndarray) -> np.ndarray:
         """
-        Solve sparse matrix system using scipy.sparse algorithms.
-
-        Note: This is a placeholder for potential scipy.sparse integration.
-        For now, falls back to standard NumPy solver.
+        Solve sparse matrix system. Currently falls back to dense solver.
         """
-        # Future optimization: Convert to scipy.sparse.csc_matrix and use sparse solvers
-        # from scipy.sparse.linalg import spsolve
-        # sparse_matrix = scipy.sparse.csc_matrix(coefficient_matrix)
-        # return spsolve(sparse_matrix, constant_vector)
-
-        # Fallback to standard solver for now
         return np.linalg.solve(coefficient_matrix, constant_vector)
 
     def _solve_large_dense_system(self, coefficient_matrix: np.ndarray, constant_vector: np.ndarray) -> np.ndarray:
         """
         Solve large dense matrix system using optimized algorithms.
-
-        Uses LU decomposition with partial pivoting for better numerical stability
-        and potential reuse of factorization.
         """
-        # Use scipy.linalg.solve which is optimized for large systems
-        try:
-            # Try importing scipy for better performance on large systems
-            from scipy.linalg import solve  # type: ignore[import-untyped]
-            return solve(coefficient_matrix, constant_vector, assume_a='gen')
-        except ImportError:
-            # Fallback to NumPy if scipy is not available
-            return np.linalg.solve(coefficient_matrix, constant_vector)
+        if HAS_SCIPY and scipy_solve is not None:
+            return scipy_solve(coefficient_matrix, constant_vector, assume_a="gen")
+        return np.linalg.solve(coefficient_matrix, constant_vector)
 
-    def _apply_solution_to_variables(
-        self,
-        unknown_variables: list[str],
-        solution_vector: np.ndarray,
-        working_variables: dict[str, Variable]
-    ):
+    def _apply_solution_to_variables(self, unknown_variables: list[str], solution_vector: np.ndarray, working_variables: dict[str, FieldQnty]):
         """
         Apply solution values to variables and record solving steps.
         """
@@ -309,12 +251,7 @@ class SimultaneousEquationSolver(BaseSolver):
             solution_value = float(solution_vector[i])
             self._update_variable_with_solution(variable_name, solution_value, working_variables)
 
-    def _verify_solution_quality(
-        self,
-        equations: list[Equation],
-        working_variables: dict[str, Variable],
-        tolerance: float
-    ) -> SolveResult:
+    def _verify_solution_quality(self, equations: list[Equation], working_variables: dict[str, FieldQnty], tolerance: float) -> SolveResult:
         """
         Verify solution quality by checking equation residuals.
 
@@ -340,16 +277,9 @@ class SimultaneousEquationSolver(BaseSolver):
             variable_solutions = {var: f"{working_variables[var].quantity}" for var in working_variables if not working_variables[var].is_known}
             self.logger.debug(f"Solved {num_unknowns}×{num_unknowns} system: {variable_solutions}")
 
-        return SolveResult(
-            variables=working_variables,
-            steps=[],
-            success=is_successful,
-            message=success_message,
-            method="SimultaneousEquationSolver"
-        )
+        return SolveResult(variables=working_variables, steps=[], success=is_successful, message=success_message, method="SimultaneousEquationSolver")
 
-    def _extract_matrix_system(self, equations: list[Equation], unknown_variables: list[str],
-                             variables: dict[str, Variable]) -> tuple[np.ndarray | None, np.ndarray | None]:
+    def _extract_matrix_system(self, equations: list[Equation], unknown_variables: list[str], variables: dict[str, FieldQnty]) -> tuple[np.ndarray | None, np.ndarray | None]:
         """
         Extract coefficient matrix A and constant vector b from the system of equations.
 
@@ -379,24 +309,21 @@ class SimultaneousEquationSolver(BaseSolver):
 
             # Process equations in batches for large systems to reduce memory pressure
             for equation_index, equation in enumerate(equations):
-                coefficient_list = self._extract_linear_coefficients_vector(
-                    equation, unknown_variables, variables
-                )
+                coefficient_list = self._extract_linear_coefficients_vector(equation, unknown_variables, variables)
                 if coefficient_list is None:
                     return None, None
 
                 # coefficient_list contains [a1, a2, ..., an, constant]
                 # where equation is a1*x1 + a2*x2 + ... + an*xn = constant
                 coefficient_matrix[equation_index, :] = coefficient_list[:-1]  # Coefficients
-                constant_vector[equation_index] = coefficient_list[-1]      # Constant term
+                constant_vector[equation_index] = coefficient_list[-1]  # Constant term
 
             return coefficient_matrix, constant_vector
 
         except Exception:
             return None, None
 
-    def _extract_linear_coefficients_vector(self, equation: Equation, unknown_variables: list[str],
-                                          variables: dict[str, Variable]) -> list[float] | None:
+    def _extract_linear_coefficients_vector(self, equation: Equation, unknown_variables: list[str], variables: dict[str, FieldQnty]) -> list[float] | None:
         """
         Extract linear coefficients from equation using numerical differentiation.
 
@@ -420,47 +347,19 @@ class SimultaneousEquationSolver(BaseSolver):
             coefficients = []
 
             # Memory optimization: Pre-allocate arrays for large systems
-            residual_test_cases: np.ndarray | list[float] = np.zeros(num_unknowns) if num_unknowns > 10 else []
+            residual_test_cases: list[float] = []
 
             # Reuse test variables dictionary to reduce object creation overhead
             test_vars = variables.copy()
 
             # Test case for each unknown variable (finite difference)
             for variable_index in range(num_unknowns):
-                # Reset all unknowns to 0, then set current one to 1
-                for unknown_index, var_name in enumerate(unknown_variables):
-                    test_value = 1.0 if unknown_index == variable_index else 0.0
-                    original_var = test_vars[var_name]
-                    if original_var.quantity is None:
-                        raise ValueError(f"Variable {var_name} has no quantity")
-                    test_var = Variable(
-                        name=f"test_{var_name}",
-                        expected_dimension=original_var.quantity.dimension,
-                        is_known=True
-                    )
-                    test_var.quantity = Qty(test_value, original_var.quantity.unit)
-                    test_var.symbol = var_name
-                    test_vars[var_name] = test_var
-
+                self._set_test_variables(test_vars, unknown_variables, variable_index)
                 residual = self._calculate_equation_residual(equation, test_vars)
-                if isinstance(residual_test_cases, list):
-                    residual_test_cases.append(residual)
-                else:
-                    residual_test_cases[variable_index] = residual
+                residual_test_cases.append(residual)
 
             # Test case with all unknowns = 0 (baseline)
-            for var_name in unknown_variables:
-                original_var = test_vars[var_name]
-                if original_var.quantity is None:
-                    raise ValueError(f"Variable {var_name} has no quantity")
-                test_var = Variable(
-                    name=f"test_{var_name}",
-                    expected_dimension=original_var.quantity.dimension,
-                    is_known=True
-                )
-                test_var.quantity = Qty(0.0, original_var.quantity.unit)
-                test_var.symbol = var_name
-                test_vars[var_name] = test_var
+            self._set_test_variables(test_vars, unknown_variables, -1)  # -1 means set all to 0
             baseline_residual = self._calculate_equation_residual(equation, test_vars)
 
             # Extract coefficients: for equation sum(ai*xi) - c = 0
@@ -478,7 +377,7 @@ class SimultaneousEquationSolver(BaseSolver):
         except Exception:
             return None
 
-    def _calculate_equation_residual(self, equation: Equation, test_variables: dict[str, Variable]) -> float:
+    def _calculate_equation_residual(self, equation: Equation, test_variables: dict[str, FieldQnty]) -> float:
         """
         Calculate equation residual (LHS - RHS) with proper unit handling.
 
@@ -494,24 +393,15 @@ class SimultaneousEquationSolver(BaseSolver):
             left_hand_side = equation.lhs.evaluate(test_variables)
             right_hand_side = equation.rhs.evaluate(test_variables)
 
-            # Calculate residual with unit handling
+            # Calculate residual and extract numerical value
             residual = left_hand_side - right_hand_side
-
-            # Return the magnitude of the residual
-            if hasattr(residual, 'value'):
-                return residual.value
-            elif isinstance(residual, int | float):
-                return float(residual)
-            else:
-                # If it's a Qty object without .value, try to convert
-                return float(residual.value) if hasattr(residual, 'value') else 0.0
+            return self._extract_numerical_value(residual)
 
         except Exception:
             # Fallback for cases where evaluation fails
-            return float('inf')
+            return float("inf")
 
-    def _update_variable_with_solution(self, variable_symbol: str, solution_value: float,
-                                     variables: dict[str, Variable]):
+    def _update_variable_with_solution(self, variable_symbol: str, solution_value: float, variables: dict[str, FieldQnty]):
         """
         Update a variable with its solved value and record the solving step.
 
@@ -524,15 +414,11 @@ class SimultaneousEquationSolver(BaseSolver):
         if original_variable.quantity is None:
             raise ValueError(f"Variable {variable_symbol} has no quantity")
         result_unit = original_variable.quantity.unit
-        solution_quantity = Qty(solution_value, result_unit)
+        solution_quantity = Quantity(solution_value, result_unit)
 
         # Preserve the original variable name and create solved variable
         original_name = original_variable.name
-        solved_variable = Variable(
-            name=original_name,
-            expected_dimension=solution_quantity.dimension,
-            is_known=True
-        )
+        solved_variable = FieldQnty(name=original_name, expected_dimension=solution_quantity.dimension, is_known=True)
         solved_variable.quantity = solution_quantity
         solved_variable.symbol = variable_symbol
         variables[variable_symbol] = solved_variable
@@ -541,7 +427,49 @@ class SimultaneousEquationSolver(BaseSolver):
         self._log_step(
             1,  # iteration number
             variable_symbol,
-            'simultaneous_system',
+            "simultaneous_system",
             str(solution_quantity),
-            'simultaneous'
+            "simultaneous",
         )
+
+    def _set_test_variables(self, test_vars: dict[str, FieldQnty], unknown_variables: list[str], active_index: int):
+        """
+        Set test variables for coefficient extraction.
+
+        Args:
+            test_vars: Dictionary of test variables to modify
+            unknown_variables: List of unknown variable names
+            active_index: Index of variable to set to 1.0, others set to 0.0. If -1, all set to 0.0
+        """
+        for unknown_index, var_name in enumerate(unknown_variables):
+            test_value = 1.0 if unknown_index == active_index else 0.0
+            original_var = test_vars[var_name]
+            if original_var.quantity is None:
+                raise ValueError(f"Variable {var_name} has no quantity")
+            test_var = FieldQnty(name=f"test_{var_name}", expected_dimension=original_var.quantity.dimension, is_known=True)
+            test_var.quantity = Quantity(test_value, original_var.quantity.unit)
+            test_var.symbol = var_name
+            test_vars[var_name] = test_var
+
+    def _extract_numerical_value(self, value: Any) -> float:
+        """
+        Extract numerical value from various quantity types.
+
+        Args:
+            value: Value that may be a Quantity, float, int, or other numeric type
+
+        Returns:
+            Float representation of the value
+        """
+        # Check for Quantity type first (most common case)
+        if isinstance(value, Quantity):
+            return float(value.value)
+        # Handle primitive numeric types
+        elif isinstance(value, int | float):
+            return float(value)
+        # Handle objects with .value attribute as last resort
+        elif hasattr(value, "value"):
+            return float(value.value)
+        else:
+            # Last resort: try direct conversion
+            return float(value)

qnty/units/__init__.py

@@ -0,0 +1 @@
+from .field_units import *