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

qnty/problem/solving.py

@@ -0,0 +1,180 @@
+"""
+High-level solve orchestration for Problem class.
+
+This module contains the main solving logic, dependency graph building,
+solution verification, and system analysis methods.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from qnty.equations import Equation
+    from qnty.quantities import TypeSafeVariable as Variable
+
+# Constants
+MAX_ITERATIONS_DEFAULT = 100
+TOLERANCE_DEFAULT = 1e-10
+
+
+# Custom Exceptions
+class SolverError(RuntimeError):
+    """Raised when the solving process fails."""
+    pass
+
+
+class SolvingMixin:
+    """Mixin class providing solving orchestration functionality."""
+    
+    # These attributes/methods will be provided by other mixins in the final Problem class
+    name: str
+    logger: Any
+    equations: list[Equation]
+    solver_manager: Any
+    
+    def get_known_symbols(self) -> set[str]:
+        """Will be provided by VariablesMixin."""
+        ...
+    
+    def get_known_variables(self) -> dict[str, Variable]:
+        """Will be provided by VariablesMixin."""
+        ...
+    
+    def get_unknown_variables(self) -> dict[str, Variable]:
+        """Will be provided by VariablesMixin."""
+        ...
+    
+    def _sync_variables_to_instance_attributes(self) -> None:
+        """Will be provided by VariablesMixin."""
+        ...
+
+    def solve(self, max_iterations: int = MAX_ITERATIONS_DEFAULT, tolerance: float = TOLERANCE_DEFAULT) -> dict[str, Any]:
+        """
+        Solve the engineering problem by finding values for all unknown variables.
+        
+        This method orchestrates the complete solving process:
+        1. Builds dependency graph from equations
+        2. Determines optimal solving order using topological sorting
+        3. Solves equations iteratively using symbolic/numerical methods
+        4. Verifies solution against all equations
+        5. Updates variable states and synchronizes instance attributes
+        
+        Args:
+            max_iterations: Maximum number of solving iterations (default: 100)
+            tolerance: Numerical tolerance for convergence (default: 1e-10)
+            
+        Returns:
+            dict mapping variable symbols to solved Variable objects
+            
+        Raises:
+            SolverError: If solving fails or times out
+            
+        Example:
+            >>> problem = MyEngineeringProblem()
+            >>> solution = problem.solve()
+            >>> print(f"Force = {solution['F'].quantity}")
+        """
+        self.logger.info(f"Solving problem: {self.name}")
+        
+        try:
+            # Clear previous solution
+            self.solution = {}
+            self.is_solved = False
+            self.solving_history = []
+            
+            # Build dependency graph
+            self._build_dependency_graph()
+            
+            # Use solver manager to solve the system
+            solve_result = self.solver_manager.solve(
+                self.equations,
+                self.variables,
+                self.dependency_graph,
+                max_iterations,
+                tolerance
+            )
+            
+            if solve_result.success:
+                # Update variables with the result
+                self.variables = solve_result.variables
+                self.solving_history.extend(solve_result.steps)
+                
+                # Sync solved values back to instance attributes
+                self._sync_variables_to_instance_attributes()
+                
+                # Verify solution
+                self.solution = self.variables
+                verification_passed = self.verify_solution()
+                
+                # Mark as solved based on solver result and verification
+                if verification_passed:
+                    self.is_solved = True
+                    self.logger.info("Solution verified successfully")
+                    return self.solution
+                else:
+                    self.logger.warning("Solution verification failed")
+                    return self.solution
+            else:
+                raise SolverError(f"Solving failed: {solve_result.message}")
+                
+        except SolverError:
+            raise
+        except Exception as e:
+            self.logger.error(f"Solving failed: {e}")
+            raise SolverError(f"Unexpected error during solving: {e}") from e
+
+    def _build_dependency_graph(self):
+        """Build the dependency graph for solving order determination."""
+        # Reset the dependency graph
+        from qnty.solving.order import Order
+        self.dependency_graph = Order()
+        
+        # Get known variables
+        known_vars = self.get_known_symbols()
+        
+        # Add dependencies from equations
+        for equation in self.equations:
+            self.dependency_graph.add_equation(equation, known_vars)
+
+    def verify_solution(self, tolerance: float = 1e-10) -> bool:
+        """Verify that all equations are satisfied."""
+        if not self.equations:
+            return True
+        
+        try:
+            for equation in self.equations:
+                if not equation.check_residual(self.variables, tolerance):
+                    self.logger.debug(f"Equation verification failed: {equation}")
+                    return False
+            return True
+        except Exception as e:
+            self.logger.debug(f"Solution verification error: {e}")
+            return False
+
+    def analyze_system(self) -> dict[str, Any]:
+        """Analyze the equation system for solvability, cycles, etc."""
+        try:
+            self._build_dependency_graph()
+            known_vars = self.get_known_symbols()
+            analysis = self.dependency_graph.analyze_system(known_vars)
+            
+            # Add some additional info
+            analysis['total_equations'] = len(self.equations)
+            analysis['is_determined'] = len(self.get_unknown_variables()) <= len(self.equations)
+            
+            return analysis
+        except Exception as e:
+            self.logger.debug(f"Dependency analysis failed: {e}")
+            # Return basic analysis on failure
+            return {
+                'total_variables': len(self.variables),
+                'known_variables': len(self.get_known_variables()),
+                'unknown_variables': len(self.get_unknown_variables()),
+                'total_equations': len(self.equations),
+                'is_determined': len(self.get_unknown_variables()) <= len(self.equations),
+                'has_cycles': False,
+                'solving_order': [],
+                'can_solve_completely': False,
+                'unsolvable_variables': []
+            }

qnty/problem/validation.py

@@ -0,0 +1,64 @@
+"""
+Problem-validation integration for Problem class.
+
+This module contains validation check management and execution
+integrated with the Problem system.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    pass
+
+
+class ValidationMixin:
+    """Mixin class providing validation functionality."""
+    
+    # These attributes will be provided by other mixins in the final Problem class
+    logger: Any
+    warnings: list[dict[str, Any]]
+    validation_checks: list[Callable]
+
+    def add_validation_check(self, check_function: Callable) -> None:
+        """Add a validation check function."""
+        self.validation_checks.append(check_function)
+
+    def validate(self) -> list[dict[str, Any]]:
+        """Run all validation checks and return any warnings."""
+        validation_warnings = []
+        
+        for check in self.validation_checks:
+            try:
+                result = check(self)
+                if result:
+                    validation_warnings.append(result)
+            except Exception as e:
+                self.logger.debug(f"Validation check failed: {e}")
+        
+        return validation_warnings
+
+    def get_warnings(self) -> list[dict[str, Any]]:
+        """Get all warnings from the problem."""
+        warnings = self.warnings.copy()
+        warnings.extend(self.validate())
+        return warnings
+
+    def _recreate_validation_checks(self):
+        """Collect and integrate validation checks from class-level Check objects."""
+        # Clear existing checks
+        self.validation_checks = []
+        
+        # Collect Check objects from metaclass
+        class_checks = getattr(self.__class__, '_class_checks', {})
+        
+        for check in class_checks.values():
+            # Create a validation function from the Check object
+            def make_check_function(check_obj):
+                def check_function(problem_instance):
+                    return check_obj.evaluate(problem_instance.variables)
+                return check_function
+            
+            self.validation_checks.append(make_check_function(check))

qnty/problem/variables.py

@@ -0,0 +1,239 @@
+"""
+Variable lifecycle management for Problem class.
+
+This module contains all variable-related operations including adding,
+getting, managing known/unknown state, and variable caching.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from qnty.quantities import Quantity as Qty
+    from qnty.quantities import TypeSafeVariable as Variable
+
+from qnty.generated.units import DimensionlessUnits
+from qnty.quantities import Quantity as Qty
+from qnty.quantities import TypeSafeVariable as Variable
+
+
+# Custom Exceptions
+class VariableNotFoundError(KeyError):
+    """Raised when trying to access a variable that doesn't exist."""
+    pass
+
+
+class VariablesMixin:
+    """Mixin class providing variable management functionality."""
+    
+    # These attributes/methods will be provided by other mixins in the final Problem class
+    variables: dict[str, Variable]
+    name: str
+    logger: Any
+    is_solved: bool
+    sub_problems: dict[str, Any]
+    dependency_graph: Any
+    _known_variables_cache: dict[str, Variable] | None
+    _unknown_variables_cache: dict[str, Variable] | None
+    _cache_dirty: bool
+    
+    def _invalidate_caches(self) -> None:
+        """Will be provided by ProblemBase."""
+        ...
+    
+    def _update_variable_caches(self) -> None:
+        """Will be provided by ProblemBase."""
+        ...
+
+    def add_variable(self, variable: Variable) -> None:
+        """
+        Add a variable to the problem.
+        
+        The variable will be available for use in equations and can be accessed
+        via both dictionary notation (problem['symbol']) and attribute notation
+        (problem.symbol).
+        
+        Args:
+            variable: Variable object to add to the problem
+            
+        Note:
+            If a variable with the same symbol already exists, it will be replaced
+            and a warning will be logged.
+        """
+        if variable.symbol in self.variables:
+            self.logger.warning(f"Variable {variable.symbol} already exists. Replacing.")
+        
+        if variable.symbol is not None:
+            self.variables[variable.symbol] = variable
+        # Set parent problem reference for dependency invalidation
+        try:
+            variable._parent_problem = self
+        except (AttributeError, TypeError):
+            # _parent_problem might not be settable
+            pass
+        # Also set as instance attribute for dot notation access
+        if variable.symbol is not None:
+            setattr(self, variable.symbol, variable)
+        self.is_solved = False
+        self._invalidate_caches()
+
+    def add_variables(self, *variables: Variable) -> None:
+        """Add multiple variables to the problem."""
+        for var in variables:
+            self.add_variable(var)
+
+    def get_variable(self, symbol: str) -> Variable:
+        """Get a variable by its symbol."""
+        if symbol not in self.variables:
+            raise VariableNotFoundError(f"Variable '{symbol}' not found in problem '{self.name}'.")
+        return self.variables[symbol]
+    
+    def get_known_variables(self) -> dict[str, Variable]:
+        """Get all known variables."""
+        if self._cache_dirty or self._known_variables_cache is None:
+            self._update_variable_caches()
+        return self._known_variables_cache.copy() if self._known_variables_cache else {}
+
+    def get_unknown_variables(self) -> dict[str, Variable]:
+        """Get all unknown variables."""
+        if self._cache_dirty or self._unknown_variables_cache is None:
+            self._update_variable_caches()
+        return self._unknown_variables_cache.copy() if self._unknown_variables_cache else {}
+
+    def get_known_symbols(self) -> set[str]:
+        """Get symbols of all known variables."""
+        return {symbol for symbol, var in self.variables.items() if var.is_known}
+
+    def get_unknown_symbols(self) -> set[str]:
+        """Get symbols of all unknown variables."""
+        return {symbol for symbol, var in self.variables.items() if not var.is_known}
+    
+    def get_known_variable_symbols(self) -> set[str]:
+        """Alias for get_known_symbols for compatibility."""
+        return self.get_known_symbols()
+    
+    def get_unknown_variable_symbols(self) -> set[str]:
+        """Alias for get_unknown_symbols for compatibility."""
+        return self.get_unknown_symbols()
+    
+    # Properties for compatibility
+    @property
+    def known_variables(self) -> dict[str, Variable]:
+        """Get all variables marked as known."""
+        return self.get_known_variables()
+    
+    @property
+    def unknown_variables(self) -> dict[str, Variable]:
+        """Get all variables marked as unknown."""
+        return self.get_unknown_variables()
+
+    def mark_unknown(self, *symbols: str):
+        """Mark variables as unknown (to be solved for)."""
+        for symbol in symbols:
+            if symbol in self.variables:
+                self.variables[symbol].mark_unknown()
+            else:
+                raise VariableNotFoundError(f"Variable '{symbol}' not found in problem '{self.name}'")
+        self.is_solved = False
+        self._invalidate_caches()
+        return self
+    
+    def mark_known(self, **symbol_values: Qty):
+        """Mark variables as known and set their values."""
+        for symbol, quantity in symbol_values.items():
+            if symbol in self.variables:
+                self.variables[symbol].mark_known(quantity)
+            else:
+                raise VariableNotFoundError(f"Variable '{symbol}' not found in problem '{self.name}'")
+        self.is_solved = False
+        self._invalidate_caches()
+        return self
+
+    def invalidate_dependents(self, changed_variable_symbol: str) -> None:
+        """
+        Mark all variables that depend on the changed variable as unknown.
+        This ensures they get recalculated when the problem is re-solved.
+        
+        Args:
+            changed_variable_symbol: Symbol of the variable whose value changed
+        """
+        if not hasattr(self, 'dependency_graph') or not self.dependency_graph:
+            # If dependency graph hasn't been built yet, we can't invalidate
+            return
+            
+        # Get all variables that depend on the changed variable
+        dependent_vars = self.dependency_graph.graph.get(changed_variable_symbol, [])
+        
+        # Mark each dependent variable as unknown
+        for dependent_symbol in dependent_vars:
+            if dependent_symbol in self.variables:
+                var = self.variables[dependent_symbol]
+                # Only mark as unknown if it was previously solved (known)
+                if var.is_known:
+                    var.mark_unknown()
+                    # Recursively invalidate variables that depend on this one
+                    self.invalidate_dependents(dependent_symbol)
+        
+        # Mark problem as needing re-solving
+        self.is_solved = False
+        self._invalidate_caches()
+
+    def _create_placeholder_variable(self, symbol: str) -> None:
+        """Create a placeholder variable for a missing symbol."""
+        
+        placeholder_var = Variable(
+            name=f"Auto-created: {symbol}",
+            expected_dimension=DimensionlessUnits.dimensionless.dimension,
+            is_known=False
+        )
+        placeholder_var.symbol = symbol
+        placeholder_var.quantity = Qty(0.0, DimensionlessUnits.dimensionless)
+        self.add_variable(placeholder_var)
+        self.logger.debug(f"Auto-created placeholder variable: {symbol}")
+
+    def _clone_variable(self, variable: Variable) -> Variable:
+        """Create a copy of a variable to avoid shared state without corrupting global units."""
+        # Create a new variable of the same exact type to preserve .equals() method
+        # This ensures domain-specific variables (Length, Pressure, etc.) keep their type
+        variable_type = type(variable)
+        
+        # Use __new__ to avoid constructor parameter issues
+        cloned = variable_type.__new__(variable_type)
+        
+        # Initialize manually with the same attributes as the original
+        cloned.name = variable.name
+        cloned.symbol = variable.symbol
+        cloned.expected_dimension = variable.expected_dimension
+        cloned.quantity = variable.quantity  # Keep reference to same quantity - units must not be copied
+        cloned.is_known = variable.is_known
+        
+        # Ensure the cloned variable has fresh validation checks
+        if hasattr(variable, 'validation_checks'):
+            try:
+                cloned.validation_checks = []
+            except (AttributeError, TypeError):
+                # validation_checks might be read-only or not settable
+                pass
+        return cloned
+
+    def _sync_variables_to_instance_attributes(self):
+        """
+        Sync variable objects to instance attributes after solving.
+        This ensures that self.P refers to the same Variable object that's in self.variables.
+        Variables maintain their original dimensional types (e.g., AreaVariable, PressureVariable).
+        """
+        for var_symbol, var in self.variables.items():
+            # Update instance attribute if it exists
+            if hasattr(self, var_symbol):
+                # Variables preserve their dimensional types during solving
+                setattr(self, var_symbol, var)
+        
+        # Also update sub-problem namespace objects
+        for namespace, sub_problem in self.sub_problems.items():
+            if hasattr(self, namespace):
+                namespace_obj = getattr(self, namespace)
+                for var_symbol in sub_problem.variables:
+                    namespaced_symbol = f"{namespace}_{var_symbol}"
+                    if namespaced_symbol in self.variables and hasattr(namespace_obj, var_symbol):
+                        setattr(namespace_obj, var_symbol, self.variables[namespaced_symbol])

qnty/quantities/__init__.py

@@ -0,0 +1,6 @@
+from .quantity import Quantity, TypeSafeVariable
+
+__all__ = [
+    "Quantity",
+    "TypeSafeVariable"
+    ]