qnty 0.1.3__py3-none-any.whl → 0.1.4__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/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."""

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."""