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

qnty/{expression.py → expressions/nodes.py}

@@ -1,50 +1,32 @@
 """
-Expression System
-=================
+Expression AST Nodes
+===================
 
-Mathematical expressions for building equation trees with qnty variables.
+Core abstract syntax tree nodes for mathematical expressions.
 """
 
 import math
 from abc import ABC, abstractmethod
-from typing import Union, cast
+from typing import TYPE_CHECKING, Union
 
-from .units import DimensionlessUnits
+if TYPE_CHECKING:
+    from ..quantities.quantity import Quantity, TypeSafeVariable
 
-# if TYPE_CHECKING:
-from .variable import FastQuantity, TypeSafeVariable
-
-
-def wrap_operand(operand: Union['Expression', 'TypeSafeVariable', 'FastQuantity', int, float]) -> 'Expression':
-    """
-    Wrap non-Expression operands in appropriate Expression subclasses.
-    
-    This function handles type conversion without circular imports by using
-    duck typing and delayed imports where necessary.
-    """
-    # Type guard for Expression types
-    if hasattr(operand, 'evaluate') and hasattr(operand, 'get_variables'):
-        # Already an Expression
-        return cast('Expression', operand)
-    elif hasattr(operand, 'name') and hasattr(operand, 'quantity') and hasattr(operand, 'is_known'):
-        # TypeSafeVariable-like object
-        return VariableReference(cast('TypeSafeVariable', operand))
-    elif hasattr(operand, 'value') and hasattr(operand, 'unit') and hasattr(operand, '_dimension_sig'):
-        # FastQuantity-like object
-        return Constant(cast('FastQuantity', operand))
-    elif isinstance(operand, int | float):
-        # Numeric value - create dimensionless quantity
-
-        return Constant(FastQuantity(float(operand), DimensionlessUnits.dimensionless))
-    else:
-        raise TypeError(f"Cannot convert {type(operand)} to Expression")
+from ..generated.units import DimensionlessUnits
+from ..quantities.quantity import Quantity, TypeSafeVariable
+from .cache import _EXPRESSION_RESULT_CACHE, _MAX_EXPRESSION_CACHE_SIZE, wrap_operand
 
 
 class Expression(ABC):
     """Abstract base class for mathematical expressions."""
     
+    # Class-level optimization settings
+    _scope_cache = {}
+    _auto_eval_enabled = False  # Disabled by default for performance
+    _max_scope_cache_size = 100  # Limit scope cache size
+    
     @abstractmethod
-    def evaluate(self, variable_values: dict[str, 'TypeSafeVariable']) -> 'FastQuantity':
+    def evaluate(self, variable_values: dict[str, 'TypeSafeVariable']) -> 'Quantity':
         """Evaluate the expression given variable values."""
         pass
     
@@ -63,55 +45,67 @@ class Expression(ABC):
         pass
     
     def _discover_variables_from_scope(self) -> dict[str, 'TypeSafeVariable']:
-        """Automatically discover variables from the calling scope."""
+        """Automatically discover variables from the calling scope (optimized)."""
+        # Skip if auto-evaluation is disabled
+        if not self._auto_eval_enabled:
+            return {}
+            
+        # Check cache first with size limit
+        cache_key = id(self)
+        if cache_key in self._scope_cache:
+            return self._scope_cache[cache_key]
+            
+        # Clean cache if it gets too large
+        if len(self._scope_cache) >= self._max_scope_cache_size:
+            self._scope_cache.clear()
+            
         import inspect
         
         # Get the frame that called this method (skip through __str__ calls)
         frame = inspect.currentframe()
         try:
-            # Skip frames until we find one outside the expression system
-            while frame and (
+            # Skip frames until we find one outside the expression system (with depth limit)
+            depth = 0
+            max_depth = 6  # Reduced from unlimited for performance
+            while frame and depth < max_depth and (
                 frame.f_code.co_filename.endswith('expression.py') or
                 frame.f_code.co_name in ['__str__', '__repr__']
             ):
                 frame = frame.f_back
+                depth += 1
             
             if not frame:
                 return {}
                 
-            # Combine local and global variables
-            all_vars = {**frame.f_globals, **frame.f_locals}
-            
-            # Find TypeSafeVariable objects that match our required variables
+            # Get required variables first to optimize search
             required_vars = self.get_variables()
+            if not required_vars:
+                return {}
+                
             discovered = {}
             
+            # Search locals first (most common case)
+            local_vars = frame.f_locals
             for var_name in required_vars:
-                for name, obj in all_vars.items():
-                    # Check if this is a TypeSafeVariable with matching symbol/name
-                    if hasattr(obj, 'symbol') and obj.symbol == var_name:
+                # Direct lookup first (fastest)
+                if var_name in local_vars:
+                    obj = local_vars[var_name]
+                    if isinstance(obj, TypeSafeVariable):
                         discovered[var_name] = obj
-                        break
-                    elif hasattr(obj, 'name') and obj.name == var_name:
-                        discovered[var_name] = obj
-                        break
-                    # Check if this is an Expression that can be evaluated to get the variable
-                    elif hasattr(obj, 'get_variables') and name == var_name:
-                        # This is an expression named after our variable - try to evaluate it
-                        try:
-                            if hasattr(obj, '_can_auto_evaluate'):
-                                can_eval, expr_vars = obj._can_auto_evaluate()
-                                if can_eval:
-                                    result = obj.evaluate(expr_vars)
-                                    # Create a temporary variable to hold the result
-                                    from .variables import Length  # Import here to avoid circular import
-                                    temp_var = Length(result.value, result.unit.symbol, f"temp_{var_name}")
-                                    temp_var.symbol = var_name
-                                    discovered[var_name] = temp_var
-                                    break
-                        except Exception:
-                            pass
+                        continue
+            
+            # Search globals only for remaining variables
+            if len(discovered) < len(required_vars):
+                global_vars = frame.f_globals
+                remaining_vars = required_vars - discovered.keys()
+                for var_name in remaining_vars:
+                    if var_name in global_vars:
+                        obj = global_vars[var_name]
+                        if isinstance(obj, TypeSafeVariable):
+                            discovered[var_name] = obj
             
+            # Cache the result
+            self._scope_cache[cache_key] = discovered
             return discovered
             
         finally:
@@ -136,57 +130,66 @@ class Expression(ABC):
         except Exception:
             return False, {}
     
-    def __add__(self, other: Union['Expression', 'TypeSafeVariable', 'FastQuantity', int, float]) -> 'Expression':
+    def __add__(self, other: Union['Expression', 'TypeSafeVariable', 'Quantity', int, float]) -> 'Expression':
         return BinaryOperation('+', self, wrap_operand(other))
     
-    def __radd__(self, other: Union['TypeSafeVariable', 'FastQuantity', int, float]) -> 'Expression':
+    def __radd__(self, other: Union['TypeSafeVariable', 'Quantity', int, float]) -> 'Expression':
         return BinaryOperation('+', wrap_operand(other), self)
     
-    def __sub__(self, other: Union['Expression', 'TypeSafeVariable', 'FastQuantity', int, float]) -> 'Expression':
+    def __sub__(self, other: Union['Expression', 'TypeSafeVariable', 'Quantity', int, float]) -> 'Expression':
         return BinaryOperation('-', self, wrap_operand(other))
     
-    def __rsub__(self, other: Union['TypeSafeVariable', 'FastQuantity', int, float]) -> 'Expression':
+    def __rsub__(self, other: Union['TypeSafeVariable', 'Quantity', int, float]) -> 'Expression':
         return BinaryOperation('-', wrap_operand(other), self)
     
-    def __mul__(self, other: Union['Expression', 'TypeSafeVariable', 'FastQuantity', int, float]) -> 'Expression':
+    def __mul__(self, other: Union['Expression', 'TypeSafeVariable', 'Quantity', int, float]) -> 'Expression':
         return BinaryOperation('*', self, wrap_operand(other))
     
-    def __rmul__(self, other: Union['TypeSafeVariable', 'FastQuantity', int, float]) -> 'Expression':
+    def __rmul__(self, other: Union['TypeSafeVariable', 'Quantity', int, float]) -> 'Expression':
         return BinaryOperation('*', wrap_operand(other), self)
     
-    def __truediv__(self, other: Union['Expression', 'TypeSafeVariable', 'FastQuantity', int, float]) -> 'Expression':
+    def __truediv__(self, other: Union['Expression', 'TypeSafeVariable', 'Quantity', int, float]) -> 'Expression':
         return BinaryOperation('/', self, wrap_operand(other))
     
-    def __rtruediv__(self, other: Union['TypeSafeVariable', 'FastQuantity', int, float]) -> 'Expression':
+    def __rtruediv__(self, other: Union['TypeSafeVariable', 'Quantity', int, float]) -> 'Expression':
         return BinaryOperation('/', wrap_operand(other), self)
     
-    def __pow__(self, other: Union['Expression', 'TypeSafeVariable', 'FastQuantity', int, float]) -> 'Expression':
+    def __pow__(self, other: Union['Expression', 'TypeSafeVariable', 'Quantity', int, float]) -> 'Expression':
         return BinaryOperation('**', self, wrap_operand(other))
     
-    def __rpow__(self, other: Union['TypeSafeVariable', 'FastQuantity', int, float]) -> 'Expression':
+    def __rpow__(self, other: Union['TypeSafeVariable', 'Quantity', int, float]) -> 'Expression':
         return BinaryOperation('**', wrap_operand(other), self)
     
-    # Comparison operators for conditional expressions
-    def __lt__(self, other: Union['Expression', 'TypeSafeVariable', 'FastQuantity', int, float]) -> 'BinaryOperation':
-        return BinaryOperation('<', self, self._wrap_operand(other))
+    def __abs__(self) -> 'Expression':
+        """Absolute value of the expression."""
+        return UnaryFunction('abs', self)
+    
+    # Comparison operators for conditional expressions (consolidated)
+    def _make_comparison(self, operator: str, other) -> 'BinaryOperation':
+        """Helper method to create comparison operations."""
+        return BinaryOperation(operator, self, wrap_operand(other))
+    
+    def __lt__(self, other: Union['Expression', 'TypeSafeVariable', 'Quantity', int, float]) -> 'BinaryOperation':
+        return self._make_comparison('<', other)
 
-    def __le__(self, other: Union['Expression', 'TypeSafeVariable', 'FastQuantity', int, float]) -> 'BinaryOperation':
-        return BinaryOperation('<=', self, self._wrap_operand(other))
+    def __le__(self, other: Union['Expression', 'TypeSafeVariable', 'Quantity', int, float]) -> 'BinaryOperation':
+        return self._make_comparison('<=', other)
     
-    def __gt__(self, other: Union['Expression', 'TypeSafeVariable', 'FastQuantity', int, float]) -> 'BinaryOperation':
-        return BinaryOperation('>', self, self._wrap_operand(other))
+    def __gt__(self, other: Union['Expression', 'TypeSafeVariable', 'Quantity', int, float]) -> 'BinaryOperation':
+        return self._make_comparison('>', other)
     
-    def __ge__(self, other: Union['Expression', 'TypeSafeVariable', 'FastQuantity', int, float]) -> 'BinaryOperation':
-        return BinaryOperation('>=', self, self._wrap_operand(other))
+    def __ge__(self, other: Union['Expression', 'TypeSafeVariable', 'Quantity', int, float]) -> 'BinaryOperation':
+        return self._make_comparison('>=', other)
     
     @staticmethod
-    def _wrap_operand(operand: Union['Expression', 'TypeSafeVariable', 'FastQuantity', int, float]) -> 'Expression':
+    def _wrap_operand(operand: Union['Expression', 'TypeSafeVariable', 'Quantity', int, float]) -> 'Expression':
         """Wrap non-Expression operands in appropriate Expression subclasses."""
         return wrap_operand(operand)
 
 
 class VariableReference(Expression):
     """Reference to a variable in an expression with performance optimizations."""
+    __slots__ = ('variable', '_cached_name', '_last_symbol')
     
     def __init__(self, variable: 'TypeSafeVariable'):
         self.variable = variable
@@ -204,7 +207,7 @@ class VariableReference(Expression):
             self._last_symbol = current_symbol
         return self._cached_name
 
-    def evaluate(self, variable_values: dict[str, 'TypeSafeVariable']) -> 'FastQuantity':
+    def evaluate(self, variable_values: dict[str, 'TypeSafeVariable']) -> 'Quantity':
         try:
             if self.name in variable_values:
                 var = variable_values[self.name]
@@ -236,11 +239,12 @@ class VariableReference(Expression):
 
 class Constant(Expression):
     """Constant value in an expression."""
+    __slots__ = ('value',)
     
-    def __init__(self, value: 'FastQuantity'):
+    def __init__(self, value: 'Quantity'):
         self.value = value
     
-    def evaluate(self, variable_values: dict[str, 'TypeSafeVariable']) -> 'FastQuantity':
+    def evaluate(self, variable_values: dict[str, 'TypeSafeVariable']) -> 'Quantity':
         del variable_values  # Suppress unused variable warning
         return self.value
     
@@ -256,70 +260,130 @@ class Constant(Expression):
 
 class BinaryOperation(Expression):
     """Binary operation between two expressions."""
+    __slots__ = ('operator', 'left', 'right')
+    
+    # Operator dispatch table for better performance
+    _ARITHMETIC_OPS = {'+', '-', '*', '/', '**'}
+    _COMPARISON_OPS = {'<', '<=', '>', '>=', '==', '!='}
     
     def __init__(self, operator: str, left: Expression, right: Expression):
         self.operator = operator
         self.left = left
         self.right = right
 
-    def evaluate(self, variable_values: dict[str, 'TypeSafeVariable']) -> 'FastQuantity':
+    def evaluate(self, variable_values: dict[str, 'TypeSafeVariable']) -> 'Quantity':
         try:
+            # Fast path for constant expressions (both sides are constants)
+            if isinstance(self.left, Constant) and isinstance(self.right, Constant):
+                cache_key = (id(self), self.operator, id(self.left.value), id(self.right.value))
+                if cache_key in _EXPRESSION_RESULT_CACHE:
+                    return _EXPRESSION_RESULT_CACHE[cache_key]
+                
+                # Clean cache if it gets too large
+                if len(_EXPRESSION_RESULT_CACHE) >= _MAX_EXPRESSION_CACHE_SIZE:
+                    _EXPRESSION_RESULT_CACHE.clear()
+            else:
+                cache_key = None
+            
             left_val = self.left.evaluate(variable_values)
             right_val = self.right.evaluate(variable_values)
             
-            if self.operator == '+':
-                return left_val + right_val
-            elif self.operator == '-':
-                return left_val - right_val
-            elif self.operator == '*':
-                return left_val * right_val
-            elif self.operator == '/':
-                # Check for division by zero
-                if abs(right_val.value) < 1e-15:
-                    raise ValueError(f"Division by zero in expression: {self}")
-                return left_val / right_val
-            elif self.operator == '**':
-                # For power, right side should be dimensionless
-                if isinstance(right_val.value, int | float):
-                    if right_val.value < 0 and left_val.value < 0:
-                        raise ValueError(f"Negative base with negative exponent: {left_val.value}^{right_val.value}")
-                    result_value = left_val.value ** right_val.value
-                    # For power operations, we need to handle units carefully
-                    # This is a simplified implementation
-                    return FastQuantity(result_value, left_val.unit)
-                else:
-                    raise ValueError("Exponent must be dimensionless number")
-            elif self.operator in ['<', '<=', '>', '>=', '==', '!=']:
-                # Comparison operations - return dimensionless 1.0 or 0.0
-                # Convert to same units for comparison if possible
-                try:
-                    if left_val._dimension_sig == right_val._dimension_sig and left_val.unit != right_val.unit:
-                        right_val = right_val.to(left_val.unit)
-                except (ValueError, TypeError, AttributeError):
-                    pass
-                
-                result = False  # Initialize result
-                if self.operator == '<':
-                    result = left_val.value < right_val.value
-                elif self.operator == '<=':
-                    result = left_val.value <= right_val.value
-                elif self.operator == '>':
-                    result = left_val.value > right_val.value
-                elif self.operator == '>=':
-                    result = left_val.value >= right_val.value
-                elif self.operator == '==':
-                    result = abs(left_val.value - right_val.value) < 1e-10
-                elif self.operator == '!=':
-                    result = abs(left_val.value - right_val.value) >= 1e-10
-                
-                return FastQuantity(1.0 if result else 0.0, DimensionlessUnits.dimensionless)
+            # Fast dispatch for arithmetic operations
+            if self.operator in self._ARITHMETIC_OPS:
+                result = self._evaluate_arithmetic(left_val, right_val)
+            elif self.operator in self._COMPARISON_OPS:
+                result = self._evaluate_comparison(left_val, right_val)
             else:
                 raise ValueError(f"Unknown operator: {self.operator}")
+            
+            # Cache result for constant expressions
+            if cache_key is not None:
+                _EXPRESSION_RESULT_CACHE[cache_key] = result
+                
+            return result
         except Exception as e:
             if isinstance(e, ValueError):
                 raise
             raise ValueError(f"Error evaluating binary operation '{self}': {e}") from e
     
+    def _evaluate_arithmetic(self, left_val: 'Quantity', right_val: 'Quantity') -> 'Quantity':
+        """Evaluate arithmetic operations with fast paths."""
+        # Fast path optimizations for common cases
+        if self.operator == '*':
+            # Fast path for multiplication by 1
+            if right_val.value == 1.0:
+                return left_val
+            elif left_val.value == 1.0:
+                return right_val
+            # Fast path for multiplication by 0
+            elif right_val.value == 0.0 or left_val.value == 0.0:
+                return Quantity(0.0, left_val.unit if right_val.value == 0.0 else right_val.unit)
+            return left_val * right_val
+        elif self.operator == '+':
+            # Fast path for addition with 0
+            if right_val.value == 0.0:
+                return left_val
+            elif left_val.value == 0.0:
+                return right_val
+            return left_val + right_val
+        elif self.operator == '-':
+            # Fast path for subtraction with 0
+            if right_val.value == 0.0:
+                return left_val
+            return left_val - right_val
+        elif self.operator == '/':
+            # Check for division by zero
+            if abs(right_val.value) < 1e-15:
+                raise ValueError(f"Division by zero in expression: {self}")
+            # Fast path for division by 1
+            if right_val.value == 1.0:
+                return left_val
+            return left_val / right_val
+        elif self.operator == '**':
+            # For power, right side should be dimensionless
+            if isinstance(right_val.value, int | float):
+                # Fast paths for common exponents
+                if right_val.value == 1.0:
+                    return left_val
+                elif right_val.value == 0.0:
+                    return Quantity(1.0, DimensionlessUnits.dimensionless)
+                elif right_val.value == 2.0:
+                    return left_val * left_val  # Use multiplication for squaring
+                
+                if right_val.value < 0 and left_val.value < 0:
+                    raise ValueError(f"Negative base with negative exponent: {left_val.value}^{right_val.value}")
+                result_value = left_val.value ** right_val.value
+                # For power operations, we need to handle units carefully
+                # This is a simplified implementation
+                return Quantity(result_value, left_val.unit)
+            else:
+                raise ValueError("Exponent must be dimensionless number")
+        else:
+            # Unknown operator - should not happen
+            raise ValueError(f"Unknown arithmetic operator: {self.operator}")
+    
+    def _evaluate_comparison(self, left_val: 'Quantity', right_val: 'Quantity') -> 'Quantity':
+        """Evaluate comparison operations."""
+        # Convert to same units for comparison if possible
+        try:
+            if left_val._dimension_sig == right_val._dimension_sig and left_val.unit != right_val.unit:
+                right_val = right_val.to(left_val.unit)
+        except (ValueError, TypeError, AttributeError):
+            pass
+        
+        # Use dispatch dictionary for comparisons
+        ops = {
+            '<': lambda left, right: left < right,
+            '<=': lambda left, right: left <= right,
+            '>': lambda left, right: left > right,
+            '>=': lambda left, right: left >= right,
+            '==': lambda left, right: abs(left - right) < 1e-10,
+            '!=': lambda left, right: abs(left - right) >= 1e-10
+        }
+        
+        result = ops[self.operator](left_val.value, right_val.value)
+        return Quantity(1.0 if result else 0.0, DimensionlessUnits.dimensionless)
+    
     def get_variables(self) -> set[str]:
         return self.left.get_variables() | self.right.get_variables()
     
@@ -375,46 +439,46 @@ class BinaryOperation(Expression):
         return f"{left_str} {self.operator} {right_str}"
 
 
-
 class UnaryFunction(Expression):
     """Unary mathematical function expression."""
+    __slots__ = ('function_name', 'operand')
     
     def __init__(self, function_name: str, operand: Expression):
         self.function_name = function_name
         self.operand = operand
     
-    def evaluate(self, variable_values: dict[str, 'TypeSafeVariable']) -> 'FastQuantity':
+    def evaluate(self, variable_values: dict[str, 'TypeSafeVariable']) -> 'Quantity':
         
         operand_val = self.operand.evaluate(variable_values)
         
         if self.function_name == 'sin':
             # Assume input is in radians, result is dimensionless
             result_value = math.sin(operand_val.value)
-            return FastQuantity(result_value, DimensionlessUnits.dimensionless)
+            return Quantity(result_value, DimensionlessUnits.dimensionless)
         elif self.function_name == 'cos':
             result_value = math.cos(operand_val.value)
-            return FastQuantity(result_value, DimensionlessUnits.dimensionless)
+            return Quantity(result_value, DimensionlessUnits.dimensionless)
         elif self.function_name == 'tan':
             result_value = math.tan(operand_val.value)
-            return FastQuantity(result_value, DimensionlessUnits.dimensionless)
+            return Quantity(result_value, DimensionlessUnits.dimensionless)
         elif self.function_name == 'sqrt':
             # For sqrt, we need to handle units carefully
             result_value = math.sqrt(operand_val.value)
             # This is simplified - proper unit handling would need dimensional analysis
-            return FastQuantity(result_value, operand_val.unit)
+            return Quantity(result_value, operand_val.unit)
         elif self.function_name == 'abs':
-            return FastQuantity(abs(operand_val.value), operand_val.unit)
+            return Quantity(abs(operand_val.value), operand_val.unit)
         elif self.function_name == 'ln':
             # Natural log - input should be dimensionless
             result_value = math.log(operand_val.value)
-            return FastQuantity(result_value, DimensionlessUnits.dimensionless)
+            return Quantity(result_value, DimensionlessUnits.dimensionless)
         elif self.function_name == 'log10':
             result_value = math.log10(operand_val.value)
-            return FastQuantity(result_value, DimensionlessUnits.dimensionless)
+            return Quantity(result_value, DimensionlessUnits.dimensionless)
         elif self.function_name == 'exp':
             # Exponential - input should be dimensionless
             result_value = math.exp(operand_val.value)
-            return FastQuantity(result_value, DimensionlessUnits.dimensionless)
+            return Quantity(result_value, DimensionlessUnits.dimensionless)
         else:
             raise ValueError(f"Unknown function: {self.function_name}")
     
@@ -439,13 +503,14 @@ class UnaryFunction(Expression):
 
 class ConditionalExpression(Expression):
     """Conditional expression: if condition then true_expr else false_expr."""
+    __slots__ = ('condition', 'true_expr', 'false_expr')
     
     def __init__(self, condition: Expression, true_expr: Expression, false_expr: Expression):
         self.condition = condition
         self.true_expr = true_expr
         self.false_expr = false_expr
     
-    def evaluate(self, variable_values: dict[str, 'TypeSafeVariable']) -> 'FastQuantity':
+    def evaluate(self, variable_values: dict[str, 'TypeSafeVariable']) -> 'Quantity':
         condition_val = self.condition.evaluate(variable_values)
         # Consider non-zero as True
         if abs(condition_val.value) > 1e-10:
@@ -479,75 +544,3 @@ class ConditionalExpression(Expression):
     
     def __str__(self) -> str:
         return f"if({self.condition}, {self.true_expr}, {self.false_expr})"
-
-
-# Convenience functions for mathematical operations
-def sin(expr: Union[Expression, 'TypeSafeVariable', 'FastQuantity', int, float]) -> UnaryFunction:
-    """Sine function."""
-    return UnaryFunction('sin', Expression._wrap_operand(expr))
-
-def cos(expr: Union[Expression, 'TypeSafeVariable', 'FastQuantity', int, float]) -> UnaryFunction:
-    """Cosine function."""
-    return UnaryFunction('cos', Expression._wrap_operand(expr))
-
-def tan(expr: Union[Expression, 'TypeSafeVariable', 'FastQuantity', int, float]) -> UnaryFunction:
-    """Tangent function."""
-    return UnaryFunction('tan', Expression._wrap_operand(expr))
-
-def sqrt(expr: Union[Expression, 'TypeSafeVariable', 'FastQuantity', int, float]) -> UnaryFunction:
-    """Square root function."""
-    return UnaryFunction('sqrt', Expression._wrap_operand(expr))
-
-def abs_expr(expr: Union[Expression, 'TypeSafeVariable', 'FastQuantity', int, float]) -> UnaryFunction:
-    """Absolute value function."""
-    return UnaryFunction('abs', Expression._wrap_operand(expr))
-
-def ln(expr: Union[Expression, 'TypeSafeVariable', 'FastQuantity', int, float]) -> UnaryFunction:
-    """Natural logarithm function."""
-    return UnaryFunction('ln', Expression._wrap_operand(expr))
-
-def log10(expr: Union[Expression, 'TypeSafeVariable', 'FastQuantity', int, float]) -> UnaryFunction:
-    """Base-10 logarithm function."""
-    return UnaryFunction('log10', Expression._wrap_operand(expr))
-
-def exp(expr: Union[Expression, 'TypeSafeVariable', 'FastQuantity', int, float]) -> UnaryFunction:
-    """Exponential function."""
-    return UnaryFunction('exp', Expression._wrap_operand(expr))
-
-def cond_expr(condition: Union[Expression, 'BinaryOperation'],
-              true_expr: Union[Expression, 'TypeSafeVariable', 'FastQuantity', int, float],
-              false_expr: Union[Expression, 'TypeSafeVariable', 'FastQuantity', int, float]) -> ConditionalExpression:
-    """Conditional expression: if condition then true_expr else false_expr."""
-    return ConditionalExpression(
-        condition if isinstance(condition, Expression) else condition,
-        Expression._wrap_operand(true_expr),
-        Expression._wrap_operand(false_expr)
-    )
-
-def min_expr(*expressions: Union[Expression, 'TypeSafeVariable', 'FastQuantity', int, float]) -> Expression:
-    """Minimum of multiple expressions."""
-    if len(expressions) < 2:
-        raise ValueError("min_expr requires at least 2 arguments")
-    
-    wrapped_expressions = [Expression._wrap_operand(expr) for expr in expressions]
-    result = wrapped_expressions[0]
-    
-    for expr in wrapped_expressions[1:]:
-        # min(a, b) = if(a < b, a, b)
-        result = cond_expr(result < expr, result, expr)
-    
-    return result
-
-def max_expr(*expressions: Union[Expression, 'TypeSafeVariable', 'FastQuantity', int, float]) -> Expression:
-    """Maximum of multiple expressions."""
-    if len(expressions) < 2:
-        raise ValueError("max_expr requires at least 2 arguments")
-    
-    wrapped_expressions = [Expression._wrap_operand(expr) for expr in expressions]
-    result = wrapped_expressions[0]
-    
-    for expr in wrapped_expressions[1:]:
-        # max(a, b) = if(a > b, a, b)
-        result = cond_expr(result > expr, result, expr)
-    
-    return result