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

qnty/variable.py

@@ -1,300 +0,0 @@
-"""
-High-Performance Quantity and Variables
-========================================
-
-FastQuantity class and type-safe variables optimized for engineering calculations
-with dimensional safety.
-"""
-
-from __future__ import annotations
-
-from typing import Generic, Self, TypeVar
-
-from .dimension import AREA, DIMENSIONLESS, FORCE, LENGTH, PRESSURE, VOLUME, DimensionSignature
-from .dimension import ENERGY_HEAT_WORK as ENERGY
-from .unit import UnitConstant, UnitDefinition, registry
-from .units import DimensionlessUnits, LengthUnits, PressureUnits
-
-# TypeVar for generic dimensional types
-DimensionType = TypeVar('DimensionType', bound='FastQuantity')
-
-
-class TypeSafeSetter:
-    """Basic type-safe setter that accepts compatible units."""
-    
-    def __init__(self, variable: TypeSafeVariable, value: float):
-        self.variable = variable
-        self.value = value
-    
-    def with_unit(self, unit: UnitConstant) -> TypeSafeVariable:
-        """Set with type-safe unit constant."""
-        if not self.variable.expected_dimension.is_compatible(unit.dimension):
-            raise TypeError(f"Unit {unit.name} incompatible with expected dimension")
-        
-        self.variable.quantity = FastQuantity(self.value, unit)
-        return self.variable
-
-
-class FastQuantity:
-    """High-performance quantity optimized for engineering calculations."""
-    
-    __slots__ = ('value', 'unit', 'dimension', '_si_factor', '_dimension_sig')
-    
-    def __init__(self, value: float, unit: UnitConstant):
-        self.value = float(value)
-        self.unit = unit
-        self.dimension = unit.dimension
-        # Cache commonly used values to avoid lookups
-        self._si_factor = unit.si_factor
-        self._dimension_sig = unit.dimension._signature
-    
-    def __str__(self):
-        return f"{self.value} {self.unit.symbol}"
-    
-    def __repr__(self):
-        return f"FastQuantity({self.value}, {self.unit.name})"
-    
-    # Ultra-fast arithmetic with dimensional checking
-    def __add__(self, other: FastQuantity) -> FastQuantity:
-        # Fast dimension compatibility check using cached signatures
-        if self._dimension_sig != other._dimension_sig:
-            raise ValueError(f"Cannot add {self.unit.name} and {other.unit.name}")
-        
-        # Fast path for same units - no conversion needed
-        if self.unit == other.unit:
-            return FastQuantity(self.value + other.value, self.unit)
-        
-        # Convert other to self's units using cached SI factors
-        other_value = other.value * other._si_factor / self._si_factor
-        return FastQuantity(self.value + other_value, self.unit)
-    
-    def __sub__(self, other: FastQuantity) -> FastQuantity:
-        # Fast dimension compatibility check using cached signatures
-        if self._dimension_sig != other._dimension_sig:
-            raise ValueError(f"Cannot subtract {other.unit.name} from {self.unit.name}")
-        
-        # Fast path for same units - no conversion needed
-        if self.unit == other.unit:
-            return FastQuantity(self.value - other.value, self.unit)
-        
-        # Convert other to self's units using cached SI factors
-        other_value = other.value * other._si_factor / self._si_factor
-        return FastQuantity(self.value - other_value, self.unit)
-    
-    def __mul__(self, other: FastQuantity | float | int) -> FastQuantity:
-        if isinstance(other, int | float):
-            return FastQuantity(self.value * other, self.unit)
-        
-        # Handle TypeSafeVariable objects by using their quantity
-        from .variable_types.typed_variable import TypedVariable  # Avoid circular imports
-        if isinstance(other, TypedVariable) and other.quantity is not None:
-            other = other.quantity
-        
-        # Fast dimensional analysis using cached signatures
-        result_dimension_sig = self._dimension_sig * other._dimension_sig
-        
-        # Use cached SI factors for conversion
-        self_si_value = self.value * self._si_factor
-        other_si_value = other.value * other._si_factor
-        result_si_value = self_si_value * other_si_value
-        
-        # Fast path for common dimension combinations
-        result_unit = self._find_result_unit_fast(result_dimension_sig, self, other)
-        result_value = result_si_value / result_unit.si_factor
-        
-        return FastQuantity(result_value, result_unit)
-    
-    def __rmul__(self, other: float | int) -> FastQuantity:
-        """Reverse multiplication for cases like 2 * quantity."""
-        if isinstance(other, int | float):
-            return FastQuantity(other * self.value, self.unit)
-        return NotImplemented
-    
-    def __truediv__(self, other: FastQuantity | float | int) -> FastQuantity:
-        if isinstance(other, int | float):
-            return FastQuantity(self.value / other, self.unit)
-        
-        # Fast dimensional analysis using cached signatures
-        result_dimension_sig = self._dimension_sig / other._dimension_sig
-        
-        # Use cached SI factors for conversion
-        self_si_value = self.value * self._si_factor
-        other_si_value = other.value * other._si_factor
-        result_si_value = self_si_value / other_si_value
-        
-        # Fast path for common dimension combinations
-        result_unit = self._find_result_unit_fast(result_dimension_sig, self, other)
-        result_value = result_si_value / result_unit.si_factor
-        
-        return FastQuantity(result_value, result_unit)
-    
-    def _find_result_unit_fast(self, result_dimension_sig: int | float,
-                              left_qty: FastQuantity, right_qty: FastQuantity) -> UnitConstant:
-        """Ultra-fast unit finding using cached dimension signatures."""
-        
-        # Initialize dimension cache if empty
-        if not registry._dimension_cache:
-            from .dimension import ENERGY_PER_UNIT_AREA, SURFACE_TENSION
-            registry._dimension_cache = {
-                DIMENSIONLESS._signature: DimensionlessUnits.dimensionless,
-                LENGTH._signature: LengthUnits.millimeter,
-                PRESSURE._signature: PressureUnits.Pa,
-                AREA._signature: LengthUnits.millimeter,  # mm²
-                VOLUME._signature: LengthUnits.millimeter,  # mm³
-                FORCE._signature: UnitConstant(UnitDefinition("newton", "N", FORCE, 1.0)),
-                ENERGY._signature: UnitConstant(UnitDefinition("joule", "J", ENERGY, 1.0)),
-                SURFACE_TENSION._signature: UnitConstant(UnitDefinition("newton_per_meter", "N/m", SURFACE_TENSION, 1.0)),
-                ENERGY_PER_UNIT_AREA._signature: UnitConstant(UnitDefinition("joule_per_square_meter", "J/m²", ENERGY_PER_UNIT_AREA, 1.0)),
-            }
-        
-        # O(1) lookup for common dimensions
-        if result_dimension_sig in registry._dimension_cache:
-            return registry._dimension_cache[result_dimension_sig]
-        
-        # For rare combined dimensions, create SI base unit with descriptive name
-        result_dimension = DimensionSignature(result_dimension_sig)
-        
-        # Create descriptive name based on dimensional analysis
-        si_name = self._create_si_unit_name(result_dimension)
-        si_symbol = self._create_si_unit_symbol(result_dimension)
-        
-        temp_unit = UnitDefinition(
-            name=si_name,
-            symbol=si_symbol,
-            dimension=result_dimension,
-            si_factor=1.0
-        )
-        result_unit = UnitConstant(temp_unit)
-        
-        # Cache for future use
-        registry._dimension_cache[result_dimension_sig] = result_unit
-        return result_unit
-    
-    def _create_si_unit_name(self, dimension: DimensionSignature) -> str:
-        """Create descriptive SI unit name based on dimensional analysis."""
-        # For now, return a generic SI unit name. In the future, this could be enhanced
-        # to parse the dimension signature and create descriptive names like "newton_per_meter"
-        return f"si_derived_unit_{abs(hash(dimension._signature)) % 10000}"
-    
-    def _create_si_unit_symbol(self, _dimension: DimensionSignature) -> str:
-        """Create SI unit symbol based on dimensional analysis."""
-        # For complex units, return descriptive symbol based on common engineering units
-        return "SI_unit"
-    
-    def _find_result_unit(self, result_dimension: DimensionSignature,
-                         left_qty: FastQuantity, right_qty: FastQuantity) -> UnitConstant:
-        """Legacy method - kept for compatibility."""
-        return self._find_result_unit_fast(result_dimension._signature, left_qty, right_qty)
-    
-    # Ultra-fast comparisons
-    def __lt__(self, other: FastQuantity) -> bool:
-        if self._dimension_sig != other._dimension_sig:
-            raise ValueError("Cannot compare incompatible dimensions")
-        
-        # Fast path for same units
-        if self.unit == other.unit:
-            return self.value < other.value
-            
-        # Convert using cached SI factors
-        other_value = other.value * other._si_factor / self._si_factor
-        return self.value < other_value
-    
-    def __eq__(self, other) -> bool:
-        if not isinstance(other, FastQuantity):
-            return False
-        if self._dimension_sig != other._dimension_sig:
-            return False
-        
-        # Fast path for same units
-        if self.unit == other.unit:
-            return abs(self.value - other.value) < 1e-10
-            
-        # Convert using cached SI factors
-        other_value = other.value * other._si_factor / self._si_factor
-        return abs(self.value - other_value) < 1e-10
-    
-    def to(self, target_unit: UnitConstant) -> FastQuantity:
-        """Ultra-fast unit conversion."""
-        if self.unit == target_unit:
-            return FastQuantity(self.value, target_unit)
-        
-        # Direct SI factor conversion - avoid registry lookup
-        converted_value = self.value * self._si_factor / target_unit.si_factor
-        return FastQuantity(converted_value, target_unit)
-
-
-class TypeSafeVariable(Generic[DimensionType]):
-    """
-    Base class for type-safe variables with dimensional checking.
-    
-    This is a simple data container without dependencies on expressions or equations.
-    Mathematical operations are added by subclasses or mixins.
-    """
-    
-    # Class attribute defining which setter to use - subclasses can override
-    _setter_class = TypeSafeSetter
-    
-    def __init__(self, name: str, expected_dimension, is_known: bool = True):
-        self.name = name
-        self.symbol: str | None = None  # Will be set by EngineeringProblem to attribute name
-        self.expected_dimension = expected_dimension
-        self.quantity: FastQuantity | None = None
-        self.is_known = is_known
-    
-    def set(self, value: float):
-        """Create a setter for this variable using the class-specific setter type."""
-        return self._setter_class(self, value)
-    
-    @property
-    def unknown(self) -> Self:
-        """Mark this variable as unknown using fluent API."""
-        self.is_known = False
-        return self
-    
-    @property
-    def known(self) -> Self:
-        """Mark this variable as known using fluent API."""
-        self.is_known = True
-        return self
-    
-    def update(self, value=None, unit=None, quantity=None, is_known=None):
-        """Update variable properties flexibly."""
-        if quantity is not None:
-            self.quantity = quantity
-        elif value is not None:
-            # Create setter and call the appropriate unit property
-            setter = self.set(value)
-            if unit is not None:
-                # Try to find the unit property on the setter
-                if hasattr(setter, unit):
-                    getattr(setter, unit)
-                elif hasattr(setter, unit + 's'):  # Handle singular/plural
-                    getattr(setter, unit + 's')
-                elif unit.endswith('s') and hasattr(setter, unit[:-1]):  # Handle plural to singular
-                    getattr(setter, unit[:-1])
-                else:
-                    raise ValueError(f"Unit '{unit}' not found for {self.__class__.__name__}")
-            else:
-                # If no unit specified, we can't automatically choose a unit
-                # The caller should specify either a unit or a quantity
-                raise ValueError("Must specify either 'unit' with 'value' or provide 'quantity' directly")
-        if is_known is not None:
-            self.is_known = is_known
-        return self  # For method chaining
-    
-    def mark_known(self, quantity=None):
-        """Mark variable as known, optionally updating its value."""
-        self.is_known = True
-        if quantity is not None:
-            self.quantity = quantity
-        return self  # For method chaining
-    
-    def mark_unknown(self):
-        """Mark variable as unknown."""
-        self.is_known = False
-        return self  # For method chaining
-    
-    def __str__(self):
-        return f"{self.name}: {self.quantity}" if self.quantity else f"{self.name}: unset"
-
-

qnty/variable_types/base.py

@@ -1,58 +0,0 @@
-"""
-Base Variable Module Definition
-===============================
-
-Provides abstract base class for variable modules and registration functionality.
-"""
-
-from abc import ABC, abstractmethod
-from typing import Any
-
-
-class VariableModule(ABC):
-    """Abstract base class for variable modules."""
-    
-    @abstractmethod
-    def get_variable_class(self) -> type[Any]:
-        """Return the variable class for this module."""
-        pass
-    
-    @abstractmethod
-    def get_setter_class(self) -> type[Any]:
-        """Return the setter class for this module."""
-        pass
-    
-    @abstractmethod
-    def get_expected_dimension(self) -> Any:
-        """Return the expected dimension for this variable type."""
-        pass
-    
-    def register_to_registry(self, variable_registry):
-        """Register this variable module to the given registry."""
-        variable_registry.register_module(
-            self.get_expected_dimension(),
-            self.get_variable_class(),
-            self.get_setter_class()
-        )
-
-
-class VariableRegistry:
-    """Registry for variable modules."""
-    
-    def __init__(self):
-        self._modules = {}
-    
-    def register_module(self, dimension, variable_class, setter_class):
-        """Register a variable module."""
-        self._modules[dimension] = {
-            'variable_class': variable_class,
-            'setter_class': setter_class
-        }
-    
-    def get_variable_class(self, dimension):
-        """Get variable class for a dimension."""
-        return self._modules.get(dimension, {}).get('variable_class')
-    
-    def get_setter_class(self, dimension):
-        """Get setter class for a dimension."""
-        return self._modules.get(dimension, {}).get('setter_class')

qnty/variable_types/expression_variable.py

@@ -1,106 +0,0 @@
-"""
-Expression Variable Base Class
-==============================
-
-Base class that extends TypeSafeVariable with mathematical expression
-and equation capabilities.
-"""
-
-from __future__ import annotations
-
-from ..equation import Equation
-from ..expression import Expression, wrap_operand
-from ..variable import FastQuantity, TypeSafeVariable
-
-
-class ExpressionVariable(TypeSafeVariable):
-    """
-    TypeSafeVariable extended with expression and equation capabilities.
-    
-    This adds mathematical operations that create expressions and equations,
-    keeping the base TypeSafeVariable free of these dependencies.
-    """
-    
-    def equals(self, expression: Expression | TypeSafeVariable | FastQuantity | int | float):
-        """Create an equation: self = expression."""
-        # Wrap the expression in proper Expression type
-        rhs_expr = wrap_operand(expression)
-        return Equation(f"{self.name}_eq", self, rhs_expr)
-    
-    def __add__(self, other: TypeSafeVariable | FastQuantity | int | float) -> Expression:
-        """Add this variable to another operand, returning an Expression."""
-        return wrap_operand(self) + wrap_operand(other)
-
-    def __radd__(self, other: FastQuantity | int | float) -> Expression:
-        """Reverse add for this variable."""
-        return wrap_operand(other) + wrap_operand(self)
-    
-    def __sub__(self, other: TypeSafeVariable | FastQuantity | int | float) -> Expression:
-        """Subtract another operand from this variable, returning an Expression."""
-        return wrap_operand(self) - wrap_operand(other)
-    
-    def __rsub__(self, other: FastQuantity | int | float) -> Expression:
-        """Reverse subtract for this variable."""
-        return wrap_operand(other) - wrap_operand(self)
-    
-    def __mul__(self, other: TypeSafeVariable | FastQuantity | int | float) -> Expression:
-        """Multiply this variable by another operand, returning an Expression."""
-        return wrap_operand(self) * wrap_operand(other)
-    
-    def __rmul__(self, other: FastQuantity | int | float) -> Expression:
-        """Reverse multiply for this variable."""
-        return wrap_operand(other) * wrap_operand(self)
-    
-    def __truediv__(self, other: TypeSafeVariable | FastQuantity | int | float) -> Expression:
-        """Divide this variable by another operand, returning an Expression."""
-        return wrap_operand(self) / wrap_operand(other)
-
-    def __rtruediv__(self, other: FastQuantity | int | float) -> Expression:
-        """Reverse divide for this variable."""
-        return wrap_operand(other) / wrap_operand(self)
-    
-    def __pow__(self, other: TypeSafeVariable | FastQuantity | int | float) -> Expression:
-        """Raise this variable to a power, returning an Expression."""
-        return wrap_operand(self) ** wrap_operand(other)
-
-    def __rpow__(self, other: FastQuantity | int | float) -> Expression:
-        """Reverse power for this variable."""
-        return wrap_operand(other) ** wrap_operand(self)
-    
-    # Comparison methods
-    def lt(self, other: TypeSafeVariable | FastQuantity | int | float) -> Expression:
-        """Less than comparison (<)."""
-        from ..expression import BinaryOperation
-        return BinaryOperation('<', wrap_operand(self), wrap_operand(other))
-    
-    def leq(self, other: TypeSafeVariable | FastQuantity | int | float) -> Expression:
-        """Less than or equal comparison (<=)."""
-        from ..expression import BinaryOperation
-        return BinaryOperation('<=', wrap_operand(self), wrap_operand(other))
-    
-    def geq(self, other: TypeSafeVariable | FastQuantity | int | float) -> Expression:
-        """Greater than or equal comparison (>=)."""
-        from ..expression import BinaryOperation
-        return BinaryOperation('>=', wrap_operand(self), wrap_operand(other))
-    
-    def gt(self, other: TypeSafeVariable | FastQuantity | int | float) -> Expression:
-        """Greater than comparison (>)."""
-        from ..expression import BinaryOperation
-        return BinaryOperation('>', wrap_operand(self), wrap_operand(other))
-    
-    # Python comparison operators
-    def __lt__(self, other: TypeSafeVariable | FastQuantity | int | float) -> Expression:
-        """Less than comparison (<) operator."""
-        return self.lt(other)
-    
-    def __le__(self, other: TypeSafeVariable | FastQuantity | int | float) -> Expression:
-        """Less than or equal comparison (<=) operator."""
-        return self.leq(other)
-    
-    def __gt__(self, other: TypeSafeVariable | FastQuantity | int | float) -> Expression:
-        """Greater than comparison (>) operator."""
-        return self.gt(other)
-    
-    def __ge__(self, other: TypeSafeVariable | FastQuantity | int | float) -> Expression:
-        """Greater than or equal comparison (>=) operator."""
-        return self.geq(other)

qnty/variable_types/typed_variable.py

@@ -1,87 +0,0 @@
-"""
-Typed Variable Base Class
-=========================
-
-Base class that provides common constructor logic for all typed variables,
-handling both the original syntax and the new value/unit/name syntax.
-"""
-
-from ..dimension import DimensionSignature
-from ..variable import TypeSafeSetter
-from .expression_variable import ExpressionVariable
-
-
-class TypedVariable(ExpressionVariable):
-    """
-    Base class for typed variables with common constructor logic.
-    
-    Subclasses need to define:
-    - _setter_class: The setter class to use
-    - _expected_dimension: The expected dimension
-    - _default_unit_property: The default unit property name for fallback
-    """
-    
-    _setter_class: type[TypeSafeSetter] | None = None
-    _expected_dimension: DimensionSignature | None = None
-    _default_unit_property: str | None = None
-    
-    def __init__(self, *args, is_known: bool = True):
-        """
-        Flexible constructor supporting multiple syntaxes.
-        
-        Single argument: TypedVariable("name")
-        Three arguments: TypedVariable(value, "unit", "name")
-        Two arguments (Dimensionless only): TypedVariable(value, "name")
-        """
-        if self._setter_class is None or self._expected_dimension is None:
-            raise NotImplementedError("Subclass must define _setter_class and _expected_dimension")
-        
-        # Handle different argument patterns
-        if len(args) == 1:
-            # Original syntax: Variable("name")
-            super().__init__(args[0], self._expected_dimension, is_known=is_known)
-            
-        elif len(args) == 2 and self.__class__.__name__ == 'Dimensionless':
-            # Special case for Dimensionless: (value, "name")
-            value, name = args
-            super().__init__(name, self._expected_dimension, is_known=is_known)
-            setter = self._setter_class(self, value)
-            # For DimensionlessSetter, use the dimensionless property
-            # Type ignore since we know DimensionlessSetter has this property
-            getattr(setter, 'dimensionless', None)  # type: ignore
-            
-        elif len(args) == 3:
-            # New syntax: Variable(value, "unit", "name")
-            # But Dimensionless doesn't support this pattern
-            if self.__class__.__name__ == 'Dimensionless':
-                raise ValueError(f"{self.__class__.__name__} expects either 1 argument (name) or 2 arguments (value, name), got {len(args)}")
-            
-            value, unit, name = args
-            super().__init__(name, self._expected_dimension, is_known=is_known)
-            
-            # Auto-set the value with the specified unit
-            setter = self._setter_class(self, value)
-            
-            # Try to find the unit property on the setter
-            if hasattr(setter, unit):
-                getattr(setter, unit)
-            elif hasattr(setter, unit + 's'):  # Handle singular/plural
-                getattr(setter, unit + 's')
-            elif unit.endswith('s') and hasattr(setter, unit[:-1]):  # Handle plural to singular
-                getattr(setter, unit[:-1])
-            else:
-                # Unit not found - provide helpful error with available units
-                unit_properties = [attr for attr in dir(setter)
-                                 if not attr.startswith('_') and attr != 'value' and attr != 'variable']
-                available_units = ', '.join(sorted(unit_properties[:10]))  # Show first 10 units
-                if len(unit_properties) > 10:
-                    available_units += f' ... and {len(unit_properties) - 10} more'
-                raise ValueError(f"Unit '{unit}' not found for {self.__class__.__name__}. "
-                               f"Available units: {available_units}")
-                    
-        else:
-            # More specific error messages matching test expectations
-            if self.__class__.__name__ == 'Dimensionless':
-                raise ValueError(f"{self.__class__.__name__} expects either 1 argument (name) or 2 arguments (value, name), got {len(args)}")
-            else:
-                raise ValueError(f"{self.__class__.__name__} expects either 1 argument (name) or 3 arguments (value, unit, name), got {len(args)}")