qnty 0.1.3__py3-none-any.whl → 0.1.5__py3-none-any.whl

qnty/equations/equation.py

@@ -98,12 +98,38 @@ class Equation:
         if var_obj is None:
             raise ValueError(f"Variable '{target_var}' not found in variable_values")
 
-        # Convert result to the target variable's original unit if it had one
+        # Convert result to preferred unit or original unit if available
+        target_unit_constant = None
+        
+        # First priority: existing quantity unit
         if var_obj.quantity is not None and var_obj.quantity.unit is not None:
+            target_unit_constant = var_obj.quantity.unit
+        # Second priority: preferred unit from constructor
+        elif hasattr(var_obj, 'preferred_unit') and var_obj.preferred_unit is not None:
+            # Look up unit constant from string name
+            preferred_unit_name = var_obj.preferred_unit
             try:
-                result_qty = result_qty.to(var_obj.quantity.unit)
+                # Get the dimension-specific units class
+                class_name = var_obj.__class__.__name__
+                units_class_name = f'{class_name}Units'
+                
+                # Import field_units dynamically to avoid circular imports
+                from ..units import field_units
+                units_class = getattr(field_units, units_class_name, None)
+                if units_class and hasattr(units_class, preferred_unit_name):
+                    target_unit_constant = getattr(units_class, preferred_unit_name)
+                    _logger.debug(f"Found preferred unit constant: {preferred_unit_name}")
+                else:
+                    _logger.debug(f"Could not find unit constant for {preferred_unit_name} in {units_class_name}")
+            except (ImportError, AttributeError) as e:
+                _logger.debug(f"Failed to lookup preferred unit {preferred_unit_name}: {e}")
+            
+        if target_unit_constant is not None:
+            try:
+                result_qty = result_qty.to(target_unit_constant)
+                _logger.debug(f"Converted {target_var} result to preferred unit: {target_unit_constant.symbol}")
             except (ValueError, TypeError, AttributeError) as e:
-                _logger.debug(f"Unit conversion failed for {target_var}: {e}. Using calculated unit.")
+                _logger.debug(f"Unit conversion failed for {target_var} to {target_unit_constant}: {e}. Using calculated unit.")
 
         # Update the variable and return it
         var_obj.quantity = result_qty

qnty/expressions/functions.py

@@ -16,8 +16,24 @@ ConditionalOperand = Expression | BinaryOperation
 def _create_unary_function(name: str, docstring: str):
     """Factory function for creating unary mathematical functions."""
 
-    def func(expr: ExpressionOperand) -> UnaryFunction:
-        return UnaryFunction(name, wrap_operand(expr))
+    def func(expr: ExpressionOperand):
+        from .nodes import VariableReference
+        
+        wrapped_expr = wrap_operand(expr)
+        
+        # For known quantities (FieldQnty with known values), evaluate immediately
+        if hasattr(expr, 'quantity') and expr.quantity is not None:
+            try:
+                unary_func = UnaryFunction(name, wrapped_expr)
+                # Use an empty variable dict since we have the quantity directly
+                result = unary_func.evaluate({})
+                return result
+            except (ValueError, TypeError, AttributeError):
+                # Fall back to expression if evaluation fails
+                pass
+        
+        # For unknown variables or expressions, return the UnaryFunction
+        return UnaryFunction(name, wrapped_expr)
 
     func.__name__ = name
     func.__doc__ = docstring

qnty/expressions/nodes.py

@@ -304,32 +304,37 @@ class BinaryOperation(Expression):
         right_value = right_val.value
         
         # ENHANCED FAST PATHS: Check most common optimizations first
+        # BUT ONLY when they don't affect dimensional analysis!
+        
         # Identity optimizations (1.0 multiplication) - most frequent case
-        if right_value == 1.0:
+        # Only safe when the 1.0 value is dimensionless
+        if right_value == 1.0 and right_val._dimension_sig == 1:
             return left_val
-        elif left_value == 1.0:
+        elif left_value == 1.0 and left_val._dimension_sig == 1:
             return right_val
 
         # Zero optimizations - second most common
-        elif right_value == 0.0:
-            return Quantity(0.0, right_val.unit)
-        elif left_value == 0.0:
-            return Quantity(0.0, left_val.unit)
+        # Zero multiplication always gives zero, but we need proper units via full multiplication
+        elif right_value == 0.0 or left_value == 0.0:
+            # Use full multiplication to get correct dimensional result for zero
+            return left_val * right_val
 
         # Additional fast paths for common values
-        elif right_value == -1.0:
+        # Only safe when the scalar value is dimensionless
+        elif right_value == -1.0 and right_val._dimension_sig == 1:
             return Quantity(-left_value, left_val.unit)
-        elif left_value == -1.0:
+        elif left_value == -1.0 and left_val._dimension_sig == 1:
             return Quantity(-right_value, right_val.unit)
         
         # ADDITIONAL COMMON CASES: Powers of 2 and 0.5 (very common in engineering)
-        elif right_value == 2.0:
+        # Only safe when the scalar value is dimensionless
+        elif right_value == 2.0 and right_val._dimension_sig == 1:
             return Quantity(left_value * 2.0, left_val.unit)
-        elif left_value == 2.0:
+        elif left_value == 2.0 and left_val._dimension_sig == 1:
             return Quantity(right_value * 2.0, right_val.unit)
-        elif right_value == 0.5:
+        elif right_value == 0.5 and right_val._dimension_sig == 1:
             return Quantity(left_value * 0.5, left_val.unit)
-        elif left_value == 0.5:
+        elif left_value == 0.5 and left_val._dimension_sig == 1:
             return Quantity(right_value * 0.5, right_val.unit)
 
         # OPTIMIZED REGULAR CASE: Use the enhanced multiplication from base_qnty
@@ -432,7 +437,10 @@ class BinaryOperation(Expression):
 
         # Perform comparison using optimized dispatch
         result = self._perform_comparison(left_val.value, right_val.value)
-        return Quantity(1.0 if result else 0.0, DimensionlessUnits.dimensionless)
+        
+        # Import BooleanQuantity locally to avoid circular imports
+        from ..quantities.base_qnty import BooleanQuantity
+        return BooleanQuantity(result)
 
     def _normalize_comparison_units(self, left_val: "Quantity", right_val: "Quantity") -> tuple["Quantity", "Quantity"]:
         """Normalize units for comparison operations."""
@@ -506,14 +514,14 @@ class UnaryFunction(Expression):
 
         # Function dispatch table for better performance and maintainability
         functions = {
-            "sin": lambda x: Quantity(math.sin(x.value), DimensionlessUnits.dimensionless),
-            "cos": lambda x: Quantity(math.cos(x.value), DimensionlessUnits.dimensionless),
-            "tan": lambda x: Quantity(math.tan(x.value), DimensionlessUnits.dimensionless),
+            "sin": lambda x: math.sin(self._to_radians_if_angle(x)),
+            "cos": lambda x: math.cos(self._to_radians_if_angle(x)),
+            "tan": lambda x: math.tan(self._to_radians_if_angle(x)),
             "sqrt": lambda x: Quantity(math.sqrt(x.value), x.unit),
             "abs": lambda x: Quantity(abs(x.value), x.unit),
-            "ln": lambda x: Quantity(math.log(x.value), DimensionlessUnits.dimensionless),
-            "log10": lambda x: Quantity(math.log10(x.value), DimensionlessUnits.dimensionless),
-            "exp": lambda x: Quantity(math.exp(x.value), DimensionlessUnits.dimensionless),
+            "ln": lambda x: math.log(x.value),
+            "log10": lambda x: math.log10(x.value),
+            "exp": lambda x: math.exp(x.value),
         }
 
         func = functions.get(self.function_name)
@@ -522,6 +530,35 @@ class UnaryFunction(Expression):
         else:
             raise ValueError(f"Unknown function: {self.function_name}")
 
+    def _to_radians_if_angle(self, quantity: "Quantity") -> float:
+        """Convert angle quantities to radians for trigonometric functions."""
+        from ..dimensions import field_dims
+        
+        # Check if this is an angle dimension by comparing dimension signature
+        # Need to handle the case where angle dimensions might not exactly match due to implementation details
+        try:
+            # Import angle plane dimension for comparison
+            angle_plane_dim = field_dims.ANGLE_PLANE
+            
+            # If this looks like an angle (has angle dimension or unit name suggests it)
+            if (hasattr(quantity, '_dimension_sig') and quantity._dimension_sig == angle_plane_dim) or \
+               (hasattr(quantity, 'unit') and hasattr(quantity.unit, 'name') and 
+                any(angle_word in str(quantity.unit.name).lower() for angle_word in ['degree', 'radian', 'grad', 'gon'])):
+                
+                # Import the radian unit for conversion
+                from ..units.field_units import AnglePlaneUnits
+                
+                # Convert to radians and return the numeric value
+                radian_quantity = quantity.to(AnglePlaneUnits.radian.definition)
+                return radian_quantity.value
+            else:
+                # Non-angle quantities: return raw value (backward compatibility)
+                return quantity.value
+        except (ImportError, AttributeError, ValueError):
+            # If anything goes wrong with angle detection/conversion, fall back to raw value
+            return quantity.value
+
+
     def get_variables(self) -> set[str]:
         return self.operand.get_variables()
 
@@ -538,6 +575,15 @@ class UnaryFunction(Expression):
         return UnaryFunction(self.function_name, simplified_operand)
 
     def __str__(self) -> str:
+        # Try auto-evaluation first if possible
+        can_eval, variables = self._can_auto_evaluate()
+        if can_eval and variables:
+            try:
+                result = self.evaluate(variables)
+                return str(result)
+            except (ValueError, TypeError, AttributeError):
+                # Fall back to symbolic representation
+                pass
         return ExpressionFormatter.format_unary_function(self)  # type: ignore[arg-type]
 
 

qnty/problems/composition.py

@@ -186,6 +186,8 @@ class ConfigurableVariable:
                 return self._variable._arithmetic_mode
             # Otherwise default to 'expression'
             return 'expression'
+        
+        
         return getattr(self._variable, name)
 
     # Delegate arithmetic operations to the wrapped variable
@@ -233,10 +235,10 @@ class ConfigurableVariable:
     def __ge__(self, other):
         return self._variable.__ge__(other)
 
-    def __eq__(self, other):
+    def __eq__(self, other):  # type: ignore[override]
         return self._variable.__eq__(other)
 
-    def __ne__(self, other):
+    def __ne__(self, other):  # type: ignore[override]
         return self._variable.__ne__(other)
 
     def __setattr__(self, name, value):
@@ -257,6 +259,30 @@ class ConfigurableVariable:
         else:
             return original_setter
 
+    def update(self, value=None, unit=None, quantity=None, is_known=None):
+        """Override update method to track configuration changes."""
+        result = self._variable.update(value, unit, quantity, is_known)
+        if self._proxy and self._original_symbol:
+            # Track this configuration change
+            self._proxy.track_configuration(self._original_symbol, self._variable.quantity, self._variable.is_known)
+        return result
+
+    def mark_known(self):
+        """Override mark_known to track configuration changes."""
+        result = self._variable.mark_known()
+        if self._proxy and self._original_symbol:
+            # Track this configuration change
+            self._proxy.track_configuration(self._original_symbol, self._variable.quantity, self._variable.is_known)
+        return result
+
+    def mark_unknown(self):
+        """Override mark_unknown to track configuration changes."""
+        result = self._variable.mark_unknown()
+        if self._proxy and self._original_symbol:
+            # Track this configuration change
+            self._proxy.track_configuration(self._original_symbol, self._variable.quantity, self._variable.is_known)
+        return result
+
 
 class TrackingSetterWrapper:
     """
@@ -307,30 +333,6 @@ class TrackingSetterWrapper:
             )
         return result
 
-    def update(self, value=None, unit=None, quantity=None, is_known=None):
-        """Override update method to track configuration changes."""
-        result = self._variable.update(value, unit, quantity, is_known)
-        if self._proxy and self._original_symbol:
-            # Track this configuration change
-            self._proxy.track_configuration(self._original_symbol, self._variable.quantity, self._variable.is_known)
-        return result
-
-    def mark_known(self):
-        """Override mark_known to track configuration changes."""
-        result = self._variable.mark_known()
-        if self._proxy and self._original_symbol:
-            # Track this configuration change
-            self._proxy.track_configuration(self._original_symbol, self._variable.quantity, self._variable.is_known)
-        return result
-
-    def mark_unknown(self):
-        """Override mark_unknown to track configuration changes."""
-        result = self._variable.mark_unknown()
-        if self._proxy and self._original_symbol:
-            # Track this configuration change
-            self._proxy.track_configuration(self._original_symbol, self._variable.quantity, self._variable.is_known)
-        return result
-
 
 class DelayedVariableReference(ArithmeticOperationsMixin):
     """

qnty/problems/problem.py

@@ -372,6 +372,10 @@ class Problem(ValidationMixin):
         cloned.quantity = variable.quantity  # Keep reference to same quantity - units must not be copied
         cloned.is_known = variable.is_known
 
+        # Copy unit preference if it exists
+        if hasattr(variable, '_preferred_unit'):
+            cloned._preferred_unit = variable._preferred_unit
+
         # Ensure the cloned variable has fresh validation checks
         if hasattr(variable, "validation_checks") and hasattr(cloned, "validation_checks"):
             cloned.validation_checks = []

qnty/quantities/base_qnty.py

@@ -673,5 +673,43 @@ class Quantity:
         return UnitConversions.to(self, target_unit)
 
 
+class BooleanQuantity(Quantity):
+    """A quantity that represents a boolean value but maintains Quantity compatibility.
+    
+    This class is used for comparison operations that need to return boolean results
+    while maintaining the Expression interface requirement of returning Quantity objects.
+    """
+    
+    __slots__ = ("_boolean_value",)
+    
+    def __init__(self, boolean_value: bool):
+        """Initialize with a boolean value."""
+        # Store the actual boolean value
+        self._boolean_value = boolean_value
+        
+        # Initialize parent with numeric representation
+        super().__init__(
+            1.0 if boolean_value else 0.0,
+            DimensionlessUnits.dimensionless
+        )
+    
+    def __str__(self) -> str:
+        """Display as True/False instead of 1.0/0.0."""
+        return str(self._boolean_value)
+    
+    def __repr__(self) -> str:
+        """Display as BooleanQuantity(True/False)."""
+        return f"BooleanQuantity({self._boolean_value})"
+    
+    def __bool__(self) -> bool:
+        """Return the actual boolean value."""
+        return self._boolean_value
+    
+    @property
+    def boolean_value(self) -> bool:
+        """Access the boolean value directly."""
+        return self._boolean_value
+
+
 # Initialize cache manager at module load
 _cache_manager.initialize_common_operations()

qnty/quantities/field_converters.py

@@ -13,8 +13,8 @@ from typing import TYPE_CHECKING, Final
 if TYPE_CHECKING:
     from ..quantities.field_qnty import FieldQnty
 
-from ..units import field_units
 from .base_qnty import Quantity
+from ..units import field_units
 
 # ===== BASE CONVERTER CLASSES =====
 
@@ -33,7 +33,10 @@ class UnitConverter:
             units_class = getattr(field_units, units_class_name, None)
             if units_class and hasattr(units_class, unit_name):
                 return getattr(units_class, unit_name)
-        raise ValueError(f'Unknown unit: {unit_name} for {self.variable.__class__.__name__}')
+        # Raise error with suggestions
+        from ..utils.unit_suggestions import create_unit_validation_error
+        var_type = getattr(self.variable, '__class__', type(self.variable)).__name__
+        raise create_unit_validation_error(unit_name, var_type)
 
     def _convert_quantity(self, unit_constant, modify_original: bool = False):
         """Convert quantity to specified unit."""

qnty/quantities/field_qnty.py

@@ -43,6 +43,7 @@ class QuantityManagementMixin:
         self._is_known: bool = False
         self._name: str = ""
         self._symbol: str | None = None
+        self._preferred_unit: str | None = None
 
     @property
     def quantity(self) -> Quantity | None:
@@ -90,6 +91,15 @@ class QuantityManagementMixin:
 
         return self
 
+    def _set_preferred_unit(self, unit: str) -> None:
+        """Set the preferred unit for solver results."""
+        self._preferred_unit = unit
+
+    @property
+    def preferred_unit(self) -> str | None:
+        """Get the preferred unit for this variable."""
+        return self._preferred_unit
+
 
 class FlexibleConstructorMixin:
     """Handles flexible variable initialization patterns maintaining backward compatibility."""
@@ -180,10 +190,9 @@ class FlexibleConstructorMixin:
                 return result
 
         # Fallback to direct quantity creation
-        from ..units import DimensionlessUnits
         from .base_qnty import Quantity
 
-        # Try to find the unit in the registry or use dimensionless fallback
+        # Try to find the unit in the registry
         try:
             from ..units.registry import registry
 
@@ -194,8 +203,10 @@ class FlexibleConstructorMixin:
         except Exception:
             pass
 
-        # Final fallback to dimensionless
-        return Quantity(value, DimensionlessUnits.dimensionless)
+        # If unit is not found, raise error with suggestions instead of falling back to dimensionless
+        from ..utils.unit_suggestions import create_unit_validation_error
+        var_type = getattr(self, '__class__', type(self)).__name__
+        raise create_unit_validation_error(str(unit), var_type)
 
     def _find_unit_property(self, setter: TypeSafeSetter, unit: str) -> str | None:
         """Find unit property with simple lookup."""
@@ -609,6 +620,12 @@ class ExpressionMixin:
 
     def __gt__(self, other) -> Expression:
         return self.gt(other)
+    
+    def __eq__(self, other) -> Expression:  # type: ignore[override]
+        return self.eq(other)
+    
+    def __ne__(self, other) -> Expression:  # type: ignore[override]
+        return self.ne(other)
 
     def eq(self, other) -> Expression:
         """Create equality comparison expression."""
@@ -827,7 +844,10 @@ class UnitConverter:
         except Exception:
             pass
         
-        raise ValueError(f"Unknown unit: {unit_str}")
+        # Raise error with suggestions
+        from ..utils.unit_suggestions import create_unit_validation_error
+        var_type = getattr(self.variable, '__class__', type(self.variable)).__name__
+        raise create_unit_validation_error(unit_str, var_type)
     
     def _convert_quantity(self, to_unit_constant, modify_original: bool = True):
         """Convert the variable's quantity to the specified unit."""