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

qnty/{generated/quantities.py → quantities/field_vars.py}

@@ -4,17 +4,18 @@ Quantity Classes Module - Static Edition
 
 Static quantity class definitions for maximum import performance.
 Uses static class generation instead of dynamic type() calls.
-Auto-generated from unit_data.json.
+Auto-generated by codegen/generators/field_vars.py
+DO NOT EDIT MANUALLY - changes will be overwritten.
 """
 
-from ..quantities.typed_quantity import TypedQuantity
-from . import dimensions as dim
-from . import setters as ts
+from ..dimensions import field_dims as dim
+from . import field_setter as ts
+from .field_qnty import FieldQnty
 
 # ===== QUANTITY CLASSES =====
 # Static quantity class definitions with __slots__ optimization
 
-class AbsorbedDose(TypedQuantity):
+class AbsorbedDose(FieldQnty):
     """
     Type-safe absorbed radiation dose quantity with expression capabilities.
     
@@ -30,10 +31,11 @@ class AbsorbedDose(TypedQuantity):
     
     Available units: "erg_per_gram", "gram_rad", "gray"
     """
+
     __slots__ = ()
     _setter_class = ts.AbsorbedDoseSetter
-    _expected_dimension = dim.ABSORBED_DOSE
-    
+    _dimension = dim.ABSORBED_DOSE
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize absorbed radiation dose quantity.
@@ -52,13 +54,15 @@ class AbsorbedDose(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.AbsorbedDoseSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.AbsorbedDoseSetter:
         """
         Create a setter for this absorbed radiation dose quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             AbsorbedDoseSetter: A setter with unit properties like .meters, .inches, etc.
@@ -70,7 +74,7 @@ class AbsorbedDose(TypedQuantity):
         return ts.AbsorbedDoseSetter(self, value)
     
 
-class Acceleration(TypedQuantity):
+class Acceleration(FieldQnty):
     """
     Type-safe acceleration quantity with expression capabilities.
     
@@ -86,10 +90,11 @@ class Acceleration(TypedQuantity):
     
     Available units: "meter_per_second_squared", "foot_per_second_squared"
     """
+
     __slots__ = ()
     _setter_class = ts.AccelerationSetter
-    _expected_dimension = dim.ACCELERATION
-    
+    _dimension = dim.ACCELERATION
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize acceleration quantity.
@@ -108,13 +113,15 @@ class Acceleration(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.AccelerationSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.AccelerationSetter:
         """
         Create a setter for this acceleration quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             AccelerationSetter: A setter with unit properties like .meters, .inches, etc.
@@ -126,7 +133,7 @@ class Acceleration(TypedQuantity):
         return ts.AccelerationSetter(self, value)
     
 
-class ActivationEnergy(TypedQuantity):
+class ActivationEnergy(FieldQnty):
     """
     Type-safe activation energy quantity with expression capabilities.
     
@@ -142,10 +149,11 @@ class ActivationEnergy(TypedQuantity):
     
     Available units: "btu_per_pound_mole", "calorie_mean_per_gram_mole", "joule_per_gram_mole"
     """
+
     __slots__ = ()
     _setter_class = ts.ActivationEnergySetter
-    _expected_dimension = dim.ACTIVATION_ENERGY
-    
+    _dimension = dim.ACTIVATION_ENERGY
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize activation energy quantity.
@@ -164,13 +172,15 @@ class ActivationEnergy(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.ActivationEnergySetter:
+    def set(self, value: float, unit: str | None = None) -> ts.ActivationEnergySetter:
         """
         Create a setter for this activation energy quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             ActivationEnergySetter: A setter with unit properties like .meters, .inches, etc.
@@ -182,7 +192,7 @@ class ActivationEnergy(TypedQuantity):
         return ts.ActivationEnergySetter(self, value)
     
 
-class AmountOfSubstance(TypedQuantity):
+class AmountOfSubstance(FieldQnty):
     """
     Type-safe amount of substance quantity with expression capabilities.
     
@@ -198,10 +208,11 @@ class AmountOfSubstance(TypedQuantity):
     
     Available units: "kilogram_mol", "mole", "pound_mole"
     """
+
     __slots__ = ()
     _setter_class = ts.AmountOfSubstanceSetter
-    _expected_dimension = dim.AMOUNT_OF_SUBSTANCE
-    
+    _dimension = dim.AMOUNT_OF_SUBSTANCE
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize amount of substance quantity.
@@ -220,13 +231,15 @@ class AmountOfSubstance(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.AmountOfSubstanceSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.AmountOfSubstanceSetter:
         """
         Create a setter for this amount of substance quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             AmountOfSubstanceSetter: A setter with unit properties like .meters, .inches, etc.
@@ -238,7 +251,7 @@ class AmountOfSubstance(TypedQuantity):
         return ts.AmountOfSubstanceSetter(self, value)
     
 
-class AnglePlane(TypedQuantity):
+class AnglePlane(FieldQnty):
     """
     Type-safe angle, plane quantity with expression capabilities.
     
@@ -254,10 +267,11 @@ class AnglePlane(TypedQuantity):
     
     Available units: "degree", "gon", "grade"
     """
+
     __slots__ = ()
     _setter_class = ts.AnglePlaneSetter
-    _expected_dimension = dim.ANGLE_PLANE
-    
+    _dimension = dim.ANGLE_PLANE
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize angle, plane quantity.
@@ -276,13 +290,15 @@ class AnglePlane(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.AnglePlaneSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.AnglePlaneSetter:
         """
         Create a setter for this angle, plane quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             AnglePlaneSetter: A setter with unit properties like .meters, .inches, etc.
@@ -294,7 +310,7 @@ class AnglePlane(TypedQuantity):
         return ts.AnglePlaneSetter(self, value)
     
 
-class AngleSolid(TypedQuantity):
+class AngleSolid(FieldQnty):
     """
     Type-safe angle, solid quantity with expression capabilities.
     
@@ -310,10 +326,11 @@ class AngleSolid(TypedQuantity):
     
     Available units: "spat", "square_degree", "square_gon"
     """
+
     __slots__ = ()
     _setter_class = ts.AngleSolidSetter
-    _expected_dimension = dim.ANGLE_SOLID
-    
+    _dimension = dim.ANGLE_SOLID
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize angle, solid quantity.
@@ -332,13 +349,15 @@ class AngleSolid(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.AngleSolidSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.AngleSolidSetter:
         """
         Create a setter for this angle, solid quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             AngleSolidSetter: A setter with unit properties like .meters, .inches, etc.
@@ -350,7 +369,7 @@ class AngleSolid(TypedQuantity):
         return ts.AngleSolidSetter(self, value)
     
 
-class AngularAcceleration(TypedQuantity):
+class AngularAcceleration(FieldQnty):
     """
     Type-safe angular acceleration quantity with expression capabilities.
     
@@ -366,10 +385,11 @@ class AngularAcceleration(TypedQuantity):
     
     Available units: "radian_per_second_squared", "revolution_per_second_squared", "rpm_or_revolution_per_minute"
     """
+
     __slots__ = ()
     _setter_class = ts.AngularAccelerationSetter
-    _expected_dimension = dim.ANGULAR_ACCELERATION
-    
+    _dimension = dim.ANGULAR_ACCELERATION
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize angular acceleration quantity.
@@ -388,13 +408,15 @@ class AngularAcceleration(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.AngularAccelerationSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.AngularAccelerationSetter:
         """
         Create a setter for this angular acceleration quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             AngularAccelerationSetter: A setter with unit properties like .meters, .inches, etc.
@@ -406,7 +428,7 @@ class AngularAcceleration(TypedQuantity):
         return ts.AngularAccelerationSetter(self, value)
     
 
-class AngularMomentum(TypedQuantity):
+class AngularMomentum(FieldQnty):
     """
     Type-safe angular momentum quantity with expression capabilities.
     
@@ -422,10 +444,11 @@ class AngularMomentum(TypedQuantity):
     
     Available units: "gram_centimeter_squared_per_second", "kilogram_meter_squared_per_second", "pound_force_square_foot_per_second"
     """
+
     __slots__ = ()
     _setter_class = ts.AngularMomentumSetter
-    _expected_dimension = dim.ANGULAR_MOMENTUM
-    
+    _dimension = dim.ANGULAR_MOMENTUM
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize angular momentum quantity.
@@ -444,13 +467,15 @@ class AngularMomentum(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.AngularMomentumSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.AngularMomentumSetter:
         """
         Create a setter for this angular momentum quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             AngularMomentumSetter: A setter with unit properties like .meters, .inches, etc.
@@ -462,7 +487,7 @@ class AngularMomentum(TypedQuantity):
         return ts.AngularMomentumSetter(self, value)
     
 
-class Area(TypedQuantity):
+class Area(FieldQnty):
     """
     Type-safe area quantity with expression capabilities.
     
@@ -478,10 +503,11 @@ class Area(TypedQuantity):
     
     Available units: "acre_general", "are", "arpent_quebec"
     """
+
     __slots__ = ()
     _setter_class = ts.AreaSetter
-    _expected_dimension = dim.AREA
-    
+    _dimension = dim.AREA
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize area quantity.
@@ -500,13 +526,15 @@ class Area(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.AreaSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.AreaSetter:
         """
         Create a setter for this area quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             AreaSetter: A setter with unit properties like .meters, .inches, etc.
@@ -518,7 +546,7 @@ class Area(TypedQuantity):
         return ts.AreaSetter(self, value)
     
 
-class AreaPerUnitVolume(TypedQuantity):
+class AreaPerUnitVolume(FieldQnty):
     """
     Type-safe area per unit volume quantity with expression capabilities.
     
@@ -534,10 +562,11 @@ class AreaPerUnitVolume(TypedQuantity):
     
     Available units: "square_centimeter_per_cubic_centimeter", "square_foot_per_cubic_foot", "square_inch_per_cubic_inch"
     """
+
     __slots__ = ()
     _setter_class = ts.AreaPerUnitVolumeSetter
-    _expected_dimension = dim.AREA_PER_UNIT_VOLUME
-    
+    _dimension = dim.AREA_PER_UNIT_VOLUME
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize area per unit volume quantity.
@@ -556,13 +585,15 @@ class AreaPerUnitVolume(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.AreaPerUnitVolumeSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.AreaPerUnitVolumeSetter:
         """
         Create a setter for this area per unit volume quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             AreaPerUnitVolumeSetter: A setter with unit properties like .meters, .inches, etc.
@@ -574,7 +605,7 @@ class AreaPerUnitVolume(TypedQuantity):
         return ts.AreaPerUnitVolumeSetter(self, value)
     
 
-class AtomicWeight(TypedQuantity):
+class AtomicWeight(FieldQnty):
     """
     Type-safe atomic weight quantity with expression capabilities.
     
@@ -590,10 +621,11 @@ class AtomicWeight(TypedQuantity):
     
     Available units: "atomic_mass_unit_12c", "grams_per_mole", "kilograms_per_kilomole"
     """
+
     __slots__ = ()
     _setter_class = ts.AtomicWeightSetter
-    _expected_dimension = dim.ATOMIC_WEIGHT
-    
+    _dimension = dim.ATOMIC_WEIGHT
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize atomic weight quantity.
@@ -612,13 +644,15 @@ class AtomicWeight(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.AtomicWeightSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.AtomicWeightSetter:
         """
         Create a setter for this atomic weight quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             AtomicWeightSetter: A setter with unit properties like .meters, .inches, etc.
@@ -630,7 +664,7 @@ class AtomicWeight(TypedQuantity):
         return ts.AtomicWeightSetter(self, value)
     
 
-class Concentration(TypedQuantity):
+class Concentration(FieldQnty):
     """
     Type-safe concentration quantity with expression capabilities.
     
@@ -646,10 +680,11 @@ class Concentration(TypedQuantity):
     
     Available units: "grains_of_i_per_cubic_foot", "grains_of_i_per_gallon_us"
     """
+
     __slots__ = ()
     _setter_class = ts.ConcentrationSetter
-    _expected_dimension = dim.CONCENTRATION
-    
+    _dimension = dim.CONCENTRATION
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize concentration quantity.
@@ -668,13 +703,15 @@ class Concentration(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.ConcentrationSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.ConcentrationSetter:
         """
         Create a setter for this concentration quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             ConcentrationSetter: A setter with unit properties like .meters, .inches, etc.
@@ -686,7 +723,7 @@ class Concentration(TypedQuantity):
         return ts.ConcentrationSetter(self, value)
     
 
-class Dimensionless(TypedQuantity):
+class Dimensionless(FieldQnty):
     """
     Type-safe dimensionless quantity with expression capabilities.
     
@@ -700,10 +737,11 @@ class Dimensionless(TypedQuantity):
     >>> unknown = Dimensionless("efficiency")  # Unknown dimensionless
     >>> known = Dimensionless(0.85, "thermal_efficiency")  # Known dimensionless
     """
+
     __slots__ = ()
     _setter_class = ts.DimensionlessSetter
-    _expected_dimension = dim.DIMENSIONLESS
-    
+    _dimension = dim.DIMENSIONLESS
+
     def __init__(self, name_or_value: str | int | float, name: str | None = None, is_known: bool = True):
         """
         Initialize dimensionless quantity.
@@ -719,25 +757,45 @@ class Dimensionless(TypedQuantity):
         else:
             # Two arguments: value and name (known variable)
             super().__init__(name_or_value, name, is_known=is_known)
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.DimensionlessSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.DimensionlessSetter:
         """
         Create a setter for this dimensionless quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for direct setting)
         
         Returns:
-            DimensionlessSetter: A setter with unit properties like .meters, .inches, etc.
+            DimensionlessSetter: A setter with unit properties like .dimensionless
         
         Example:
-            >>> length = Length("beam_length")
-            >>> length.set(100).millimeters  # Sets to 100 mm
-        """
-        return ts.DimensionlessSetter(self, value)
+            >>> factor = Dimensionless("factor")
+            >>> factor.set(2.5).dimensionless  # Sets to 2.5
+            >>> factor.set(2.5, "dimensionless")  # Direct setting
+        """
+        if unit is not None:
+            # Direct setting with unit
+            setter = ts.DimensionlessSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                # Try common aliases
+                unit_aliases = {
+                    "dimensionless": "dimensionless", "": "dimensionless"
+                }
+                if unit in unit_aliases and hasattr(setter, unit_aliases[unit]):
+                    getattr(setter, unit_aliases[unit])
+                else:
+                    raise ValueError(f"Unknown unit: {unit}")
+            return self  # Return the variable itself for consistency
+        else:
+            return ts.DimensionlessSetter(self, value)
     
 
-class DynamicFluidity(TypedQuantity):
+class DynamicFluidity(FieldQnty):
     """
     Type-safe dynamic fluidity quantity with expression capabilities.
     
@@ -753,10 +811,11 @@ class DynamicFluidity(TypedQuantity):
     
     Available units: "meter_seconds_per_kilogram", "rhe", "square_foot_per_pound_second"
     """
+
     __slots__ = ()
     _setter_class = ts.DynamicFluiditySetter
-    _expected_dimension = dim.DYNAMIC_FLUIDITY
-    
+    _dimension = dim.DYNAMIC_FLUIDITY
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize dynamic fluidity quantity.
@@ -775,13 +834,15 @@ class DynamicFluidity(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.DynamicFluiditySetter:
+    def set(self, value: float, unit: str | None = None) -> ts.DynamicFluiditySetter:
         """
         Create a setter for this dynamic fluidity quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             DynamicFluiditySetter: A setter with unit properties like .meters, .inches, etc.
@@ -793,7 +854,7 @@ class DynamicFluidity(TypedQuantity):
         return ts.DynamicFluiditySetter(self, value)
     
 
-class ElectricCapacitance(TypedQuantity):
+class ElectricCapacitance(FieldQnty):
     """
     Type-safe electric capacitance quantity with expression capabilities.
     
@@ -809,10 +870,11 @@ class ElectricCapacitance(TypedQuantity):
     
     Available units: "cm", "abfarad", "farad"
     """
+
     __slots__ = ()
     _setter_class = ts.ElectricCapacitanceSetter
-    _expected_dimension = dim.ELECTRIC_CAPACITANCE
-    
+    _dimension = dim.ELECTRIC_CAPACITANCE
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize electric capacitance quantity.
@@ -831,13 +893,15 @@ class ElectricCapacitance(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.ElectricCapacitanceSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.ElectricCapacitanceSetter:
         """
         Create a setter for this electric capacitance quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             ElectricCapacitanceSetter: A setter with unit properties like .meters, .inches, etc.
@@ -849,7 +913,7 @@ class ElectricCapacitance(TypedQuantity):
         return ts.ElectricCapacitanceSetter(self, value)
     
 
-class ElectricCharge(TypedQuantity):
+class ElectricCharge(FieldQnty):
     """
     Type-safe electric charge quantity with expression capabilities.
     
@@ -865,10 +929,11 @@ class ElectricCharge(TypedQuantity):
     
     Available units: "abcoulomb", "ampere_hour", "coulomb"
     """
+
     __slots__ = ()
     _setter_class = ts.ElectricChargeSetter
-    _expected_dimension = dim.ELECTRIC_CHARGE
-    
+    _dimension = dim.ELECTRIC_CHARGE
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize electric charge quantity.
@@ -887,13 +952,15 @@ class ElectricCharge(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.ElectricChargeSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.ElectricChargeSetter:
         """
         Create a setter for this electric charge quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             ElectricChargeSetter: A setter with unit properties like .meters, .inches, etc.
@@ -905,7 +972,7 @@ class ElectricCharge(TypedQuantity):
         return ts.ElectricChargeSetter(self, value)
     
 
-class ElectricCurrentIntensity(TypedQuantity):
+class ElectricCurrentIntensity(FieldQnty):
     """
     Type-safe electric current intensity quantity with expression capabilities.
     
@@ -921,10 +988,11 @@ class ElectricCurrentIntensity(TypedQuantity):
     
     Available units: "abampere", "ampere_intl_mean", "ampere_intl_us"
     """
+
     __slots__ = ()
     _setter_class = ts.ElectricCurrentIntensitySetter
-    _expected_dimension = dim.ELECTRIC_CURRENT_INTENSITY
-    
+    _dimension = dim.ELECTRIC_CURRENT_INTENSITY
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize electric current intensity quantity.
@@ -943,13 +1011,15 @@ class ElectricCurrentIntensity(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.ElectricCurrentIntensitySetter:
+    def set(self, value: float, unit: str | None = None) -> ts.ElectricCurrentIntensitySetter:
         """
         Create a setter for this electric current intensity quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             ElectricCurrentIntensitySetter: A setter with unit properties like .meters, .inches, etc.
@@ -961,7 +1031,7 @@ class ElectricCurrentIntensity(TypedQuantity):
         return ts.ElectricCurrentIntensitySetter(self, value)
     
 
-class ElectricDipoleMoment(TypedQuantity):
+class ElectricDipoleMoment(FieldQnty):
     """
     Type-safe electric dipole moment quantity with expression capabilities.
     
@@ -977,10 +1047,11 @@ class ElectricDipoleMoment(TypedQuantity):
     
     Available units: "ampere_meter_second", "coulomb_meter", "debye"
     """
+
     __slots__ = ()
     _setter_class = ts.ElectricDipoleMomentSetter
-    _expected_dimension = dim.ELECTRIC_DIPOLE_MOMENT
-    
+    _dimension = dim.ELECTRIC_DIPOLE_MOMENT
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize electric dipole moment quantity.
@@ -999,13 +1070,15 @@ class ElectricDipoleMoment(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.ElectricDipoleMomentSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.ElectricDipoleMomentSetter:
         """
         Create a setter for this electric dipole moment quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             ElectricDipoleMomentSetter: A setter with unit properties like .meters, .inches, etc.
@@ -1017,7 +1090,7 @@ class ElectricDipoleMoment(TypedQuantity):
         return ts.ElectricDipoleMomentSetter(self, value)
     
 
-class ElectricFieldStrength(TypedQuantity):
+class ElectricFieldStrength(FieldQnty):
     """
     Type-safe electric field strength quantity with expression capabilities.
     
@@ -1033,10 +1106,11 @@ class ElectricFieldStrength(TypedQuantity):
     
     Available units: "volt_per_centimeter", "volt_per_meter"
     """
+
     __slots__ = ()
     _setter_class = ts.ElectricFieldStrengthSetter
-    _expected_dimension = dim.ELECTRIC_FIELD_STRENGTH
-    
+    _dimension = dim.ELECTRIC_FIELD_STRENGTH
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize electric field strength quantity.
@@ -1055,13 +1129,15 @@ class ElectricFieldStrength(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.ElectricFieldStrengthSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.ElectricFieldStrengthSetter:
         """
         Create a setter for this electric field strength quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             ElectricFieldStrengthSetter: A setter with unit properties like .meters, .inches, etc.
@@ -1073,7 +1149,7 @@ class ElectricFieldStrength(TypedQuantity):
         return ts.ElectricFieldStrengthSetter(self, value)
     
 
-class ElectricInductance(TypedQuantity):
+class ElectricInductance(FieldQnty):
     """
     Type-safe electric inductance quantity with expression capabilities.
     
@@ -1089,10 +1165,11 @@ class ElectricInductance(TypedQuantity):
     
     Available units: "abhenry", "cm", "henry"
     """
+
     __slots__ = ()
     _setter_class = ts.ElectricInductanceSetter
-    _expected_dimension = dim.ELECTRIC_INDUCTANCE
-    
+    _dimension = dim.ELECTRIC_INDUCTANCE
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize electric inductance quantity.
@@ -1111,13 +1188,15 @@ class ElectricInductance(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.ElectricInductanceSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.ElectricInductanceSetter:
         """
         Create a setter for this electric inductance quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             ElectricInductanceSetter: A setter with unit properties like .meters, .inches, etc.
@@ -1129,7 +1208,7 @@ class ElectricInductance(TypedQuantity):
         return ts.ElectricInductanceSetter(self, value)
     
 
-class ElectricPotential(TypedQuantity):
+class ElectricPotential(FieldQnty):
     """
     Type-safe electric potential quantity with expression capabilities.
     
@@ -1145,10 +1224,11 @@ class ElectricPotential(TypedQuantity):
     
     Available units: "abvolt", "statvolt", "u_a_potential"
     """
+
     __slots__ = ()
     _setter_class = ts.ElectricPotentialSetter
-    _expected_dimension = dim.ELECTRIC_POTENTIAL
-    
+    _dimension = dim.ELECTRIC_POTENTIAL
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize electric potential quantity.
@@ -1167,13 +1247,15 @@ class ElectricPotential(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.ElectricPotentialSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.ElectricPotentialSetter:
         """
         Create a setter for this electric potential quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             ElectricPotentialSetter: A setter with unit properties like .meters, .inches, etc.
@@ -1185,7 +1267,7 @@ class ElectricPotential(TypedQuantity):
         return ts.ElectricPotentialSetter(self, value)
     
 
-class ElectricResistance(TypedQuantity):
+class ElectricResistance(FieldQnty):
     """
     Type-safe electric resistance quantity with expression capabilities.
     
@@ -1201,10 +1283,11 @@ class ElectricResistance(TypedQuantity):
     
     Available units: "abohm", "jacobi", "lenz"
     """
+
     __slots__ = ()
     _setter_class = ts.ElectricResistanceSetter
-    _expected_dimension = dim.ELECTRIC_RESISTANCE
-    
+    _dimension = dim.ELECTRIC_RESISTANCE
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize electric resistance quantity.
@@ -1223,13 +1306,15 @@ class ElectricResistance(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.ElectricResistanceSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.ElectricResistanceSetter:
         """
         Create a setter for this electric resistance quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             ElectricResistanceSetter: A setter with unit properties like .meters, .inches, etc.
@@ -1241,7 +1326,7 @@ class ElectricResistance(TypedQuantity):
         return ts.ElectricResistanceSetter(self, value)
     
 
-class ElectricalConductance(TypedQuantity):
+class ElectricalConductance(FieldQnty):
     """
     Type-safe electrical conductance quantity with expression capabilities.
     
@@ -1257,10 +1342,11 @@ class ElectricalConductance(TypedQuantity):
     
     Available units: "emu_cgs", "esu_cgs", "mho"
     """
+
     __slots__ = ()
     _setter_class = ts.ElectricalConductanceSetter
-    _expected_dimension = dim.ELECTRICAL_CONDUCTANCE
-    
+    _dimension = dim.ELECTRICAL_CONDUCTANCE
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize electrical conductance quantity.
@@ -1279,13 +1365,15 @@ class ElectricalConductance(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.ElectricalConductanceSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.ElectricalConductanceSetter:
         """
         Create a setter for this electrical conductance quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             ElectricalConductanceSetter: A setter with unit properties like .meters, .inches, etc.
@@ -1297,7 +1385,7 @@ class ElectricalConductance(TypedQuantity):
         return ts.ElectricalConductanceSetter(self, value)
     
 
-class ElectricalPermittivity(TypedQuantity):
+class ElectricalPermittivity(FieldQnty):
     """
     Type-safe electrical permittivity quantity with expression capabilities.
     
@@ -1313,10 +1401,11 @@ class ElectricalPermittivity(TypedQuantity):
     
     Available units: "farad_per_meter"
     """
+
     __slots__ = ()
     _setter_class = ts.ElectricalPermittivitySetter
-    _expected_dimension = dim.ELECTRICAL_PERMITTIVITY
-    
+    _dimension = dim.ELECTRICAL_PERMITTIVITY
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize electrical permittivity quantity.
@@ -1335,13 +1424,15 @@ class ElectricalPermittivity(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.ElectricalPermittivitySetter:
+    def set(self, value: float, unit: str | None = None) -> ts.ElectricalPermittivitySetter:
         """
         Create a setter for this electrical permittivity quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             ElectricalPermittivitySetter: A setter with unit properties like .meters, .inches, etc.
@@ -1353,7 +1444,7 @@ class ElectricalPermittivity(TypedQuantity):
         return ts.ElectricalPermittivitySetter(self, value)
     
 
-class ElectricalResistivity(TypedQuantity):
+class ElectricalResistivity(FieldQnty):
     """
     Type-safe electrical resistivity quantity with expression capabilities.
     
@@ -1369,10 +1460,11 @@ class ElectricalResistivity(TypedQuantity):
     
     Available units: "circular_mil_ohm_per_foot", "emu_cgs", "microhm_inch"
     """
+
     __slots__ = ()
     _setter_class = ts.ElectricalResistivitySetter
-    _expected_dimension = dim.ELECTRICAL_RESISTIVITY
-    
+    _dimension = dim.ELECTRICAL_RESISTIVITY
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize electrical resistivity quantity.
@@ -1391,13 +1483,15 @@ class ElectricalResistivity(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.ElectricalResistivitySetter:
+    def set(self, value: float, unit: str | None = None) -> ts.ElectricalResistivitySetter:
         """
         Create a setter for this electrical resistivity quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             ElectricalResistivitySetter: A setter with unit properties like .meters, .inches, etc.
@@ -1409,7 +1503,7 @@ class ElectricalResistivity(TypedQuantity):
         return ts.ElectricalResistivitySetter(self, value)
     
 
-class EnergyFlux(TypedQuantity):
+class EnergyFlux(FieldQnty):
     """
     Type-safe energy flux quantity with expression capabilities.
     
@@ -1425,10 +1519,11 @@ class EnergyFlux(TypedQuantity):
     
     Available units: "btu_per_square_foot_per_hour", "calorie_per_square_centimeter_per_second", "celsius_heat_units_chu"
     """
+
     __slots__ = ()
     _setter_class = ts.EnergyFluxSetter
-    _expected_dimension = dim.ENERGY_FLUX
-    
+    _dimension = dim.ENERGY_FLUX
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize energy flux quantity.
@@ -1447,13 +1542,15 @@ class EnergyFlux(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.EnergyFluxSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.EnergyFluxSetter:
         """
         Create a setter for this energy flux quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             EnergyFluxSetter: A setter with unit properties like .meters, .inches, etc.
@@ -1465,7 +1562,7 @@ class EnergyFlux(TypedQuantity):
         return ts.EnergyFluxSetter(self, value)
     
 
-class EnergyHeatWork(TypedQuantity):
+class EnergyHeatWork(FieldQnty):
     """
     Type-safe energy, heat, work quantity with expression capabilities.
     
@@ -1481,10 +1578,11 @@ class EnergyHeatWork(TypedQuantity):
     
     Available units: "barrel_oil_equivalent_or_equivalent_barrel", "billion_electronvolt", "british_thermal_unit_4circ_mathrmc"
     """
+
     __slots__ = ()
     _setter_class = ts.EnergyHeatWorkSetter
-    _expected_dimension = dim.ENERGY_HEAT_WORK
-    
+    _dimension = dim.ENERGY_HEAT_WORK
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize energy, heat, work quantity.
@@ -1503,13 +1601,15 @@ class EnergyHeatWork(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.EnergyHeatWorkSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.EnergyHeatWorkSetter:
         """
         Create a setter for this energy, heat, work quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             EnergyHeatWorkSetter: A setter with unit properties like .meters, .inches, etc.
@@ -1521,7 +1621,7 @@ class EnergyHeatWork(TypedQuantity):
         return ts.EnergyHeatWorkSetter(self, value)
     
 
-class EnergyPerUnitArea(TypedQuantity):
+class EnergyPerUnitArea(FieldQnty):
     """
     Type-safe energy per unit area quantity with expression capabilities.
     
@@ -1537,10 +1637,11 @@ class EnergyPerUnitArea(TypedQuantity):
     
     Available units: "british_thermal_unit_per_square_foot", "joule_per_square_meter", "langley"
     """
+
     __slots__ = ()
     _setter_class = ts.EnergyPerUnitAreaSetter
-    _expected_dimension = dim.ENERGY_PER_UNIT_AREA
-    
+    _dimension = dim.ENERGY_PER_UNIT_AREA
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize energy per unit area quantity.
@@ -1559,13 +1660,15 @@ class EnergyPerUnitArea(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.EnergyPerUnitAreaSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.EnergyPerUnitAreaSetter:
         """
         Create a setter for this energy per unit area quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             EnergyPerUnitAreaSetter: A setter with unit properties like .meters, .inches, etc.
@@ -1577,7 +1680,7 @@ class EnergyPerUnitArea(TypedQuantity):
         return ts.EnergyPerUnitAreaSetter(self, value)
     
 
-class Force(TypedQuantity):
+class Force(FieldQnty):
     """
     Type-safe force quantity with expression capabilities.
     
@@ -1593,10 +1696,11 @@ class Force(TypedQuantity):
     
     Available units: "crinal", "dyne", "funal"
     """
+
     __slots__ = ()
     _setter_class = ts.ForceSetter
-    _expected_dimension = dim.FORCE
-    
+    _dimension = dim.FORCE
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize force quantity.
@@ -1615,13 +1719,15 @@ class Force(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.ForceSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.ForceSetter:
         """
         Create a setter for this force quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             ForceSetter: A setter with unit properties like .meters, .inches, etc.
@@ -1633,7 +1739,7 @@ class Force(TypedQuantity):
         return ts.ForceSetter(self, value)
     
 
-class ForceBody(TypedQuantity):
+class ForceBody(FieldQnty):
     """
     Type-safe force (body) quantity with expression capabilities.
     
@@ -1649,10 +1755,11 @@ class ForceBody(TypedQuantity):
     
     Available units: "dyne_per_cubic_centimeter", "kilogram_force_per_cubic_centimeter", "kilogram_force_per_cubic_meter"
     """
+
     __slots__ = ()
     _setter_class = ts.ForceBodySetter
-    _expected_dimension = dim.FORCE_BODY
-    
+    _dimension = dim.FORCE_BODY
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize force (body) quantity.
@@ -1671,13 +1778,15 @@ class ForceBody(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.ForceBodySetter:
+    def set(self, value: float, unit: str | None = None) -> ts.ForceBodySetter:
         """
         Create a setter for this force (body) quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             ForceBodySetter: A setter with unit properties like .meters, .inches, etc.
@@ -1689,7 +1798,7 @@ class ForceBody(TypedQuantity):
         return ts.ForceBodySetter(self, value)
     
 
-class ForcePerUnitMass(TypedQuantity):
+class ForcePerUnitMass(FieldQnty):
     """
     Type-safe force per unit mass quantity with expression capabilities.
     
@@ -1705,10 +1814,11 @@ class ForcePerUnitMass(TypedQuantity):
     
     Available units: "dyne_per_gram", "kilogram_force_per_kilogram", "newton_per_kilogram"
     """
+
     __slots__ = ()
     _setter_class = ts.ForcePerUnitMassSetter
-    _expected_dimension = dim.FORCE_PER_UNIT_MASS
-    
+    _dimension = dim.FORCE_PER_UNIT_MASS
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize force per unit mass quantity.
@@ -1727,13 +1837,15 @@ class ForcePerUnitMass(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.ForcePerUnitMassSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.ForcePerUnitMassSetter:
         """
         Create a setter for this force per unit mass quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             ForcePerUnitMassSetter: A setter with unit properties like .meters, .inches, etc.
@@ -1745,7 +1857,7 @@ class ForcePerUnitMass(TypedQuantity):
         return ts.ForcePerUnitMassSetter(self, value)
     
 
-class FrequencyVoltageRatio(TypedQuantity):
+class FrequencyVoltageRatio(FieldQnty):
     """
     Type-safe frequency voltage ratio quantity with expression capabilities.
     
@@ -1761,10 +1873,11 @@ class FrequencyVoltageRatio(TypedQuantity):
     
     Available units: "cycles_per_second_per_volt", "hertz_per_volt", "terahertz_per_volt"
     """
+
     __slots__ = ()
     _setter_class = ts.FrequencyVoltageRatioSetter
-    _expected_dimension = dim.FREQUENCY_VOLTAGE_RATIO
-    
+    _dimension = dim.FREQUENCY_VOLTAGE_RATIO
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize frequency voltage ratio quantity.
@@ -1783,13 +1896,15 @@ class FrequencyVoltageRatio(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.FrequencyVoltageRatioSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.FrequencyVoltageRatioSetter:
         """
         Create a setter for this frequency voltage ratio quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             FrequencyVoltageRatioSetter: A setter with unit properties like .meters, .inches, etc.
@@ -1801,7 +1916,7 @@ class FrequencyVoltageRatio(TypedQuantity):
         return ts.FrequencyVoltageRatioSetter(self, value)
     
 
-class FuelConsumption(TypedQuantity):
+class FuelConsumption(FieldQnty):
     """
     Type-safe fuel consumption quantity with expression capabilities.
     
@@ -1817,10 +1932,11 @@ class FuelConsumption(TypedQuantity):
     
     Available units: "unit_100_km_per_liter", "gallons_uk", "gallons_us"
     """
+
     __slots__ = ()
     _setter_class = ts.FuelConsumptionSetter
-    _expected_dimension = dim.FUEL_CONSUMPTION
-    
+    _dimension = dim.FUEL_CONSUMPTION
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize fuel consumption quantity.
@@ -1839,13 +1955,15 @@ class FuelConsumption(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.FuelConsumptionSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.FuelConsumptionSetter:
         """
         Create a setter for this fuel consumption quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             FuelConsumptionSetter: A setter with unit properties like .meters, .inches, etc.
@@ -1857,7 +1975,7 @@ class FuelConsumption(TypedQuantity):
         return ts.FuelConsumptionSetter(self, value)
     
 
-class HeatOfCombustion(TypedQuantity):
+class HeatOfCombustion(FieldQnty):
     """
     Type-safe heat of combustion quantity with expression capabilities.
     
@@ -1873,10 +1991,11 @@ class HeatOfCombustion(TypedQuantity):
     
     Available units: "british_thermal_unit_per_pound", "calorie_per_gram", "chu_per_pound"
     """
+
     __slots__ = ()
     _setter_class = ts.HeatOfCombustionSetter
-    _expected_dimension = dim.HEAT_OF_COMBUSTION
-    
+    _dimension = dim.HEAT_OF_COMBUSTION
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize heat of combustion quantity.
@@ -1895,13 +2014,15 @@ class HeatOfCombustion(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.HeatOfCombustionSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.HeatOfCombustionSetter:
         """
         Create a setter for this heat of combustion quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             HeatOfCombustionSetter: A setter with unit properties like .meters, .inches, etc.
@@ -1913,7 +2034,7 @@ class HeatOfCombustion(TypedQuantity):
         return ts.HeatOfCombustionSetter(self, value)
     
 
-class HeatOfFusion(TypedQuantity):
+class HeatOfFusion(FieldQnty):
     """
     Type-safe heat of fusion quantity with expression capabilities.
     
@@ -1929,10 +2050,11 @@ class HeatOfFusion(TypedQuantity):
     
     Available units: "british_thermal_unit_mean", "british_thermal_unit_per_pound", "calorie_per_gram"
     """
+
     __slots__ = ()
     _setter_class = ts.HeatOfFusionSetter
-    _expected_dimension = dim.HEAT_OF_FUSION
-    
+    _dimension = dim.HEAT_OF_FUSION
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize heat of fusion quantity.
@@ -1951,13 +2073,15 @@ class HeatOfFusion(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.HeatOfFusionSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.HeatOfFusionSetter:
         """
         Create a setter for this heat of fusion quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             HeatOfFusionSetter: A setter with unit properties like .meters, .inches, etc.
@@ -1969,7 +2093,7 @@ class HeatOfFusion(TypedQuantity):
         return ts.HeatOfFusionSetter(self, value)
     
 
-class HeatOfVaporization(TypedQuantity):
+class HeatOfVaporization(FieldQnty):
     """
     Type-safe heat of vaporization quantity with expression capabilities.
     
@@ -1985,10 +2109,11 @@ class HeatOfVaporization(TypedQuantity):
     
     Available units: "british_thermal_unit_per_pound", "calorie_per_gram", "chu_per_pound"
     """
+
     __slots__ = ()
     _setter_class = ts.HeatOfVaporizationSetter
-    _expected_dimension = dim.HEAT_OF_VAPORIZATION
-    
+    _dimension = dim.HEAT_OF_VAPORIZATION
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize heat of vaporization quantity.
@@ -2007,13 +2132,15 @@ class HeatOfVaporization(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.HeatOfVaporizationSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.HeatOfVaporizationSetter:
         """
         Create a setter for this heat of vaporization quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             HeatOfVaporizationSetter: A setter with unit properties like .meters, .inches, etc.
@@ -2025,7 +2152,7 @@ class HeatOfVaporization(TypedQuantity):
         return ts.HeatOfVaporizationSetter(self, value)
     
 
-class HeatTransferCoefficient(TypedQuantity):
+class HeatTransferCoefficient(FieldQnty):
     """
     Type-safe heat transfer coefficient quantity with expression capabilities.
     
@@ -2041,10 +2168,11 @@ class HeatTransferCoefficient(TypedQuantity):
     
     Available units: "btu_per_square_foot_per_hour_per_degree_fahrenheit_or_rankine", "watt_per_square_meter_per_degree_celsius_or_kelvin"
     """
+
     __slots__ = ()
     _setter_class = ts.HeatTransferCoefficientSetter
-    _expected_dimension = dim.HEAT_TRANSFER_COEFFICIENT
-    
+    _dimension = dim.HEAT_TRANSFER_COEFFICIENT
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize heat transfer coefficient quantity.
@@ -2063,13 +2191,15 @@ class HeatTransferCoefficient(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.HeatTransferCoefficientSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.HeatTransferCoefficientSetter:
         """
         Create a setter for this heat transfer coefficient quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             HeatTransferCoefficientSetter: A setter with unit properties like .meters, .inches, etc.
@@ -2081,7 +2211,7 @@ class HeatTransferCoefficient(TypedQuantity):
         return ts.HeatTransferCoefficientSetter(self, value)
     
 
-class Illuminance(TypedQuantity):
+class Illuminance(FieldQnty):
     """
     Type-safe illuminance quantity with expression capabilities.
     
@@ -2097,10 +2227,11 @@ class Illuminance(TypedQuantity):
     
     Available units: "foot_candle", "lux", "nox"
     """
+
     __slots__ = ()
     _setter_class = ts.IlluminanceSetter
-    _expected_dimension = dim.ILLUMINANCE
-    
+    _dimension = dim.ILLUMINANCE
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize illuminance quantity.
@@ -2119,13 +2250,15 @@ class Illuminance(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.IlluminanceSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.IlluminanceSetter:
         """
         Create a setter for this illuminance quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             IlluminanceSetter: A setter with unit properties like .meters, .inches, etc.
@@ -2137,7 +2270,7 @@ class Illuminance(TypedQuantity):
         return ts.IlluminanceSetter(self, value)
     
 
-class KineticEnergyOfTurbulence(TypedQuantity):
+class KineticEnergyOfTurbulence(FieldQnty):
     """
     Type-safe kinetic energy of turbulence quantity with expression capabilities.
     
@@ -2153,10 +2286,11 @@ class KineticEnergyOfTurbulence(TypedQuantity):
     
     Available units: "square_foot_per_second_squared", "square_meters_per_second_squared"
     """
+
     __slots__ = ()
     _setter_class = ts.KineticEnergyOfTurbulenceSetter
-    _expected_dimension = dim.KINETIC_ENERGY_OF_TURBULENCE
-    
+    _dimension = dim.KINETIC_ENERGY_OF_TURBULENCE
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize kinetic energy of turbulence quantity.
@@ -2175,13 +2309,15 @@ class KineticEnergyOfTurbulence(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.KineticEnergyOfTurbulenceSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.KineticEnergyOfTurbulenceSetter:
         """
         Create a setter for this kinetic energy of turbulence quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             KineticEnergyOfTurbulenceSetter: A setter with unit properties like .meters, .inches, etc.
@@ -2193,7 +2329,7 @@ class KineticEnergyOfTurbulence(TypedQuantity):
         return ts.KineticEnergyOfTurbulenceSetter(self, value)
     
 
-class Length(TypedQuantity):
+class Length(FieldQnty):
     """
     Type-safe length quantity with expression capabilities.
     
@@ -2209,10 +2345,11 @@ class Length(TypedQuantity):
     
     Available units: "ngstr_m", "arpent_quebec", "astronomic_unit"
     """
+
     __slots__ = ()
     _setter_class = ts.LengthSetter
-    _expected_dimension = dim.LENGTH
-    
+    _dimension = dim.LENGTH
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize length quantity.
@@ -2231,13 +2368,15 @@ class Length(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.LengthSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.LengthSetter:
         """
         Create a setter for this length quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for direct setting)
         
         Returns:
             LengthSetter: A setter with unit properties like .meters, .inches, etc.
@@ -2245,11 +2384,33 @@ class Length(TypedQuantity):
         Example:
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
-        """
-        return ts.LengthSetter(self, value)
+            >>> length.set(100, "inch")  # Direct setting
+        """
+        if unit is not None:
+            # Direct setting with unit
+            setter = ts.LengthSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                # Try common aliases
+                unit_aliases = {
+                    "inch": "inch", "inches": "inch", "in": "inch",
+                    "foot": "foot", "feet": "foot", "ft": "foot", 
+                    "meter": "meter", "meters": "meter", "m": "meter",
+                    "millimeter": "millimeter", "millimeters": "millimeter", "mm": "millimeter",
+                    "centimeter": "centimeter", "centimeters": "centimeter", "cm": "centimeter"
+                }
+                if unit in unit_aliases and hasattr(setter, unit_aliases[unit]):
+                    getattr(setter, unit_aliases[unit])
+                else:
+                    raise ValueError(f"Unknown unit: {unit}")
+            return self  # Return the variable itself for consistency
+        else:
+            return ts.LengthSetter(self, value)
     
 
-class LinearMassDensity(TypedQuantity):
+class LinearMassDensity(FieldQnty):
     """
     Type-safe linear mass density quantity with expression capabilities.
     
@@ -2265,10 +2426,11 @@ class LinearMassDensity(TypedQuantity):
     
     Available units: "denier", "kilogram_per_centimeter", "kilogram_per_meter"
     """
+
     __slots__ = ()
     _setter_class = ts.LinearMassDensitySetter
-    _expected_dimension = dim.LINEAR_MASS_DENSITY
-    
+    _dimension = dim.LINEAR_MASS_DENSITY
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize linear mass density quantity.
@@ -2287,13 +2449,15 @@ class LinearMassDensity(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.LinearMassDensitySetter:
+    def set(self, value: float, unit: str | None = None) -> ts.LinearMassDensitySetter:
         """
         Create a setter for this linear mass density quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             LinearMassDensitySetter: A setter with unit properties like .meters, .inches, etc.
@@ -2305,7 +2469,7 @@ class LinearMassDensity(TypedQuantity):
         return ts.LinearMassDensitySetter(self, value)
     
 
-class LinearMomentum(TypedQuantity):
+class LinearMomentum(FieldQnty):
     """
     Type-safe linear momentum quantity with expression capabilities.
     
@@ -2321,10 +2485,11 @@ class LinearMomentum(TypedQuantity):
     
     Available units: "foot_pounds_force_per_hour", "foot_pounds_force_per_minute", "foot_pounds_force_per_second"
     """
+
     __slots__ = ()
     _setter_class = ts.LinearMomentumSetter
-    _expected_dimension = dim.LINEAR_MOMENTUM
-    
+    _dimension = dim.LINEAR_MOMENTUM
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize linear momentum quantity.
@@ -2343,13 +2508,15 @@ class LinearMomentum(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.LinearMomentumSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.LinearMomentumSetter:
         """
         Create a setter for this linear momentum quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             LinearMomentumSetter: A setter with unit properties like .meters, .inches, etc.
@@ -2361,7 +2528,7 @@ class LinearMomentum(TypedQuantity):
         return ts.LinearMomentumSetter(self, value)
     
 
-class LuminanceSelf(TypedQuantity):
+class LuminanceSelf(FieldQnty):
     """
     Type-safe luminance (self) quantity with expression capabilities.
     
@@ -2377,10 +2544,11 @@ class LuminanceSelf(TypedQuantity):
     
     Available units: "apostilb", "blondel", "candela_per_square_meter"
     """
+
     __slots__ = ()
     _setter_class = ts.LuminanceSelfSetter
-    _expected_dimension = dim.LUMINANCE_SELF
-    
+    _dimension = dim.LUMINANCE_SELF
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize luminance (self) quantity.
@@ -2399,13 +2567,15 @@ class LuminanceSelf(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.LuminanceSelfSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.LuminanceSelfSetter:
         """
         Create a setter for this luminance (self) quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             LuminanceSelfSetter: A setter with unit properties like .meters, .inches, etc.
@@ -2417,7 +2587,7 @@ class LuminanceSelf(TypedQuantity):
         return ts.LuminanceSelfSetter(self, value)
     
 
-class LuminousFlux(TypedQuantity):
+class LuminousFlux(FieldQnty):
     """
     Type-safe luminous flux quantity with expression capabilities.
     
@@ -2433,10 +2603,11 @@ class LuminousFlux(TypedQuantity):
     
     Available units: "candela_steradian", "lumen"
     """
+
     __slots__ = ()
     _setter_class = ts.LuminousFluxSetter
-    _expected_dimension = dim.LUMINOUS_FLUX
-    
+    _dimension = dim.LUMINOUS_FLUX
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize luminous flux quantity.
@@ -2455,13 +2626,15 @@ class LuminousFlux(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.LuminousFluxSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.LuminousFluxSetter:
         """
         Create a setter for this luminous flux quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             LuminousFluxSetter: A setter with unit properties like .meters, .inches, etc.
@@ -2473,7 +2646,7 @@ class LuminousFlux(TypedQuantity):
         return ts.LuminousFluxSetter(self, value)
     
 
-class LuminousIntensity(TypedQuantity):
+class LuminousIntensity(FieldQnty):
     """
     Type-safe luminous intensity quantity with expression capabilities.
     
@@ -2489,10 +2662,11 @@ class LuminousIntensity(TypedQuantity):
     
     Available units: "candela", "candle_international", "carcel"
     """
+
     __slots__ = ()
     _setter_class = ts.LuminousIntensitySetter
-    _expected_dimension = dim.LUMINOUS_INTENSITY
-    
+    _dimension = dim.LUMINOUS_INTENSITY
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize luminous intensity quantity.
@@ -2511,13 +2685,15 @@ class LuminousIntensity(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.LuminousIntensitySetter:
+    def set(self, value: float, unit: str | None = None) -> ts.LuminousIntensitySetter:
         """
         Create a setter for this luminous intensity quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             LuminousIntensitySetter: A setter with unit properties like .meters, .inches, etc.
@@ -2529,7 +2705,7 @@ class LuminousIntensity(TypedQuantity):
         return ts.LuminousIntensitySetter(self, value)
     
 
-class MagneticField(TypedQuantity):
+class MagneticField(FieldQnty):
     """
     Type-safe magnetic field quantity with expression capabilities.
     
@@ -2545,10 +2721,11 @@ class MagneticField(TypedQuantity):
     
     Available units: "ampere_per_meter", "lenz", "oersted"
     """
+
     __slots__ = ()
     _setter_class = ts.MagneticFieldSetter
-    _expected_dimension = dim.MAGNETIC_FIELD
-    
+    _dimension = dim.MAGNETIC_FIELD
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize magnetic field quantity.
@@ -2567,13 +2744,15 @@ class MagneticField(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.MagneticFieldSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.MagneticFieldSetter:
         """
         Create a setter for this magnetic field quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             MagneticFieldSetter: A setter with unit properties like .meters, .inches, etc.
@@ -2585,7 +2764,7 @@ class MagneticField(TypedQuantity):
         return ts.MagneticFieldSetter(self, value)
     
 
-class MagneticFlux(TypedQuantity):
+class MagneticFlux(FieldQnty):
     """
     Type-safe magnetic flux quantity with expression capabilities.
     
@@ -2601,10 +2780,11 @@ class MagneticFlux(TypedQuantity):
     
     Available units: "kapp_line", "line", "maxwell"
     """
+
     __slots__ = ()
     _setter_class = ts.MagneticFluxSetter
-    _expected_dimension = dim.MAGNETIC_FLUX
-    
+    _dimension = dim.MAGNETIC_FLUX
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize magnetic flux quantity.
@@ -2623,13 +2803,15 @@ class MagneticFlux(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.MagneticFluxSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.MagneticFluxSetter:
         """
         Create a setter for this magnetic flux quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             MagneticFluxSetter: A setter with unit properties like .meters, .inches, etc.
@@ -2641,7 +2823,7 @@ class MagneticFlux(TypedQuantity):
         return ts.MagneticFluxSetter(self, value)
     
 
-class MagneticInductionFieldStrength(TypedQuantity):
+class MagneticInductionFieldStrength(FieldQnty):
     """
     Type-safe magnetic induction field strength quantity with expression capabilities.
     
@@ -2657,10 +2839,11 @@ class MagneticInductionFieldStrength(TypedQuantity):
     
     Available units: "gamma", "gauss", "line_per_square_centimeter"
     """
+
     __slots__ = ()
     _setter_class = ts.MagneticInductionFieldStrengthSetter
-    _expected_dimension = dim.MAGNETIC_INDUCTION_FIELD_STRENGTH
-    
+    _dimension = dim.MAGNETIC_INDUCTION_FIELD_STRENGTH
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize magnetic induction field strength quantity.
@@ -2679,13 +2862,15 @@ class MagneticInductionFieldStrength(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.MagneticInductionFieldStrengthSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.MagneticInductionFieldStrengthSetter:
         """
         Create a setter for this magnetic induction field strength quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             MagneticInductionFieldStrengthSetter: A setter with unit properties like .meters, .inches, etc.
@@ -2697,7 +2882,7 @@ class MagneticInductionFieldStrength(TypedQuantity):
         return ts.MagneticInductionFieldStrengthSetter(self, value)
     
 
-class MagneticMoment(TypedQuantity):
+class MagneticMoment(FieldQnty):
     """
     Type-safe magnetic moment quantity with expression capabilities.
     
@@ -2713,10 +2898,11 @@ class MagneticMoment(TypedQuantity):
     
     Available units: "bohr_magneton", "joule_per_tesla", "nuclear_magneton"
     """
+
     __slots__ = ()
     _setter_class = ts.MagneticMomentSetter
-    _expected_dimension = dim.MAGNETIC_MOMENT
-    
+    _dimension = dim.MAGNETIC_MOMENT
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize magnetic moment quantity.
@@ -2735,13 +2921,15 @@ class MagneticMoment(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.MagneticMomentSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.MagneticMomentSetter:
         """
         Create a setter for this magnetic moment quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             MagneticMomentSetter: A setter with unit properties like .meters, .inches, etc.
@@ -2753,7 +2941,7 @@ class MagneticMoment(TypedQuantity):
         return ts.MagneticMomentSetter(self, value)
     
 
-class MagneticPermeability(TypedQuantity):
+class MagneticPermeability(FieldQnty):
     """
     Type-safe magnetic permeability quantity with expression capabilities.
     
@@ -2769,10 +2957,11 @@ class MagneticPermeability(TypedQuantity):
     
     Available units: "henrys_per_meter", "newton_per_square_ampere"
     """
+
     __slots__ = ()
     _setter_class = ts.MagneticPermeabilitySetter
-    _expected_dimension = dim.MAGNETIC_PERMEABILITY
-    
+    _dimension = dim.MAGNETIC_PERMEABILITY
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize magnetic permeability quantity.
@@ -2791,13 +2980,15 @@ class MagneticPermeability(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.MagneticPermeabilitySetter:
+    def set(self, value: float, unit: str | None = None) -> ts.MagneticPermeabilitySetter:
         """
         Create a setter for this magnetic permeability quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             MagneticPermeabilitySetter: A setter with unit properties like .meters, .inches, etc.
@@ -2809,7 +3000,7 @@ class MagneticPermeability(TypedQuantity):
         return ts.MagneticPermeabilitySetter(self, value)
     
 
-class MagnetomotiveForce(TypedQuantity):
+class MagnetomotiveForce(FieldQnty):
     """
     Type-safe magnetomotive force quantity with expression capabilities.
     
@@ -2825,10 +3016,11 @@ class MagnetomotiveForce(TypedQuantity):
     
     Available units: "abampere_turn", "ampere", "ampere_turn"
     """
+
     __slots__ = ()
     _setter_class = ts.MagnetomotiveForceSetter
-    _expected_dimension = dim.MAGNETOMOTIVE_FORCE
-    
+    _dimension = dim.MAGNETOMOTIVE_FORCE
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize magnetomotive force quantity.
@@ -2847,13 +3039,15 @@ class MagnetomotiveForce(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.MagnetomotiveForceSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.MagnetomotiveForceSetter:
         """
         Create a setter for this magnetomotive force quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             MagnetomotiveForceSetter: A setter with unit properties like .meters, .inches, etc.
@@ -2865,7 +3059,7 @@ class MagnetomotiveForce(TypedQuantity):
         return ts.MagnetomotiveForceSetter(self, value)
     
 
-class Mass(TypedQuantity):
+class Mass(FieldQnty):
     """
     Type-safe mass quantity with expression capabilities.
     
@@ -2881,10 +3075,11 @@ class Mass(TypedQuantity):
     
     Available units: "slug", "atomic_mass_unit_12_mathrmc", "carat_metric"
     """
+
     __slots__ = ()
     _setter_class = ts.MassSetter
-    _expected_dimension = dim.MASS
-    
+    _dimension = dim.MASS
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize mass quantity.
@@ -2903,13 +3098,15 @@ class Mass(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.MassSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.MassSetter:
         """
         Create a setter for this mass quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             MassSetter: A setter with unit properties like .meters, .inches, etc.
@@ -2921,7 +3118,7 @@ class Mass(TypedQuantity):
         return ts.MassSetter(self, value)
     
 
-class MassDensity(TypedQuantity):
+class MassDensity(FieldQnty):
     """
     Type-safe mass density quantity with expression capabilities.
     
@@ -2937,10 +3134,11 @@ class MassDensity(TypedQuantity):
     
     Available units: "gram_per_cubic_centimeter", "gram_per_cubic_decimeter", "gram_per_cubic_meter"
     """
+
     __slots__ = ()
     _setter_class = ts.MassDensitySetter
-    _expected_dimension = dim.MASS_DENSITY
-    
+    _dimension = dim.MASS_DENSITY
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize mass density quantity.
@@ -2959,13 +3157,15 @@ class MassDensity(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.MassDensitySetter:
+    def set(self, value: float, unit: str | None = None) -> ts.MassDensitySetter:
         """
         Create a setter for this mass density quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             MassDensitySetter: A setter with unit properties like .meters, .inches, etc.
@@ -2977,7 +3177,7 @@ class MassDensity(TypedQuantity):
         return ts.MassDensitySetter(self, value)
     
 
-class MassFlowRate(TypedQuantity):
+class MassFlowRate(FieldQnty):
     """
     Type-safe mass flow rate quantity with expression capabilities.
     
@@ -2993,10 +3193,11 @@ class MassFlowRate(TypedQuantity):
     
     Available units: "kilograms_per_day", "kilograms_per_hour", "kilograms_per_minute"
     """
+
     __slots__ = ()
     _setter_class = ts.MassFlowRateSetter
-    _expected_dimension = dim.MASS_FLOW_RATE
-    
+    _dimension = dim.MASS_FLOW_RATE
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize mass flow rate quantity.
@@ -3015,13 +3216,15 @@ class MassFlowRate(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.MassFlowRateSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.MassFlowRateSetter:
         """
         Create a setter for this mass flow rate quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             MassFlowRateSetter: A setter with unit properties like .meters, .inches, etc.
@@ -3033,7 +3236,7 @@ class MassFlowRate(TypedQuantity):
         return ts.MassFlowRateSetter(self, value)
     
 
-class MassFlux(TypedQuantity):
+class MassFlux(FieldQnty):
     """
     Type-safe mass flux quantity with expression capabilities.
     
@@ -3049,10 +3252,11 @@ class MassFlux(TypedQuantity):
     
     Available units: "kilogram_per_square_meter_per_day", "kilogram_per_square_meter_per_hour", "kilogram_per_square_meter_per_minute"
     """
+
     __slots__ = ()
     _setter_class = ts.MassFluxSetter
-    _expected_dimension = dim.MASS_FLUX
-    
+    _dimension = dim.MASS_FLUX
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize mass flux quantity.
@@ -3071,13 +3275,15 @@ class MassFlux(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.MassFluxSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.MassFluxSetter:
         """
         Create a setter for this mass flux quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             MassFluxSetter: A setter with unit properties like .meters, .inches, etc.
@@ -3089,7 +3295,7 @@ class MassFlux(TypedQuantity):
         return ts.MassFluxSetter(self, value)
     
 
-class MassFractionOfI(TypedQuantity):
+class MassFractionOfI(FieldQnty):
     """
     Type-safe mass fraction of "i" quantity with expression capabilities.
     
@@ -3105,10 +3311,11 @@ class MassFractionOfI(TypedQuantity):
     
     Available units: "grains_of_i_per_pound_total", "gram_of_i_per_kilogram_total", "kilogram_of_i_per_kilogram_total"
     """
+
     __slots__ = ()
     _setter_class = ts.MassFractionOfISetter
-    _expected_dimension = dim.MASS_FRACTION_OF_I
-    
+    _dimension = dim.MASS_FRACTION_OF_I
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize mass fraction of "i" quantity.
@@ -3127,13 +3334,15 @@ class MassFractionOfI(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.MassFractionOfISetter:
+    def set(self, value: float, unit: str | None = None) -> ts.MassFractionOfISetter:
         """
         Create a setter for this mass fraction of "i" quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             MassFractionOfISetter: A setter with unit properties like .meters, .inches, etc.
@@ -3145,7 +3354,7 @@ class MassFractionOfI(TypedQuantity):
         return ts.MassFractionOfISetter(self, value)
     
 
-class MassTransferCoefficient(TypedQuantity):
+class MassTransferCoefficient(FieldQnty):
     """
     Type-safe mass transfer coefficient quantity with expression capabilities.
     
@@ -3161,10 +3370,11 @@ class MassTransferCoefficient(TypedQuantity):
     
     Available units: "gram_per_square_centimeter_per_second", "kilogram_per_square_meter_per_second", "pounds_force_per_cubic_foot_per_hour"
     """
+
     __slots__ = ()
     _setter_class = ts.MassTransferCoefficientSetter
-    _expected_dimension = dim.MASS_TRANSFER_COEFFICIENT
-    
+    _dimension = dim.MASS_TRANSFER_COEFFICIENT
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize mass transfer coefficient quantity.
@@ -3183,13 +3393,15 @@ class MassTransferCoefficient(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.MassTransferCoefficientSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.MassTransferCoefficientSetter:
         """
         Create a setter for this mass transfer coefficient quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             MassTransferCoefficientSetter: A setter with unit properties like .meters, .inches, etc.
@@ -3201,7 +3413,7 @@ class MassTransferCoefficient(TypedQuantity):
         return ts.MassTransferCoefficientSetter(self, value)
     
 
-class MolalityOfSoluteI(TypedQuantity):
+class MolalityOfSoluteI(FieldQnty):
     """
     Type-safe molality of solute "i" quantity with expression capabilities.
     
@@ -3217,10 +3429,11 @@ class MolalityOfSoluteI(TypedQuantity):
     
     Available units: "gram_moles_of_i_per_kilogram", "kilogram_mols_of_i_per_kilogram", "kmols_of_i_per_kilogram"
     """
+
     __slots__ = ()
     _setter_class = ts.MolalityOfSoluteISetter
-    _expected_dimension = dim.MOLALITY_OF_SOLUTE_I
-    
+    _dimension = dim.MOLALITY_OF_SOLUTE_I
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize molality of solute "i" quantity.
@@ -3239,13 +3452,15 @@ class MolalityOfSoluteI(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.MolalityOfSoluteISetter:
+    def set(self, value: float, unit: str | None = None) -> ts.MolalityOfSoluteISetter:
         """
         Create a setter for this molality of solute "i" quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             MolalityOfSoluteISetter: A setter with unit properties like .meters, .inches, etc.
@@ -3257,7 +3472,7 @@ class MolalityOfSoluteI(TypedQuantity):
         return ts.MolalityOfSoluteISetter(self, value)
     
 
-class MolarConcentrationByMass(TypedQuantity):
+class MolarConcentrationByMass(FieldQnty):
     """
     Type-safe molar concentration by mass quantity with expression capabilities.
     
@@ -3273,10 +3488,11 @@ class MolarConcentrationByMass(TypedQuantity):
     
     Available units: "gram_mole_or_mole_per_gram", "gram_mole_or_mole_per_kilogram", "kilogram_mole_or_kmol_per_kilogram"
     """
+
     __slots__ = ()
     _setter_class = ts.MolarConcentrationByMassSetter
-    _expected_dimension = dim.MOLAR_CONCENTRATION_BY_MASS
-    
+    _dimension = dim.MOLAR_CONCENTRATION_BY_MASS
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize molar concentration by mass quantity.
@@ -3295,13 +3511,15 @@ class MolarConcentrationByMass(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.MolarConcentrationByMassSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.MolarConcentrationByMassSetter:
         """
         Create a setter for this molar concentration by mass quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             MolarConcentrationByMassSetter: A setter with unit properties like .meters, .inches, etc.
@@ -3313,7 +3531,7 @@ class MolarConcentrationByMass(TypedQuantity):
         return ts.MolarConcentrationByMassSetter(self, value)
     
 
-class MolarFlowRate(TypedQuantity):
+class MolarFlowRate(FieldQnty):
     """
     Type-safe molar flow rate quantity with expression capabilities.
     
@@ -3329,10 +3547,11 @@ class MolarFlowRate(TypedQuantity):
     
     Available units: "gram_mole_per_day", "gram_mole_per_hour", "gram_mole_per_minute"
     """
+
     __slots__ = ()
     _setter_class = ts.MolarFlowRateSetter
-    _expected_dimension = dim.MOLAR_FLOW_RATE
-    
+    _dimension = dim.MOLAR_FLOW_RATE
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize molar flow rate quantity.
@@ -3351,13 +3570,15 @@ class MolarFlowRate(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.MolarFlowRateSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.MolarFlowRateSetter:
         """
         Create a setter for this molar flow rate quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             MolarFlowRateSetter: A setter with unit properties like .meters, .inches, etc.
@@ -3369,7 +3590,7 @@ class MolarFlowRate(TypedQuantity):
         return ts.MolarFlowRateSetter(self, value)
     
 
-class MolarFlux(TypedQuantity):
+class MolarFlux(FieldQnty):
     """
     Type-safe molar flux quantity with expression capabilities.
     
@@ -3385,10 +3606,11 @@ class MolarFlux(TypedQuantity):
     
     Available units: "kmol_per_square_meter_per_day", "kmol_per_square_meter_per_hour", "kmol_per_square_meter_per_minute"
     """
+
     __slots__ = ()
     _setter_class = ts.MolarFluxSetter
-    _expected_dimension = dim.MOLAR_FLUX
-    
+    _dimension = dim.MOLAR_FLUX
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize molar flux quantity.
@@ -3407,13 +3629,15 @@ class MolarFlux(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.MolarFluxSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.MolarFluxSetter:
         """
         Create a setter for this molar flux quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             MolarFluxSetter: A setter with unit properties like .meters, .inches, etc.
@@ -3425,7 +3649,7 @@ class MolarFlux(TypedQuantity):
         return ts.MolarFluxSetter(self, value)
     
 
-class MolarHeatCapacity(TypedQuantity):
+class MolarHeatCapacity(FieldQnty):
     """
     Type-safe molar heat capacity quantity with expression capabilities.
     
@@ -3441,10 +3665,11 @@ class MolarHeatCapacity(TypedQuantity):
     
     Available units: "btu_per_pound_mole_per_degree_fahrenheit_or_degree_rankine", "calories_per_gram_mole_per_kelvin_or_degree_celsius", "joule_per_gram_mole_per_kelvin_or_degree_celsius"
     """
+
     __slots__ = ()
     _setter_class = ts.MolarHeatCapacitySetter
-    _expected_dimension = dim.MOLAR_HEAT_CAPACITY
-    
+    _dimension = dim.MOLAR_HEAT_CAPACITY
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize molar heat capacity quantity.
@@ -3463,13 +3688,15 @@ class MolarHeatCapacity(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.MolarHeatCapacitySetter:
+    def set(self, value: float, unit: str | None = None) -> ts.MolarHeatCapacitySetter:
         """
         Create a setter for this molar heat capacity quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             MolarHeatCapacitySetter: A setter with unit properties like .meters, .inches, etc.
@@ -3481,7 +3708,7 @@ class MolarHeatCapacity(TypedQuantity):
         return ts.MolarHeatCapacitySetter(self, value)
     
 
-class MolarityOfI(TypedQuantity):
+class MolarityOfI(FieldQnty):
     """
     Type-safe molarity of "i" quantity with expression capabilities.
     
@@ -3497,10 +3724,11 @@ class MolarityOfI(TypedQuantity):
     
     Available units: "gram_moles_of_i_per_cubic_meter", "gram_moles_of_i_per_liter", "kilogram_moles_of_i_per_cubic_meter"
     """
+
     __slots__ = ()
     _setter_class = ts.MolarityOfISetter
-    _expected_dimension = dim.MOLARITY_OF_I
-    
+    _dimension = dim.MOLARITY_OF_I
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize molarity of "i" quantity.
@@ -3519,13 +3747,15 @@ class MolarityOfI(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.MolarityOfISetter:
+    def set(self, value: float, unit: str | None = None) -> ts.MolarityOfISetter:
         """
         Create a setter for this molarity of "i" quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             MolarityOfISetter: A setter with unit properties like .meters, .inches, etc.
@@ -3537,7 +3767,7 @@ class MolarityOfI(TypedQuantity):
         return ts.MolarityOfISetter(self, value)
     
 
-class MoleFractionOfI(TypedQuantity):
+class MoleFractionOfI(FieldQnty):
     """
     Type-safe mole fraction of "i" quantity with expression capabilities.
     
@@ -3553,10 +3783,11 @@ class MoleFractionOfI(TypedQuantity):
     
     Available units: "gram_mole_of_i_per_gram_mole_total", "kilogram_mole_of_i_per_kilogram_mole_total", "kilomole_of_i_per_kilomole_total"
     """
+
     __slots__ = ()
     _setter_class = ts.MoleFractionOfISetter
-    _expected_dimension = dim.MOLE_FRACTION_OF_I
-    
+    _dimension = dim.MOLE_FRACTION_OF_I
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize mole fraction of "i" quantity.
@@ -3575,13 +3806,15 @@ class MoleFractionOfI(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.MoleFractionOfISetter:
+    def set(self, value: float, unit: str | None = None) -> ts.MoleFractionOfISetter:
         """
         Create a setter for this mole fraction of "i" quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             MoleFractionOfISetter: A setter with unit properties like .meters, .inches, etc.
@@ -3593,7 +3826,7 @@ class MoleFractionOfI(TypedQuantity):
         return ts.MoleFractionOfISetter(self, value)
     
 
-class MomentOfInertia(TypedQuantity):
+class MomentOfInertia(FieldQnty):
     """
     Type-safe moment of inertia quantity with expression capabilities.
     
@@ -3609,10 +3842,11 @@ class MomentOfInertia(TypedQuantity):
     
     Available units: "gram_force_centimeter_square_second", "gram_square_centimeter", "kilogram_force_centimeter_square_second"
     """
+
     __slots__ = ()
     _setter_class = ts.MomentOfInertiaSetter
-    _expected_dimension = dim.MOMENT_OF_INERTIA
-    
+    _dimension = dim.MOMENT_OF_INERTIA
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize moment of inertia quantity.
@@ -3631,13 +3865,15 @@ class MomentOfInertia(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.MomentOfInertiaSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.MomentOfInertiaSetter:
         """
         Create a setter for this moment of inertia quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             MomentOfInertiaSetter: A setter with unit properties like .meters, .inches, etc.
@@ -3649,7 +3885,7 @@ class MomentOfInertia(TypedQuantity):
         return ts.MomentOfInertiaSetter(self, value)
     
 
-class MomentumFlowRate(TypedQuantity):
+class MomentumFlowRate(FieldQnty):
     """
     Type-safe momentum flow rate quantity with expression capabilities.
     
@@ -3665,10 +3901,11 @@ class MomentumFlowRate(TypedQuantity):
     
     Available units: "foot_pounds_per_square_hour", "foot_pounds_per_square_minute", "foot_pounds_per_square_second"
     """
+
     __slots__ = ()
     _setter_class = ts.MomentumFlowRateSetter
-    _expected_dimension = dim.MOMENTUM_FLOW_RATE
-    
+    _dimension = dim.MOMENTUM_FLOW_RATE
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize momentum flow rate quantity.
@@ -3687,13 +3924,15 @@ class MomentumFlowRate(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.MomentumFlowRateSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.MomentumFlowRateSetter:
         """
         Create a setter for this momentum flow rate quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             MomentumFlowRateSetter: A setter with unit properties like .meters, .inches, etc.
@@ -3705,7 +3944,7 @@ class MomentumFlowRate(TypedQuantity):
         return ts.MomentumFlowRateSetter(self, value)
     
 
-class MomentumFlux(TypedQuantity):
+class MomentumFlux(FieldQnty):
     """
     Type-safe momentum flux quantity with expression capabilities.
     
@@ -3721,10 +3960,11 @@ class MomentumFlux(TypedQuantity):
     
     Available units: "dyne_per_square_centimeter", "gram_per_centimeter_per_square_second", "newton_per_square_meter"
     """
+
     __slots__ = ()
     _setter_class = ts.MomentumFluxSetter
-    _expected_dimension = dim.MOMENTUM_FLUX
-    
+    _dimension = dim.MOMENTUM_FLUX
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize momentum flux quantity.
@@ -3743,13 +3983,15 @@ class MomentumFlux(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.MomentumFluxSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.MomentumFluxSetter:
         """
         Create a setter for this momentum flux quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             MomentumFluxSetter: A setter with unit properties like .meters, .inches, etc.
@@ -3761,7 +4003,7 @@ class MomentumFlux(TypedQuantity):
         return ts.MomentumFluxSetter(self, value)
     
 
-class NormalityOfSolution(TypedQuantity):
+class NormalityOfSolution(FieldQnty):
     """
     Type-safe normality of solution quantity with expression capabilities.
     
@@ -3777,10 +4019,11 @@ class NormalityOfSolution(TypedQuantity):
     
     Available units: "gram_equivalents_per_cubic_meter", "gram_equivalents_per_liter", "pound_equivalents_per_cubic_foot"
     """
+
     __slots__ = ()
     _setter_class = ts.NormalityOfSolutionSetter
-    _expected_dimension = dim.NORMALITY_OF_SOLUTION
-    
+    _dimension = dim.NORMALITY_OF_SOLUTION
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize normality of solution quantity.
@@ -3799,13 +4042,15 @@ class NormalityOfSolution(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.NormalityOfSolutionSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.NormalityOfSolutionSetter:
         """
         Create a setter for this normality of solution quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             NormalityOfSolutionSetter: A setter with unit properties like .meters, .inches, etc.
@@ -3817,7 +4062,7 @@ class NormalityOfSolution(TypedQuantity):
         return ts.NormalityOfSolutionSetter(self, value)
     
 
-class ParticleDensity(TypedQuantity):
+class ParticleDensity(FieldQnty):
     """
     Type-safe particle density quantity with expression capabilities.
     
@@ -3833,10 +4078,11 @@ class ParticleDensity(TypedQuantity):
     
     Available units: "particles_per_cubic_centimeter", "particles_per_cubic_foot", "particles_per_cubic_meter"
     """
+
     __slots__ = ()
     _setter_class = ts.ParticleDensitySetter
-    _expected_dimension = dim.PARTICLE_DENSITY
-    
+    _dimension = dim.PARTICLE_DENSITY
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize particle density quantity.
@@ -3855,13 +4101,15 @@ class ParticleDensity(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.ParticleDensitySetter:
+    def set(self, value: float, unit: str | None = None) -> ts.ParticleDensitySetter:
         """
         Create a setter for this particle density quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             ParticleDensitySetter: A setter with unit properties like .meters, .inches, etc.
@@ -3873,7 +4121,7 @@ class ParticleDensity(TypedQuantity):
         return ts.ParticleDensitySetter(self, value)
     
 
-class Percent(TypedQuantity):
+class Percent(FieldQnty):
     """
     Type-safe percent quantity with expression capabilities.
     
@@ -3889,10 +4137,11 @@ class Percent(TypedQuantity):
     
     Available units: "percent", "per_mille", "basis_point"
     """
+
     __slots__ = ()
     _setter_class = ts.PercentSetter
-    _expected_dimension = dim.PERCENT
-    
+    _dimension = dim.PERCENT
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize percent quantity.
@@ -3911,13 +4160,15 @@ class Percent(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.PercentSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.PercentSetter:
         """
         Create a setter for this percent quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             PercentSetter: A setter with unit properties like .meters, .inches, etc.
@@ -3929,7 +4180,7 @@ class Percent(TypedQuantity):
         return ts.PercentSetter(self, value)
     
 
-class Permeability(TypedQuantity):
+class Permeability(FieldQnty):
     """
     Type-safe permeability quantity with expression capabilities.
     
@@ -3945,10 +4196,11 @@ class Permeability(TypedQuantity):
     
     Available units: "darcy", "square_feet", "square_meters"
     """
+
     __slots__ = ()
     _setter_class = ts.PermeabilitySetter
-    _expected_dimension = dim.PERMEABILITY
-    
+    _dimension = dim.PERMEABILITY
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize permeability quantity.
@@ -3967,13 +4219,15 @@ class Permeability(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.PermeabilitySetter:
+    def set(self, value: float, unit: str | None = None) -> ts.PermeabilitySetter:
         """
         Create a setter for this permeability quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             PermeabilitySetter: A setter with unit properties like .meters, .inches, etc.
@@ -3985,7 +4239,7 @@ class Permeability(TypedQuantity):
         return ts.PermeabilitySetter(self, value)
     
 
-class PhotonEmissionRate(TypedQuantity):
+class PhotonEmissionRate(FieldQnty):
     """
     Type-safe photon emission rate quantity with expression capabilities.
     
@@ -4001,10 +4255,11 @@ class PhotonEmissionRate(TypedQuantity):
     
     Available units: "rayleigh", "reciprocal_square_meter_second"
     """
+
     __slots__ = ()
     _setter_class = ts.PhotonEmissionRateSetter
-    _expected_dimension = dim.PHOTON_EMISSION_RATE
-    
+    _dimension = dim.PHOTON_EMISSION_RATE
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize photon emission rate quantity.
@@ -4023,13 +4278,15 @@ class PhotonEmissionRate(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.PhotonEmissionRateSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.PhotonEmissionRateSetter:
         """
         Create a setter for this photon emission rate quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             PhotonEmissionRateSetter: A setter with unit properties like .meters, .inches, etc.
@@ -4041,7 +4298,7 @@ class PhotonEmissionRate(TypedQuantity):
         return ts.PhotonEmissionRateSetter(self, value)
     
 
-class PowerPerUnitMass(TypedQuantity):
+class PowerPerUnitMass(FieldQnty):
     """
     Type-safe power per unit mass or specific power quantity with expression capabilities.
     
@@ -4057,10 +4314,11 @@ class PowerPerUnitMass(TypedQuantity):
     
     Available units: "british_thermal_unit_per_hour_per_pound_mass", "calorie_per_second_per_gram", "kilocalorie_per_hour_per_kilogram"
     """
+
     __slots__ = ()
     _setter_class = ts.PowerPerUnitMassSetter
-    _expected_dimension = dim.POWER_PER_UNIT_MASS
-    
+    _dimension = dim.POWER_PER_UNIT_MASS
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize power per unit mass or specific power quantity.
@@ -4079,13 +4337,15 @@ class PowerPerUnitMass(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.PowerPerUnitMassSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.PowerPerUnitMassSetter:
         """
         Create a setter for this power per unit mass or specific power quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             PowerPerUnitMassSetter: A setter with unit properties like .meters, .inches, etc.
@@ -4097,7 +4357,7 @@ class PowerPerUnitMass(TypedQuantity):
         return ts.PowerPerUnitMassSetter(self, value)
     
 
-class PowerPerUnitVolume(TypedQuantity):
+class PowerPerUnitVolume(FieldQnty):
     """
     Type-safe power per unit volume or power density quantity with expression capabilities.
     
@@ -4113,10 +4373,11 @@ class PowerPerUnitVolume(TypedQuantity):
     
     Available units: "british_thermal_unit_per_hour_per_cubic_foot", "calorie_per_second_per_cubic_centimeter", "chu_per_hour_per_cubic_foot"
     """
+
     __slots__ = ()
     _setter_class = ts.PowerPerUnitVolumeSetter
-    _expected_dimension = dim.POWER_PER_UNIT_VOLUME
-    
+    _dimension = dim.POWER_PER_UNIT_VOLUME
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize power per unit volume or power density quantity.
@@ -4135,13 +4396,15 @@ class PowerPerUnitVolume(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.PowerPerUnitVolumeSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.PowerPerUnitVolumeSetter:
         """
         Create a setter for this power per unit volume or power density quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             PowerPerUnitVolumeSetter: A setter with unit properties like .meters, .inches, etc.
@@ -4153,7 +4416,7 @@ class PowerPerUnitVolume(TypedQuantity):
         return ts.PowerPerUnitVolumeSetter(self, value)
     
 
-class PowerThermalDuty(TypedQuantity):
+class PowerThermalDuty(FieldQnty):
     """
     Type-safe power, thermal duty quantity with expression capabilities.
     
@@ -4169,10 +4432,11 @@ class PowerThermalDuty(TypedQuantity):
     
     Available units: "abwatt_emu_of_power", "boiler_horsepower", "british_thermal_unit_mean"
     """
+
     __slots__ = ()
     _setter_class = ts.PowerThermalDutySetter
-    _expected_dimension = dim.POWER_THERMAL_DUTY
-    
+    _dimension = dim.POWER_THERMAL_DUTY
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize power, thermal duty quantity.
@@ -4191,13 +4455,15 @@ class PowerThermalDuty(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.PowerThermalDutySetter:
+    def set(self, value: float, unit: str | None = None) -> ts.PowerThermalDutySetter:
         """
         Create a setter for this power, thermal duty quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             PowerThermalDutySetter: A setter with unit properties like .meters, .inches, etc.
@@ -4209,7 +4475,7 @@ class PowerThermalDuty(TypedQuantity):
         return ts.PowerThermalDutySetter(self, value)
     
 
-class Pressure(TypedQuantity):
+class Pressure(FieldQnty):
     """
     Type-safe pressure quantity with expression capabilities.
     
@@ -4225,10 +4491,11 @@ class Pressure(TypedQuantity):
     
     Available units: "atmosphere_standard", "bar", "barye"
     """
+
     __slots__ = ()
     _setter_class = ts.PressureSetter
-    _expected_dimension = dim.PRESSURE
-    
+    _dimension = dim.PRESSURE
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize pressure quantity.
@@ -4247,25 +4514,50 @@ class Pressure(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.PressureSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.PressureSetter:
         """
         Create a setter for this pressure quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for direct setting)
         
         Returns:
-            PressureSetter: A setter with unit properties like .meters, .inches, etc.
+            PressureSetter: A setter with unit properties like .psi, .bar, etc.
         
         Example:
-            >>> length = Length("beam_length")
-            >>> length.set(100).millimeters  # Sets to 100 mm
-        """
-        return ts.PressureSetter(self, value)
+            >>> pressure = Pressure("system_pressure")
+            >>> pressure.set(100).psi  # Sets to 100 psi
+            >>> pressure.set(100, "psi")  # Direct setting
+        """
+        if unit is not None:
+            # Direct setting with unit
+            setter = ts.PressureSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                # Try common aliases
+                unit_aliases = {
+                    "psi": "psi", "pound_per_square_inch": "psi",
+                    "bar": "bar", "bars": "bar",
+                    "pascal": "pascal", "pascals": "pascal", "pa": "pascal",
+                    "kpa": "kilopascal", "kilopascal": "kilopascal",
+                    "mpa": "megapascal", "megapascal": "megapascal",
+                    "atm": "atmosphere", "atmosphere": "atmosphere"
+                }
+                if unit in unit_aliases and hasattr(setter, unit_aliases[unit]):
+                    getattr(setter, unit_aliases[unit])
+                else:
+                    raise ValueError(f"Unknown unit: {unit}")
+            return self  # Return the variable itself for consistency
+        else:
+            return ts.PressureSetter(self, value)
     
 
-class RadiationDoseEquivalent(TypedQuantity):
+class RadiationDoseEquivalent(FieldQnty):
     """
     Type-safe radiation dose equivalent quantity with expression capabilities.
     
@@ -4281,10 +4573,11 @@ class RadiationDoseEquivalent(TypedQuantity):
     
     Available units: "rem", "sievert", "millisievert"
     """
+
     __slots__ = ()
     _setter_class = ts.RadiationDoseEquivalentSetter
-    _expected_dimension = dim.RADIATION_DOSE_EQUIVALENT
-    
+    _dimension = dim.RADIATION_DOSE_EQUIVALENT
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize radiation dose equivalent quantity.
@@ -4303,13 +4596,15 @@ class RadiationDoseEquivalent(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.RadiationDoseEquivalentSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.RadiationDoseEquivalentSetter:
         """
         Create a setter for this radiation dose equivalent quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             RadiationDoseEquivalentSetter: A setter with unit properties like .meters, .inches, etc.
@@ -4321,7 +4616,7 @@ class RadiationDoseEquivalent(TypedQuantity):
         return ts.RadiationDoseEquivalentSetter(self, value)
     
 
-class RadiationExposure(TypedQuantity):
+class RadiationExposure(FieldQnty):
     """
     Type-safe radiation exposure quantity with expression capabilities.
     
@@ -4337,10 +4632,11 @@ class RadiationExposure(TypedQuantity):
     
     Available units: "coulomb_per_kilogram", "d_unit", "pastille_dose_b_unit"
     """
+
     __slots__ = ()
     _setter_class = ts.RadiationExposureSetter
-    _expected_dimension = dim.RADIATION_EXPOSURE
-    
+    _dimension = dim.RADIATION_EXPOSURE
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize radiation exposure quantity.
@@ -4359,13 +4655,15 @@ class RadiationExposure(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.RadiationExposureSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.RadiationExposureSetter:
         """
         Create a setter for this radiation exposure quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             RadiationExposureSetter: A setter with unit properties like .meters, .inches, etc.
@@ -4377,7 +4675,7 @@ class RadiationExposure(TypedQuantity):
         return ts.RadiationExposureSetter(self, value)
     
 
-class Radioactivity(TypedQuantity):
+class Radioactivity(FieldQnty):
     """
     Type-safe radioactivity quantity with expression capabilities.
     
@@ -4393,10 +4691,11 @@ class Radioactivity(TypedQuantity):
     
     Available units: "becquerel", "curie", "mache_unit"
     """
+
     __slots__ = ()
     _setter_class = ts.RadioactivitySetter
-    _expected_dimension = dim.RADIOACTIVITY
-    
+    _dimension = dim.RADIOACTIVITY
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize radioactivity quantity.
@@ -4415,13 +4714,15 @@ class Radioactivity(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.RadioactivitySetter:
+    def set(self, value: float, unit: str | None = None) -> ts.RadioactivitySetter:
         """
         Create a setter for this radioactivity quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             RadioactivitySetter: A setter with unit properties like .meters, .inches, etc.
@@ -4433,7 +4734,7 @@ class Radioactivity(TypedQuantity):
         return ts.RadioactivitySetter(self, value)
     
 
-class SecondMomentOfArea(TypedQuantity):
+class SecondMomentOfArea(FieldQnty):
     """
     Type-safe second moment of area quantity with expression capabilities.
     
@@ -4449,10 +4750,11 @@ class SecondMomentOfArea(TypedQuantity):
     
     Available units: "inch_quadrupled", "centimeter_quadrupled", "foot_quadrupled"
     """
+
     __slots__ = ()
     _setter_class = ts.SecondMomentOfAreaSetter
-    _expected_dimension = dim.SECOND_MOMENT_OF_AREA
-    
+    _dimension = dim.SECOND_MOMENT_OF_AREA
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize second moment of area quantity.
@@ -4471,13 +4773,15 @@ class SecondMomentOfArea(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.SecondMomentOfAreaSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.SecondMomentOfAreaSetter:
         """
         Create a setter for this second moment of area quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             SecondMomentOfAreaSetter: A setter with unit properties like .meters, .inches, etc.
@@ -4489,7 +4793,7 @@ class SecondMomentOfArea(TypedQuantity):
         return ts.SecondMomentOfAreaSetter(self, value)
     
 
-class SecondRadiationConstantPlanck(TypedQuantity):
+class SecondRadiationConstantPlanck(FieldQnty):
     """
     Type-safe second radiation constant (planck) quantity with expression capabilities.
     
@@ -4505,10 +4809,11 @@ class SecondRadiationConstantPlanck(TypedQuantity):
     
     Available units: "meter_kelvin"
     """
+
     __slots__ = ()
     _setter_class = ts.SecondRadiationConstantPlanckSetter
-    _expected_dimension = dim.SECOND_RADIATION_CONSTANT_PLANCK
-    
+    _dimension = dim.SECOND_RADIATION_CONSTANT_PLANCK
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize second radiation constant (planck) quantity.
@@ -4527,13 +4832,15 @@ class SecondRadiationConstantPlanck(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.SecondRadiationConstantPlanckSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.SecondRadiationConstantPlanckSetter:
         """
         Create a setter for this second radiation constant (planck) quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             SecondRadiationConstantPlanckSetter: A setter with unit properties like .meters, .inches, etc.
@@ -4545,7 +4852,7 @@ class SecondRadiationConstantPlanck(TypedQuantity):
         return ts.SecondRadiationConstantPlanckSetter(self, value)
     
 
-class SpecificEnthalpy(TypedQuantity):
+class SpecificEnthalpy(FieldQnty):
     """
     Type-safe specific enthalpy quantity with expression capabilities.
     
@@ -4561,10 +4868,11 @@ class SpecificEnthalpy(TypedQuantity):
     
     Available units: "british_thermal_unit_mean", "british_thermal_unit_per_pound", "calorie_per_gram"
     """
+
     __slots__ = ()
     _setter_class = ts.SpecificEnthalpySetter
-    _expected_dimension = dim.SPECIFIC_ENTHALPY
-    
+    _dimension = dim.SPECIFIC_ENTHALPY
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize specific enthalpy quantity.
@@ -4583,13 +4891,15 @@ class SpecificEnthalpy(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.SpecificEnthalpySetter:
+    def set(self, value: float, unit: str | None = None) -> ts.SpecificEnthalpySetter:
         """
         Create a setter for this specific enthalpy quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             SpecificEnthalpySetter: A setter with unit properties like .meters, .inches, etc.
@@ -4601,7 +4911,7 @@ class SpecificEnthalpy(TypedQuantity):
         return ts.SpecificEnthalpySetter(self, value)
     
 
-class SpecificGravity(TypedQuantity):
+class SpecificGravity(FieldQnty):
     """
     Type-safe specific gravity quantity with expression capabilities.
     
@@ -4617,10 +4927,11 @@ class SpecificGravity(TypedQuantity):
     
     Available units: "dimensionless"
     """
+
     __slots__ = ()
     _setter_class = ts.SpecificGravitySetter
-    _expected_dimension = dim.SPECIFIC_GRAVITY
-    
+    _dimension = dim.SPECIFIC_GRAVITY
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize specific gravity quantity.
@@ -4639,13 +4950,15 @@ class SpecificGravity(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.SpecificGravitySetter:
+    def set(self, value: float, unit: str | None = None) -> ts.SpecificGravitySetter:
         """
         Create a setter for this specific gravity quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             SpecificGravitySetter: A setter with unit properties like .meters, .inches, etc.
@@ -4657,7 +4970,7 @@ class SpecificGravity(TypedQuantity):
         return ts.SpecificGravitySetter(self, value)
     
 
-class SpecificHeatCapacityConstantPressure(TypedQuantity):
+class SpecificHeatCapacityConstantPressure(FieldQnty):
     """
     Type-safe specific heat capacity (constant pressure) quantity with expression capabilities.
     
@@ -4673,10 +4986,11 @@ class SpecificHeatCapacityConstantPressure(TypedQuantity):
     
     Available units: "btu_per_pound_per_degree_fahrenheit_or_degree_rankine", "calories_per_gram_per_kelvin_or_degree_celsius", "joules_per_kilogram_per_kelvin_or_degree_celsius"
     """
+
     __slots__ = ()
     _setter_class = ts.SpecificHeatCapacityConstantPressureSetter
-    _expected_dimension = dim.SPECIFIC_HEAT_CAPACITY_CONSTANT_PRESSURE
-    
+    _dimension = dim.SPECIFIC_HEAT_CAPACITY_CONSTANT_PRESSURE
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize specific heat capacity (constant pressure) quantity.
@@ -4695,13 +5009,15 @@ class SpecificHeatCapacityConstantPressure(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.SpecificHeatCapacityConstantPressureSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.SpecificHeatCapacityConstantPressureSetter:
         """
         Create a setter for this specific heat capacity (constant pressure) quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             SpecificHeatCapacityConstantPressureSetter: A setter with unit properties like .meters, .inches, etc.
@@ -4713,7 +5029,7 @@ class SpecificHeatCapacityConstantPressure(TypedQuantity):
         return ts.SpecificHeatCapacityConstantPressureSetter(self, value)
     
 
-class SpecificLength(TypedQuantity):
+class SpecificLength(FieldQnty):
     """
     Type-safe specific length quantity with expression capabilities.
     
@@ -4729,10 +5045,11 @@ class SpecificLength(TypedQuantity):
     
     Available units: "centimeter_per_gram", "cotton_count", "ft_per_pound"
     """
+
     __slots__ = ()
     _setter_class = ts.SpecificLengthSetter
-    _expected_dimension = dim.SPECIFIC_LENGTH
-    
+    _dimension = dim.SPECIFIC_LENGTH
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize specific length quantity.
@@ -4751,13 +5068,15 @@ class SpecificLength(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.SpecificLengthSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.SpecificLengthSetter:
         """
         Create a setter for this specific length quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             SpecificLengthSetter: A setter with unit properties like .meters, .inches, etc.
@@ -4769,7 +5088,7 @@ class SpecificLength(TypedQuantity):
         return ts.SpecificLengthSetter(self, value)
     
 
-class SpecificSurface(TypedQuantity):
+class SpecificSurface(FieldQnty):
     """
     Type-safe specific surface quantity with expression capabilities.
     
@@ -4785,10 +5104,11 @@ class SpecificSurface(TypedQuantity):
     
     Available units: "square_centimeter_per_gram", "square_foot_per_kilogram", "square_foot_per_pound"
     """
+
     __slots__ = ()
     _setter_class = ts.SpecificSurfaceSetter
-    _expected_dimension = dim.SPECIFIC_SURFACE
-    
+    _dimension = dim.SPECIFIC_SURFACE
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize specific surface quantity.
@@ -4807,13 +5127,15 @@ class SpecificSurface(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.SpecificSurfaceSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.SpecificSurfaceSetter:
         """
         Create a setter for this specific surface quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             SpecificSurfaceSetter: A setter with unit properties like .meters, .inches, etc.
@@ -4825,7 +5147,7 @@ class SpecificSurface(TypedQuantity):
         return ts.SpecificSurfaceSetter(self, value)
     
 
-class SpecificVolume(TypedQuantity):
+class SpecificVolume(FieldQnty):
     """
     Type-safe specific volume quantity with expression capabilities.
     
@@ -4841,10 +5163,11 @@ class SpecificVolume(TypedQuantity):
     
     Available units: "cubic_centimeter_per_gram", "cubic_foot_per_kilogram", "cubic_foot_per_pound"
     """
+
     __slots__ = ()
     _setter_class = ts.SpecificVolumeSetter
-    _expected_dimension = dim.SPECIFIC_VOLUME
-    
+    _dimension = dim.SPECIFIC_VOLUME
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize specific volume quantity.
@@ -4863,13 +5186,15 @@ class SpecificVolume(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.SpecificVolumeSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.SpecificVolumeSetter:
         """
         Create a setter for this specific volume quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             SpecificVolumeSetter: A setter with unit properties like .meters, .inches, etc.
@@ -4881,7 +5206,7 @@ class SpecificVolume(TypedQuantity):
         return ts.SpecificVolumeSetter(self, value)
     
 
-class Stress(TypedQuantity):
+class Stress(FieldQnty):
     """
     Type-safe stress quantity with expression capabilities.
     
@@ -4897,10 +5222,11 @@ class Stress(TypedQuantity):
     
     Available units: "dyne_per_square_centimeter", "gigapascal", "hectopascal"
     """
+
     __slots__ = ()
     _setter_class = ts.StressSetter
-    _expected_dimension = dim.STRESS
-    
+    _dimension = dim.STRESS
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize stress quantity.
@@ -4919,13 +5245,15 @@ class Stress(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.StressSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.StressSetter:
         """
         Create a setter for this stress quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             StressSetter: A setter with unit properties like .meters, .inches, etc.
@@ -4937,7 +5265,7 @@ class Stress(TypedQuantity):
         return ts.StressSetter(self, value)
     
 
-class SurfaceMassDensity(TypedQuantity):
+class SurfaceMassDensity(FieldQnty):
     """
     Type-safe surface mass density quantity with expression capabilities.
     
@@ -4953,10 +5281,11 @@ class SurfaceMassDensity(TypedQuantity):
     
     Available units: "gram_per_square_centimeter", "gram_per_square_meter", "kilogram_per_square_meter"
     """
+
     __slots__ = ()
     _setter_class = ts.SurfaceMassDensitySetter
-    _expected_dimension = dim.SURFACE_MASS_DENSITY
-    
+    _dimension = dim.SURFACE_MASS_DENSITY
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize surface mass density quantity.
@@ -4975,13 +5304,15 @@ class SurfaceMassDensity(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.SurfaceMassDensitySetter:
+    def set(self, value: float, unit: str | None = None) -> ts.SurfaceMassDensitySetter:
         """
         Create a setter for this surface mass density quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             SurfaceMassDensitySetter: A setter with unit properties like .meters, .inches, etc.
@@ -4993,7 +5324,7 @@ class SurfaceMassDensity(TypedQuantity):
         return ts.SurfaceMassDensitySetter(self, value)
     
 
-class SurfaceTension(TypedQuantity):
+class SurfaceTension(FieldQnty):
     """
     Type-safe surface tension quantity with expression capabilities.
     
@@ -5009,10 +5340,11 @@ class SurfaceTension(TypedQuantity):
     
     Available units: "dyne_per_centimeter", "gram_force_per_centimeter", "newton_per_meter"
     """
+
     __slots__ = ()
     _setter_class = ts.SurfaceTensionSetter
-    _expected_dimension = dim.SURFACE_TENSION
-    
+    _dimension = dim.SURFACE_TENSION
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize surface tension quantity.
@@ -5031,13 +5363,15 @@ class SurfaceTension(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.SurfaceTensionSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.SurfaceTensionSetter:
         """
         Create a setter for this surface tension quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             SurfaceTensionSetter: A setter with unit properties like .meters, .inches, etc.
@@ -5049,7 +5383,7 @@ class SurfaceTension(TypedQuantity):
         return ts.SurfaceTensionSetter(self, value)
     
 
-class Temperature(TypedQuantity):
+class Temperature(FieldQnty):
     """
     Type-safe temperature quantity with expression capabilities.
     
@@ -5065,10 +5399,11 @@ class Temperature(TypedQuantity):
     
     Available units: "degree_celsius_unit_size", "degree_fahrenheit_unit_size", "degree_r_aumur_unit_size"
     """
+
     __slots__ = ()
     _setter_class = ts.TemperatureSetter
-    _expected_dimension = dim.TEMPERATURE
-    
+    _dimension = dim.TEMPERATURE
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize temperature quantity.
@@ -5087,13 +5422,15 @@ class Temperature(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.TemperatureSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.TemperatureSetter:
         """
         Create a setter for this temperature quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             TemperatureSetter: A setter with unit properties like .meters, .inches, etc.
@@ -5105,7 +5442,7 @@ class Temperature(TypedQuantity):
         return ts.TemperatureSetter(self, value)
     
 
-class ThermalConductivity(TypedQuantity):
+class ThermalConductivity(FieldQnty):
     """
     Type-safe thermal conductivity quantity with expression capabilities.
     
@@ -5121,10 +5458,11 @@ class ThermalConductivity(TypedQuantity):
     
     Available units: "btu_it", "btu_therm", "btu_therm"
     """
+
     __slots__ = ()
     _setter_class = ts.ThermalConductivitySetter
-    _expected_dimension = dim.THERMAL_CONDUCTIVITY
-    
+    _dimension = dim.THERMAL_CONDUCTIVITY
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize thermal conductivity quantity.
@@ -5143,13 +5481,15 @@ class ThermalConductivity(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.ThermalConductivitySetter:
+    def set(self, value: float, unit: str | None = None) -> ts.ThermalConductivitySetter:
         """
         Create a setter for this thermal conductivity quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             ThermalConductivitySetter: A setter with unit properties like .meters, .inches, etc.
@@ -5161,7 +5501,7 @@ class ThermalConductivity(TypedQuantity):
         return ts.ThermalConductivitySetter(self, value)
     
 
-class Time(TypedQuantity):
+class Time(FieldQnty):
     """
     Type-safe time quantity with expression capabilities.
     
@@ -5177,10 +5517,11 @@ class Time(TypedQuantity):
     
     Available units: "blink", "century", "chronon_or_tempon"
     """
+
     __slots__ = ()
     _setter_class = ts.TimeSetter
-    _expected_dimension = dim.TIME
-    
+    _dimension = dim.TIME
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize time quantity.
@@ -5199,13 +5540,15 @@ class Time(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.TimeSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.TimeSetter:
         """
         Create a setter for this time quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             TimeSetter: A setter with unit properties like .meters, .inches, etc.
@@ -5217,7 +5560,7 @@ class Time(TypedQuantity):
         return ts.TimeSetter(self, value)
     
 
-class Torque(TypedQuantity):
+class Torque(FieldQnty):
     """
     Type-safe torque quantity with expression capabilities.
     
@@ -5233,10 +5576,11 @@ class Torque(TypedQuantity):
     
     Available units: "centimeter_kilogram_force", "dyne_centimeter", "foot_kilogram_force"
     """
+
     __slots__ = ()
     _setter_class = ts.TorqueSetter
-    _expected_dimension = dim.TORQUE
-    
+    _dimension = dim.TORQUE
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize torque quantity.
@@ -5255,13 +5599,15 @@ class Torque(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.TorqueSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.TorqueSetter:
         """
         Create a setter for this torque quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             TorqueSetter: A setter with unit properties like .meters, .inches, etc.
@@ -5273,7 +5619,7 @@ class Torque(TypedQuantity):
         return ts.TorqueSetter(self, value)
     
 
-class TurbulenceEnergyDissipationRate(TypedQuantity):
+class TurbulenceEnergyDissipationRate(FieldQnty):
     """
     Type-safe turbulence energy dissipation rate quantity with expression capabilities.
     
@@ -5289,10 +5635,11 @@ class TurbulenceEnergyDissipationRate(TypedQuantity):
     
     Available units: "square_foot_per_cubic_second", "square_meter_per_cubic_second"
     """
+
     __slots__ = ()
     _setter_class = ts.TurbulenceEnergyDissipationRateSetter
-    _expected_dimension = dim.TURBULENCE_ENERGY_DISSIPATION_RATE
-    
+    _dimension = dim.TURBULENCE_ENERGY_DISSIPATION_RATE
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize turbulence energy dissipation rate quantity.
@@ -5311,13 +5658,15 @@ class TurbulenceEnergyDissipationRate(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.TurbulenceEnergyDissipationRateSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.TurbulenceEnergyDissipationRateSetter:
         """
         Create a setter for this turbulence energy dissipation rate quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             TurbulenceEnergyDissipationRateSetter: A setter with unit properties like .meters, .inches, etc.
@@ -5329,7 +5678,7 @@ class TurbulenceEnergyDissipationRate(TypedQuantity):
         return ts.TurbulenceEnergyDissipationRateSetter(self, value)
     
 
-class VelocityAngular(TypedQuantity):
+class VelocityAngular(FieldQnty):
     """
     Type-safe velocity, angular quantity with expression capabilities.
     
@@ -5345,10 +5694,11 @@ class VelocityAngular(TypedQuantity):
     
     Available units: "degree_per_minute", "degree_per_second", "grade_per_minute"
     """
+
     __slots__ = ()
     _setter_class = ts.VelocityAngularSetter
-    _expected_dimension = dim.VELOCITY_ANGULAR
-    
+    _dimension = dim.VELOCITY_ANGULAR
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize velocity, angular quantity.
@@ -5367,13 +5717,15 @@ class VelocityAngular(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.VelocityAngularSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.VelocityAngularSetter:
         """
         Create a setter for this velocity, angular quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             VelocityAngularSetter: A setter with unit properties like .meters, .inches, etc.
@@ -5385,7 +5737,7 @@ class VelocityAngular(TypedQuantity):
         return ts.VelocityAngularSetter(self, value)
     
 
-class VelocityLinear(TypedQuantity):
+class VelocityLinear(FieldQnty):
     """
     Type-safe velocity, linear quantity with expression capabilities.
     
@@ -5401,10 +5753,11 @@ class VelocityLinear(TypedQuantity):
     
     Available units: "foot_per_hour", "foot_per_minute", "foot_per_second"
     """
+
     __slots__ = ()
     _setter_class = ts.VelocityLinearSetter
-    _expected_dimension = dim.VELOCITY_LINEAR
-    
+    _dimension = dim.VELOCITY_LINEAR
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize velocity, linear quantity.
@@ -5423,13 +5776,15 @@ class VelocityLinear(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.VelocityLinearSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.VelocityLinearSetter:
         """
         Create a setter for this velocity, linear quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             VelocityLinearSetter: A setter with unit properties like .meters, .inches, etc.
@@ -5441,7 +5796,7 @@ class VelocityLinear(TypedQuantity):
         return ts.VelocityLinearSetter(self, value)
     
 
-class ViscosityDynamic(TypedQuantity):
+class ViscosityDynamic(FieldQnty):
     """
     Type-safe viscosity, dynamic quantity with expression capabilities.
     
@@ -5457,10 +5812,11 @@ class ViscosityDynamic(TypedQuantity):
     
     Available units: "centipoise", "dyne_second_per_square_centimeter", "kilopound_second_per_square_meter"
     """
+
     __slots__ = ()
     _setter_class = ts.ViscosityDynamicSetter
-    _expected_dimension = dim.VISCOSITY_DYNAMIC
-    
+    _dimension = dim.VISCOSITY_DYNAMIC
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize viscosity, dynamic quantity.
@@ -5479,13 +5835,15 @@ class ViscosityDynamic(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.ViscosityDynamicSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.ViscosityDynamicSetter:
         """
         Create a setter for this viscosity, dynamic quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             ViscosityDynamicSetter: A setter with unit properties like .meters, .inches, etc.
@@ -5497,7 +5855,7 @@ class ViscosityDynamic(TypedQuantity):
         return ts.ViscosityDynamicSetter(self, value)
     
 
-class ViscosityKinematic(TypedQuantity):
+class ViscosityKinematic(FieldQnty):
     """
     Type-safe viscosity, kinematic quantity with expression capabilities.
     
@@ -5513,10 +5871,11 @@ class ViscosityKinematic(TypedQuantity):
     
     Available units: "centistokes", "millistokes", "square_centimeter_per_second"
     """
+
     __slots__ = ()
     _setter_class = ts.ViscosityKinematicSetter
-    _expected_dimension = dim.VISCOSITY_KINEMATIC
-    
+    _dimension = dim.VISCOSITY_KINEMATIC
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize viscosity, kinematic quantity.
@@ -5535,13 +5894,15 @@ class ViscosityKinematic(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.ViscosityKinematicSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.ViscosityKinematicSetter:
         """
         Create a setter for this viscosity, kinematic quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             ViscosityKinematicSetter: A setter with unit properties like .meters, .inches, etc.
@@ -5553,7 +5914,7 @@ class ViscosityKinematic(TypedQuantity):
         return ts.ViscosityKinematicSetter(self, value)
     
 
-class Volume(TypedQuantity):
+class Volume(FieldQnty):
     """
     Type-safe volume quantity with expression capabilities.
     
@@ -5569,10 +5930,11 @@ class Volume(TypedQuantity):
     
     Available units: "acre_foot", "acre_inch", "barrel_us_liquid"
     """
+
     __slots__ = ()
     _setter_class = ts.VolumeSetter
-    _expected_dimension = dim.VOLUME
-    
+    _dimension = dim.VOLUME
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize volume quantity.
@@ -5591,13 +5953,15 @@ class Volume(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.VolumeSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.VolumeSetter:
         """
         Create a setter for this volume quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             VolumeSetter: A setter with unit properties like .meters, .inches, etc.
@@ -5609,7 +5973,7 @@ class Volume(TypedQuantity):
         return ts.VolumeSetter(self, value)
     
 
-class VolumeFractionOfI(TypedQuantity):
+class VolumeFractionOfI(FieldQnty):
     """
     Type-safe volume fraction of "i" quantity with expression capabilities.
     
@@ -5625,10 +5989,11 @@ class VolumeFractionOfI(TypedQuantity):
     
     Available units: "cubic_centimeters_of_i_per_cubic_meter_total", "cubic_foot_of_i_per_cubic_foot_total", "cubic_meters_of_i_per_cubic_meter_total"
     """
+
     __slots__ = ()
     _setter_class = ts.VolumeFractionOfISetter
-    _expected_dimension = dim.VOLUME_FRACTION_OF_I
-    
+    _dimension = dim.VOLUME_FRACTION_OF_I
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize volume fraction of "i" quantity.
@@ -5647,13 +6012,15 @@ class VolumeFractionOfI(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.VolumeFractionOfISetter:
+    def set(self, value: float, unit: str | None = None) -> ts.VolumeFractionOfISetter:
         """
         Create a setter for this volume fraction of "i" quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             VolumeFractionOfISetter: A setter with unit properties like .meters, .inches, etc.
@@ -5665,7 +6032,7 @@ class VolumeFractionOfI(TypedQuantity):
         return ts.VolumeFractionOfISetter(self, value)
     
 
-class VolumetricCalorificHeatingValue(TypedQuantity):
+class VolumetricCalorificHeatingValue(FieldQnty):
     """
     Type-safe volumetric calorific (heating) value quantity with expression capabilities.
     
@@ -5681,10 +6048,11 @@ class VolumetricCalorificHeatingValue(TypedQuantity):
     
     Available units: "british_thermal_unit_per_cubic_foot", "british_thermal_unit_per_gallon_uk", "british_thermal_unit_per_gallon_us"
     """
+
     __slots__ = ()
     _setter_class = ts.VolumetricCalorificHeatingValueSetter
-    _expected_dimension = dim.VOLUMETRIC_CALORIFIC_HEATING_VALUE
-    
+    _dimension = dim.VOLUMETRIC_CALORIFIC_HEATING_VALUE
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize volumetric calorific (heating) value quantity.
@@ -5703,13 +6071,15 @@ class VolumetricCalorificHeatingValue(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.VolumetricCalorificHeatingValueSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.VolumetricCalorificHeatingValueSetter:
         """
         Create a setter for this volumetric calorific (heating) value quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             VolumetricCalorificHeatingValueSetter: A setter with unit properties like .meters, .inches, etc.
@@ -5721,7 +6091,7 @@ class VolumetricCalorificHeatingValue(TypedQuantity):
         return ts.VolumetricCalorificHeatingValueSetter(self, value)
     
 
-class VolumetricCoefficientOfExpansion(TypedQuantity):
+class VolumetricCoefficientOfExpansion(FieldQnty):
     """
     Type-safe volumetric coefficient of expansion quantity with expression capabilities.
     
@@ -5737,10 +6107,11 @@ class VolumetricCoefficientOfExpansion(TypedQuantity):
     
     Available units: "gram_per_cubic_centimeter_per_kelvin_or_degree_celsius", "kilogram_per_cubic_meter_per_kelvin_or_degree_celsius", "pound_per_cubic_foot_per_degree_fahrenheit_or_degree_rankine"
     """
+
     __slots__ = ()
     _setter_class = ts.VolumetricCoefficientOfExpansionSetter
-    _expected_dimension = dim.VOLUMETRIC_COEFFICIENT_OF_EXPANSION
-    
+    _dimension = dim.VOLUMETRIC_COEFFICIENT_OF_EXPANSION
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize volumetric coefficient of expansion quantity.
@@ -5759,13 +6130,15 @@ class VolumetricCoefficientOfExpansion(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.VolumetricCoefficientOfExpansionSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.VolumetricCoefficientOfExpansionSetter:
         """
         Create a setter for this volumetric coefficient of expansion quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             VolumetricCoefficientOfExpansionSetter: A setter with unit properties like .meters, .inches, etc.
@@ -5777,7 +6150,7 @@ class VolumetricCoefficientOfExpansion(TypedQuantity):
         return ts.VolumetricCoefficientOfExpansionSetter(self, value)
     
 
-class VolumetricFlowRate(TypedQuantity):
+class VolumetricFlowRate(FieldQnty):
     """
     Type-safe volumetric flow rate quantity with expression capabilities.
     
@@ -5793,10 +6166,11 @@ class VolumetricFlowRate(TypedQuantity):
     
     Available units: "cubic_feet_per_day", "cubic_feet_per_hour", "cubic_feet_per_minute"
     """
+
     __slots__ = ()
     _setter_class = ts.VolumetricFlowRateSetter
-    _expected_dimension = dim.VOLUMETRIC_FLOW_RATE
-    
+    _dimension = dim.VOLUMETRIC_FLOW_RATE
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize volumetric flow rate quantity.
@@ -5815,13 +6189,15 @@ class VolumetricFlowRate(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.VolumetricFlowRateSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.VolumetricFlowRateSetter:
         """
         Create a setter for this volumetric flow rate quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             VolumetricFlowRateSetter: A setter with unit properties like .meters, .inches, etc.
@@ -5833,7 +6209,7 @@ class VolumetricFlowRate(TypedQuantity):
         return ts.VolumetricFlowRateSetter(self, value)
     
 
-class VolumetricFlux(TypedQuantity):
+class VolumetricFlux(FieldQnty):
     """
     Type-safe volumetric flux quantity with expression capabilities.
     
@@ -5849,10 +6225,11 @@ class VolumetricFlux(TypedQuantity):
     
     Available units: "cubic_feet_per_square_foot_per_day", "cubic_feet_per_square_foot_per_hour", "cubic_feet_per_square_foot_per_minute"
     """
+
     __slots__ = ()
     _setter_class = ts.VolumetricFluxSetter
-    _expected_dimension = dim.VOLUMETRIC_FLUX
-    
+    _dimension = dim.VOLUMETRIC_FLUX
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize volumetric flux quantity.
@@ -5871,13 +6248,15 @@ class VolumetricFlux(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.VolumetricFluxSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.VolumetricFluxSetter:
         """
         Create a setter for this volumetric flux quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             VolumetricFluxSetter: A setter with unit properties like .meters, .inches, etc.
@@ -5889,7 +6268,7 @@ class VolumetricFlux(TypedQuantity):
         return ts.VolumetricFluxSetter(self, value)
     
 
-class VolumetricMassFlowRate(TypedQuantity):
+class VolumetricMassFlowRate(FieldQnty):
     """
     Type-safe volumetric mass flow rate quantity with expression capabilities.
     
@@ -5905,10 +6284,11 @@ class VolumetricMassFlowRate(TypedQuantity):
     
     Available units: "gram_per_second_per_cubic_centimeter", "kilogram_per_hour_per_cubic_foot", "kilogram_per_hour_per_cubic_meter"
     """
+
     __slots__ = ()
     _setter_class = ts.VolumetricMassFlowRateSetter
-    _expected_dimension = dim.VOLUMETRIC_MASS_FLOW_RATE
-    
+    _dimension = dim.VOLUMETRIC_MASS_FLOW_RATE
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize volumetric mass flow rate quantity.
@@ -5927,13 +6307,15 @@ class VolumetricMassFlowRate(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.VolumetricMassFlowRateSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.VolumetricMassFlowRateSetter:
         """
         Create a setter for this volumetric mass flow rate quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             VolumetricMassFlowRateSetter: A setter with unit properties like .meters, .inches, etc.
@@ -5945,7 +6327,7 @@ class VolumetricMassFlowRate(TypedQuantity):
         return ts.VolumetricMassFlowRateSetter(self, value)
     
 
-class Wavenumber(TypedQuantity):
+class Wavenumber(FieldQnty):
     """
     Type-safe wavenumber quantity with expression capabilities.
     
@@ -5961,10 +6343,11 @@ class Wavenumber(TypedQuantity):
     
     Available units: "diopter", "kayser", "reciprocal_meter"
     """
+
     __slots__ = ()
     _setter_class = ts.WavenumberSetter
-    _expected_dimension = dim.WAVENUMBER
-    
+    _dimension = dim.WAVENUMBER
+
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
         """
         Initialize wavenumber quantity.
@@ -5983,13 +6366,15 @@ class Wavenumber(TypedQuantity):
             super().__init__(name_or_value, unit, name, is_known=is_known)
         else:
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
+        self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: int | float) -> ts.WavenumberSetter:
+    def set(self, value: float, unit: str | None = None) -> ts.WavenumberSetter:
         """
         Create a setter for this wavenumber quantity.
         
         Args:
             value: The numeric value to set
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             WavenumberSetter: A setter with unit properties like .meters, .inches, etc.