unitforge 0.5.12__tar.gz → 0.5.13__tar.gz

{unitforge-0.5.12 → unitforge-0.5.13}/Cargo.lock

@@ -351,7 +351,7 @@ checksum = "5a5f39404a5da50712a4c1eecf25e90dd62b613502b7e925fd4e4d19b5c96512"
 
 [[package]]
 name = "unitforge"
-version = "0.5.12"
+version = "0.5.13"
 dependencies = [
  "ndarray",
  "num-traits",
@@ -367,7 +367,7 @@ dependencies = [
 
 [[package]]
 name = "unitforge_macros"
-version = "0.5.12"
+version = "0.5.13"
 dependencies = [
  "regex",
 ]

{unitforge-0.5.12 → unitforge-0.5.13}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "unitforge"
-version = "0.5.12"
+version = "0.5.13"
 edition = "2021"
 authors = ["Dr.Q team <info@askdrq.com>", "Henrik Stromberg <henrik@askdrq.com>"]
 description = "A library for unit and quantity consistent computations in Rust"
@@ -20,7 +20,7 @@ pyo3 = { version = "0.28.3", features = ["extension-module", "auto-initialize",
 numpy = { version = "0.28.0", optional = true }
 strum = { version = "0.28.0", optional = true }
 strum_macros = { version = "0.28.0", optional = true }
-unitforge_macros = { version = "0.5.12", path = "unitforge_macros" }
+unitforge_macros = { version = "0.5.13", path = "unitforge_macros" }
 
 [features]
 default = []

{unitforge-0.5.12 → unitforge-0.5.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: unitforge
-Version: 0.5.12
+Version: 0.5.13
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Rust
 Classifier: License :: OSI Approved :: MIT License
@@ -9,7 +9,9 @@ Classifier: Topic :: Scientific/Engineering :: Physics
 Requires-Dist: numpy>=2.2.0
 Summary: A library for unit and quantity consistent computations in Rust
 Keywords: units,quantities,simulation,physics
+Author: Dr.Q team <info@askdrq.com>, Henrik Stromberg <henrik@askdrq.com>
 Author-email: "Dr.Q team" <info@askdrq.com>, Henrik Stromberg <henrik@askdrq.com>
+License: MIT
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
 Project-URL: Repository, https://gitlab.com/henrikjstromberg/unitforge
@@ -72,6 +74,20 @@ f_sum = f1 + f2
 print(f_sum.to(ForceUnit.N))  # → 8.0
 ```
 
+### Comparing Quantities
+
+`==` is tolerance-based: two quantities are equal when they differ by at most `1e-9` of the larger
+magnitude. An infinity equals only itself, and NaN equals nothing. `<`, `<=`, `>` and `>=` compare
+exactly, so for nearly equal values `a == b` and `a < b` can both be true. For explicit tolerances
+use `a.close_abs(b, threshold)` (absolute, `threshold` is a quantity) or
+`a.close_rel(b, threshold)` (relative to the mean magnitude). Quantities are not hashable.
+
+```python
+a = Force(1.0, ForceUnit.N)
+b = Force(1.0 + 1e-12, ForceUnit.N)
+print(a == b, a < b)  # → True True
+```
+
 ---
 
 ## Vector and Matrix Support

{unitforge-0.5.12 → unitforge-0.5.13}/Readme.md

@@ -15,6 +15,17 @@
 - **Serialization**: Optional support for serde using `features = ["serde"]`; combine with `ndarray` for ndarray serialization support.
 - **python interface** Optional Python interface when building with flag pyo3; also available on pypi
 
+## Comparing quantities
+
+`==` is tolerance-based: two quantities are equal when they differ by at most `1e-9` of the larger
+magnitude. An infinity equals only itself, and NaN equals nothing. Ordering (`<`, `<=`, `>`, `>=`)
+compares the stored values exactly. As a consequence:
+
+- `==` is not transitive, and for nearly equal values `a == b` and `a < b` can both be true.
+- `Hash` hashes the exact stored value, so quantities that compare equal can hash differently. Do
+  not rely on hash-based collections to merge nearly equal quantities.
+- For an explicit, absolute tolerance use `a.is_close(&b, &tolerance)`.
+
 ## Contribute
 
 All contributions are welcome! Feel free to implement new quantities or define relations using `impl_macros.rs`. 🚀

{unitforge-0.5.12 → unitforge-0.5.13}/Readme_py.md

@@ -56,6 +56,20 @@ f_sum = f1 + f2
 print(f_sum.to(ForceUnit.N))  # → 8.0
 ```
 
+### Comparing Quantities
+
+`==` is tolerance-based: two quantities are equal when they differ by at most `1e-9` of the larger
+magnitude. An infinity equals only itself, and NaN equals nothing. `<`, `<=`, `>` and `>=` compare
+exactly, so for nearly equal values `a == b` and `a < b` can both be true. For explicit tolerances
+use `a.close_abs(b, threshold)` (absolute, `threshold` is a quantity) or
+`a.close_rel(b, threshold)` (relative to the mean magnitude). Quantities are not hashable.
+
+```python
+a = Force(1.0, ForceUnit.N)
+b = Force(1.0 + 1e-12, ForceUnit.N)
+print(a == b, a < b)  # → True True
+```
+
 ---
 
 ## Vector and Matrix Support

{unitforge-0.5.12 → unitforge-0.5.13}/src/impl_macros.rs

@@ -56,6 +56,9 @@ macro_rules! impl_quantity {
             pub(crate) kind_id: u32,
         }
 
+        // Hashes the stored value: canonical parts (which every constructor produces
+        // deterministically) or the plain float with `-0.0` folded into `0.0`. `==` allows a
+        // relative tolerance, so values that are merely close can still hash differently.
         impl core::hash::Hash for $type {
             #[cfg(not(any(feature = "storage-f64", feature = "storage-f32")))]
             fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
@@ -64,11 +67,26 @@ macro_rules! impl_quantity {
             }
             #[cfg(any(feature = "storage-f64", feature = "storage-f32"))]
             fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
-                core::hash::Hash::hash(&self.value.to_bits(), state);
+                core::hash::Hash::hash(
+                    &$crate::internal::canonical_float_bits(f64::from(self.value)),
+                    state,
+                );
             }
         }
 
         impl $type {
+            /// Whether both hold exactly the same value (never true for NaN).
+            fn same_value(&self, other: &Self) -> bool {
+                #[cfg(not(any(feature = "storage-f64", feature = "storage-f32")))]
+                {
+                    self.multiplier == other.multiplier && self.power == other.power
+                }
+                #[cfg(any(feature = "storage-f64", feature = "storage-f32"))]
+                {
+                    self.value == other.value
+                }
+            }
+
             #[cfg(not(any(feature = "storage-f64", feature = "storage-f32")))]
             fn from_parts(multiplier: f64, power: i32) -> Self {
                 let (multiplier, power) =
@@ -82,8 +100,7 @@ macro_rules! impl_quantity {
 
             #[cfg(not(any(feature = "storage-f64", feature = "storage-f32")))]
             pub(crate) fn from_base_value(value: f64) -> Self {
-                let (multiplier, power) = <Self as $crate::PhysicsQuantity>::split_value(value);
-                Self::from_parts(multiplier, power)
+                Self::from_parts(value, 0)
             }
 
             #[cfg(feature = "storage-f64")]
@@ -160,8 +177,9 @@ macro_rules! impl_quantity {
                         );
                 #[cfg(not(any(feature = "storage-f64", feature = "storage-f32")))]
                 {
+                    // Same normalization as `from_raw`, so both agree bit for bit.
                     let (multiplier, power) =
-                        $crate::internal::value_to_quantity_parts_const(value);
+                        $crate::internal::canonicalize_quantity_parts_const(value, 0);
                     let (multiplier, power) = $crate::internal::canonicalize_quantity_parts_const(
                         multiplier * unit_multiplier,
                         $crate::internal::saturating_power_add_const(power, unit_power),
@@ -246,10 +264,7 @@ macro_rules! impl_quantity {
             fn as_f64(&self) -> f64 {
                 #[cfg(not(any(feature = "storage-f64", feature = "storage-f32")))]
                 {
-                    if self.multiplier == 0.0 {
-                        return 0.0;
-                    }
-                    self.multiplier * 10_f64.powi(self.power)
+                    $crate::internal::quantity_parts_to_value(self.multiplier, self.power)
                 }
                 #[cfg(feature = "storage-f64")]
                 {
@@ -269,29 +284,12 @@ macro_rules! impl_quantity {
 
             #[cfg(not(any(feature = "storage-f64", feature = "storage-f32")))]
             fn split_value(v: f64) -> (f64, i32) {
-                if v.is_zero() {
-                    (0.0, 0)
-                } else if v.is_nan() {
-                    (f64::NAN, 0)
-                } else if v.is_infinite() {
-                    if v > 0.0 {
-                        (f64::INFINITY, 0)
-                    } else {
-                        (f64::NEG_INFINITY, 0)
-                    }
-                } else {
-                    let power = v.abs().log10().floor() as i32;
-                    let multiplier = v / 10f64.powi(power);
-                    (multiplier, power)
-                }
+                $crate::internal::split_decimal(v)
             }
 
             #[cfg(not(any(feature = "storage-f64", feature = "storage-f32")))]
             fn get_value(&self) -> f64 {
-                if self.multiplier == 0.0 {
-                    return 0.0;
-                }
-                self.multiplier * 10_f64.powi(self.power)
+                self.as_f64()
             }
 
             #[cfg(not(any(feature = "storage-f64", feature = "storage-f32")))]
@@ -314,12 +312,11 @@ macro_rules! impl_quantity {
                 #[cfg(not(any(feature = "storage-f64", feature = "storage-f32")))]
                 {
                     if offset == 0.0 {
-                        if self.multiplier == 0.0 {
-                            return 0.0;
-                        }
                         let (unit_multiplier, unit_power) = unit.base_per_x();
-                        return self.multiplier / unit_multiplier
-                            * $crate::internal::pow10_delta(self.power, unit_power);
+                        return $crate::internal::quantity_parts_to_value(
+                            self.multiplier / unit_multiplier,
+                            $crate::internal::saturating_power_sub(self.power, unit_power),
+                        );
                     }
                     // Affine units (non-zero offset) go through `as_f64()`
                     // instead of the mantissa/power fast path above, since
@@ -394,7 +391,8 @@ macro_rules! impl_quantity {
             }
 
             fn is_close(&self, other: &Self, tolerance: &Self) -> bool {
-                (self.as_f64() - other.as_f64()).abs() <= tolerance.as_f64().abs()
+                // Identical values, equal infinities included, are always close.
+                self.same_value(other) || (*self - *other).abs() <= tolerance.abs()
             }
 
             fn optimize(&mut self) {
@@ -540,24 +538,18 @@ macro_rules! impl_quantity {
                 }
                 #[cfg(not(feature = "no_std"))]
                 {
-                    use std::collections::HashMap;
-                    let mut groups: HashMap<String, Vec<String>> = HashMap::new();
-
+                    // Units showing the same rounded value share an entry, in display-unit order.
+                    let mut groups: Vec<(String, Vec<String>)> = Vec::new();
                     for base_unit in $display_units {
-                        let value = self.to(base_unit);
-                        let rounded = if value.is_zero() {
-                            value
-                        } else {
-                            let digits = value.abs().log10().ceil() as i32;
-                            let rounding_multiplier = 10_f64.powi(3 - digits);
-                            (value * rounding_multiplier).round() / rounding_multiplier
-                        };
-
-                        let value = format!("{}", rounded);
-                        groups
-                            .entry(value)
-                            .or_default()
-                            .push(base_unit.name().to_string());
+                        let value = format!(
+                            "{}",
+                            $crate::internal::round_to_significant_digits(self.to(base_unit), 3)
+                        );
+                        let name = base_unit.name().to_string();
+                        match groups.iter_mut().find(|(existing, _)| *existing == value) {
+                            Some((_, units)) => units.push(name),
+                            None => groups.push((value, vec![name])),
+                        }
                     }
 
                     let mut parts = Vec::new();
@@ -599,30 +591,45 @@ macro_rules! impl_quantity {
         where
             $type: PhysicsQuantity,
         {
+            /// Equal up to `RELATIVE_EQUALITY_TOLERANCE` (1e-9) of the larger magnitude.
+            /// Symmetric; an infinity equals only itself and NaN equals nothing.
             fn eq(&self, other: &Self) -> bool {
                 #[cfg(not(any(feature = "storage-f64", feature = "storage-f32")))]
                 {
-                    self.is_close(
-                        other,
-                        &Self::from_parts(
-                            self.multiplier,
-                            $crate::internal::saturating_power_sub(self.power, 9),
-                        ),
+                    $crate::internal::quantity_parts_approx_eq(
+                        self.multiplier,
+                        self.power,
+                        other.multiplier,
+                        other.power,
                     )
                 }
                 #[cfg(any(feature = "storage-f64", feature = "storage-f32"))]
                 {
-                    self.is_close(other, &Self::from_base_value(self.as_f64().abs() * 1.0e-9))
+                    $crate::internal::float_approx_eq(self.as_f64(), other.as_f64())
                 }
             }
         }
 
+        /// Exact ordering of the stored values (unlike the tolerance-based `==`), so sorting
+        /// stays a strict weak ordering.
         impl PartialOrd for $type
         where
             $type: PhysicsQuantity,
         {
             fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-                self.as_f64().partial_cmp(&other.as_f64())
+                #[cfg(not(any(feature = "storage-f64", feature = "storage-f32")))]
+                {
+                    $crate::internal::compare_quantity_parts(
+                        self.multiplier,
+                        self.power,
+                        other.multiplier,
+                        other.power,
+                    )
+                }
+                #[cfg(any(feature = "storage-f64", feature = "storage-f32"))]
+                {
+                    self.as_f64().partial_cmp(&other.as_f64())
+                }
             }
         }
 
@@ -646,11 +653,16 @@ macro_rules! impl_quantity {
             fn add(self, other: Self) -> Self {
                 #[cfg(not(any(feature = "storage-f64", feature = "storage-f32")))]
                 {
+                    // Align to the larger power: its multiplier stays exact and the smaller
+                    // operand can only underflow, never overflow.
                     let common_power = self.power.max(other.power);
-                    let multiplier = self.multiplier
-                        * $crate::internal::pow10_delta(self.power, common_power)
-                        + other.multiplier
-                            * $crate::internal::pow10_delta(other.power, common_power);
+                    let multiplier = $crate::internal::mul_pow10(
+                        self.multiplier,
+                        $crate::internal::saturating_power_sub(self.power, common_power),
+                    ) + $crate::internal::mul_pow10(
+                        other.multiplier,
+                        $crate::internal::saturating_power_sub(other.power, common_power),
+                    );
                     Self::from_parts(multiplier, common_power)
                 }
                 #[cfg(any(feature = "storage-f64", feature = "storage-f32"))]
@@ -666,20 +678,8 @@ macro_rules! impl_quantity {
             fn sub(self, other: Self) -> Self {
                 #[cfg(not(any(feature = "storage-f64", feature = "storage-f32")))]
                 {
-                    if self.multiplier.is_infinite()
-                        && other.multiplier.is_infinite()
-                        && self.multiplier.is_sign_positive() == other.multiplier.is_sign_positive()
-                    {
-                        return Self::zero();
-                    }
-
-                    let common_power = $crate::internal::average_power(self.power, other.power);
-                    let multiplier = self.multiplier
-                        * $crate::internal::pow10_delta(self.power, common_power)
-                        - other.multiplier
-                            * $crate::internal::pow10_delta(other.power, common_power);
-
-                    Self::from_parts(multiplier, common_power)
+                    // Negation is exact, so this rounds exactly like a direct subtraction.
+                    self + (-other)
                 }
                 #[cfg(any(feature = "storage-f64", feature = "storage-f32"))]
                 {
@@ -762,45 +762,13 @@ macro_rules! impl_quantity {
 
         impl AddAssign for $type {
             fn add_assign(&mut self, other: Self) {
-                #[cfg(not(any(feature = "storage-f64", feature = "storage-f32")))]
-                {
-                    let common_power = $crate::internal::average_power(self.power, other.power);
-                    let multiplier = self.multiplier
-                        * $crate::internal::pow10_delta(self.power, common_power)
-                        + other.multiplier
-                            * $crate::internal::pow10_delta(other.power, common_power);
-                    *self = Self::from_parts(multiplier, common_power);
-                }
-                #[cfg(any(feature = "storage-f64", feature = "storage-f32"))]
-                {
-                    *self = Self::from_base_value(self.as_f64() + other.as_f64());
-                }
+                *self = *self + other;
             }
         }
 
         impl SubAssign for $type {
             fn sub_assign(&mut self, other: Self) {
-                #[cfg(not(any(feature = "storage-f64", feature = "storage-f32")))]
-                {
-                    if self.multiplier.is_infinite()
-                        && other.multiplier.is_infinite()
-                        && self.multiplier.is_sign_positive() == other.multiplier.is_sign_positive()
-                    {
-                        *self = Self::zero();
-                        return;
-                    }
-
-                    let common_power = $crate::internal::average_power(self.power, other.power);
-                    let multiplier = self.multiplier
-                        * $crate::internal::pow10_delta(self.power, common_power)
-                        - other.multiplier
-                            * $crate::internal::pow10_delta(other.power, common_power);
-                    *self = Self::from_parts(multiplier, common_power);
-                }
-                #[cfg(any(feature = "storage-f64", feature = "storage-f32"))]
-                {
-                    *self = Self::from_base_value(self.as_f64() - other.as_f64());
-                }
+                *self = *self - other;
             }
         }
 
@@ -966,12 +934,15 @@ macro_rules! impl_quantity {
             }
 
             fn close_abs(&self, other: PyRef<Self>, threshold: Self) -> bool {
-                (self.clone() - other.clone()).abs() <= threshold
+                self.is_close(&other, &threshold)
             }
 
             fn close_rel(&self, other: PyRef<Self>, threshold: f64) -> bool {
-                let mean = (self.clone() + other.clone()) / 2.;
-                (self.clone() - other.clone()).abs() <= mean * threshold
+                if self.same_value(&other) {
+                    return true;
+                }
+                let mean = (*self + *other) / 2.;
+                (*self - *other).abs() <= mean.abs() * threshold
             }
 
             fn __richcmp__(&self, other: PyRef<Self>, op: CompareOp) -> bool {
@@ -1021,74 +992,36 @@ macro_rules! impl_quantity {
                 self.kind_id
             }
 
+            /// The unit in which this value's magnitude is closest to one, i.e. the one that
+            /// minimizes `|log10(|self.to(unit)|)|`. Zero and non-finite values have no
+            /// meaningful magnitude; for them the unit whose own size is closest to the base
+            /// unit wins. `None` only if `choices` is empty.
             pub fn optimal_unit<I>(&self, choices: I) -> Option<$unit>
             where
                 I: IntoIterator<Item = $unit>,
             {
-                #[cfg(not(any(feature = "storage-f64", feature = "storage-f32")))]
-                {
-                    let mut min_value = i64::MAX;
-                    let mut best_unit = None;
-                    for unit in choices {
-                        let difference =
-                            (i64::from(self.power) - i64::from(unit.base_per_x().1)).abs();
-                        if difference < min_value {
-                            min_value = difference;
-                            best_unit = Some(unit);
-                        }
-                    }
-                    best_unit
-                }
-                #[cfg(all(
-                    feature = "no_std",
-                    any(feature = "storage-f64", feature = "storage-f32")
-                ))]
-                {
-                    let mut min_value = f64::INFINITY;
-                    let mut best_unit = None;
-                    for unit in choices {
-                        let (unit_multiplier, unit_power) = unit.base_per_x();
-                        let unit_scale =
-                            $crate::internal::quantity_parts_to_value(unit_multiplier, unit_power);
-                        let converted = (self.as_f64() / unit_scale).abs();
-                        let difference = if converted == 0.0 {
-                            f64::INFINITY
-                        } else if converted < 1.0 {
-                            1.0 / converted
-                        } else {
-                            converted
-                        };
-                        if difference < min_value {
-                            min_value = difference;
-                            best_unit = Some(unit);
-                        }
-                    }
-                    best_unit
-                }
-                #[cfg(all(
-                    not(feature = "no_std"),
-                    any(feature = "storage-f64", feature = "storage-f32")
-                ))]
-                {
-                    let mut min_value = f64::INFINITY;
-                    let mut best_unit = None;
-                    for unit in choices {
+                let value = self.as_f64();
+                let has_magnitude = value.is_finite() && value != 0.0;
+                let mut best: Option<($unit, f64)> = None;
+                for unit in choices {
+                    let magnitude = if has_magnitude {
+                        self.to(unit).abs()
+                    } else {
                         let (unit_multiplier, unit_power) = unit.base_per_x();
-                        let unit_scale =
-                            $crate::internal::quantity_parts_to_value(unit_multiplier, unit_power);
-                        let converted = (self.as_f64() / unit_scale).abs();
-                        let difference = if converted == 0.0 {
-                            f64::INFINITY
-                        } else {
-                            converted.log10().abs()
-                        };
-                        if difference < min_value {
-                            min_value = difference;
-                            best_unit = Some(unit);
-                        }
+                        $crate::internal::quantity_parts_to_value(unit_multiplier, unit_power).abs()
+                    };
+                    // max(m, 1/m) orders like |log10(m)| without needing a logarithm.
+                    let difference = if magnitude.is_finite() && magnitude > 0.0 {
+                        magnitude.max(1.0 / magnitude)
+                    } else {
+                        f64::INFINITY
+                    };
+                    match best {
+                        Some((_, best_difference)) if difference >= best_difference => {}
+                        _ => best = Some((unit, difference)),
                     }
-                    best_unit
                 }
+                best.map(|(unit, _)| unit)
             }
         }
     };
@@ -1158,8 +1091,10 @@ macro_rules! impl_div_with_self_to_f64 {
             fn div(self, rhs: Self) -> Self::Output {
                 #[cfg(not(any(feature = "storage-f64", feature = "storage-f32")))]
                 {
-                    (self.multiplier / rhs.multiplier)
-                        * $crate::internal::pow10_delta(self.power, rhs.power)
+                    $crate::internal::quantity_parts_to_value(
+                        self.multiplier / rhs.multiplier,
+                        $crate::internal::saturating_power_sub(self.power, rhs.power),
+                    )
                 }
                 #[cfg(any(feature = "storage-f64", feature = "storage-f32"))]
                 {
@@ -1238,7 +1173,13 @@ macro_rules! impl_mul {
         impl MulArray1<$rhs> for Array1<$lhs> {
             type Output = Array1<$result>;
 
+            #[track_caller]
             fn mul_array1(self, rhs: Array1<$rhs>) -> Array1<$result> {
+                assert_eq!(
+                    self.len(),
+                    rhs.len(),
+                    "mul_array1: operands must have the same length"
+                );
                 self.into_iter()
                     .zip(rhs.into_iter())
                     .map(|(force, distance)| force * distance)
@@ -1296,7 +1237,13 @@ macro_rules! impl_mul {
         impl MulArray1<$lhs> for Array1<$rhs> {
             type Output = Array1<$result>;
 
+            #[track_caller]
             fn mul_array1(self, rhs: Array1<$lhs>) -> Array1<$result> {
+                assert_eq!(
+                    self.len(),
+                    rhs.len(),
+                    "mul_array1: operands must have the same length"
+                );
                 self.into_iter()
                     .zip(rhs.into_iter())
                     .map(|(force, distance)| force * distance)
@@ -1377,7 +1324,13 @@ macro_rules! impl_mul_with_self {
         impl MulArray1<$lhs> for Array1<$lhs> {
             type Output = Array1<$result>;
 
+            #[track_caller]
             fn mul_array1(self, rhs: Array1<$lhs>) -> Array1<$result> {
+                assert_eq!(
+                    self.len(),
+                    rhs.len(),
+                    "mul_array1: operands must have the same length"
+                );
                 self.into_iter()
                     .zip(rhs.into_iter())
                     .map(|(force, distance)| force * distance)
@@ -1485,7 +1438,13 @@ macro_rules! impl_div {
         impl DivArray1<$rhs> for Array1<$lhs> {
             type Output = Array1<$result>;
 
+            #[track_caller]
             fn div_array1(self, rhs: Array1<$rhs>) -> Array1<$result> {
+                assert_eq!(
+                    self.len(),
+                    rhs.len(),
+                    "div_array1: operands must have the same length"
+                );
                 self.into_iter()
                     .zip(rhs.into_iter())
                     .map(|(force, distance)| force / distance)