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

qnty/problem/solving.py

@@ -1,180 +0,0 @@
-"""
-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

@@ -1,64 +0,0 @@
-"""
-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

@@ -1,239 +0,0 @@
-"""
-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])