unitforge 0.3.17__tar.gz → 0.3.18__tar.gz

{unitforge-0.3.17 → unitforge-0.3.18}/Cargo.lock

@@ -369,7 +369,7 @@ checksum = "7264e107f553ccae879d21fbea1d6724ac785e8c3bfc762137959b5802826ef3"
 
 [[package]]
 name = "unitforge"
-version = "0.3.17"
+version = "0.3.18"
 dependencies = [
  "ndarray",
  "num-traits",

{unitforge-0.3.17 → unitforge-0.3.18}/Cargo.toml

@@ -4,7 +4,7 @@ crate-type = ["cdylib", "rlib"]
 
 [package]
 name = "unitforge"
-version = "0.3.17"
+version = "0.3.18"
 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"

{unitforge-0.3.17 → unitforge-0.3.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: unitforge
-Version: 0.3.17
+Version: 0.3.18
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Rust
 Classifier: License :: OSI Approved :: MIT License

{unitforge-0.3.17 → unitforge-0.3.18}/src/impl_macros.rs

@@ -44,6 +44,9 @@ macro_rules! impl_quantity {
 
         impl PhysicsQuantity for $type {
             fn as_f64(&self) -> f64 {
+                if self.multiplier.abs() < f64::EPSILON {
+                    return 0.0;
+                }
                 self.multiplier * 10_f64.powi(self.power)
             }
 
@@ -67,7 +70,7 @@ macro_rules! impl_quantity {
                 let (multiplier, power) = Self::split_value(value);
                 let r = $type {
                     multiplier: multiplier * unit_multiplier,
-                    power: power + unit_power,
+                    power: $crate::internal::saturating_power_add(power, unit_power),
                 };
                 r
             }
@@ -89,6 +92,9 @@ macro_rules! impl_quantity {
             }
 
             fn get_value(&self) -> f64 {
+                if self.multiplier.abs() < f64::EPSILON {
+                    return 0.0;
+                }
                 self.multiplier * 10_f64.powi(self.power)
             }
 
@@ -105,8 +111,12 @@ macro_rules! impl_quantity {
             }
 
             fn to(&self, unit: Self::Unit) -> f64 {
+                if self.multiplier.abs() < f64::EPSILON {
+                    return 0.0;
+                }
                 let (unit_multiplier, unit_power) = unit.base_per_x();
-                self.multiplier / unit_multiplier * 10_f64.powi(self.power - unit_power)
+                self.multiplier / unit_multiplier
+                    * $crate::internal::pow10_delta(self.power, unit_power)
             }
 
             fn abs(self) -> Self {
@@ -140,6 +150,9 @@ macro_rules! impl_quantity {
             }
 
             fn from_exponential(multiplier: f64, power: i32) -> Self {
+                if multiplier.abs() < f64::EPSILON {
+                    return Self::zero();
+                }
                 Self { multiplier, power }
             }
 
@@ -165,11 +178,14 @@ macro_rules! impl_quantity {
 
             fn optimize(&mut self) {
                 if self.multiplier.abs() < f64::EPSILON {
+                    self.multiplier = 0.0;
+                    self.power = 0;
                     return;
                 }
                 let power_on_multiplier = self.multiplier.abs().log10().round() as i32;
                 self.multiplier /= 10_f64.powi(power_on_multiplier);
-                self.power += power_on_multiplier;
+                self.power =
+                    $crate::internal::saturating_power_add(self.power, power_on_multiplier);
             }
 
             const INFINITY: Self = Self {
@@ -300,7 +316,7 @@ macro_rules! impl_quantity {
                     other,
                     &Self {
                         multiplier: self.multiplier,
-                        power: self.power.clone() - 9,
+                        power: $crate::internal::saturating_power_sub(self.power, 9),
                     },
                 )
             }
@@ -334,8 +350,9 @@ macro_rules! impl_quantity {
 
             fn add(self, other: Self) -> Self {
                 let common_power = self.power.max(other.power);
-                let multiplier = self.multiplier * 10_f64.powi(self.power - common_power)
-                    + other.multiplier * 10_f64.powi(other.power - common_power);
+                let multiplier = self.multiplier
+                    * $crate::internal::pow10_delta(self.power, common_power)
+                    + other.multiplier * $crate::internal::pow10_delta(other.power, common_power);
                 let mut res = Self {
                     multiplier,
                     power: common_power,
@@ -349,9 +366,10 @@ macro_rules! impl_quantity {
             type Output = Self;
 
             fn sub(self, other: Self) -> Self {
-                let common_power = (self.power + other.power) / 2;
-                let multiplier = self.multiplier * 10_f64.powi(self.power - common_power)
-                    - other.multiplier * 10_f64.powi(other.power - common_power);
+                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);
 
                 let mut res = Self {
                     multiplier,
@@ -369,7 +387,7 @@ macro_rules! impl_quantity {
                 let (rhs_multiplier, rhs_power) = Self::split_value(rhs);
                 Self {
                     multiplier: self.multiplier / rhs_multiplier,
-                    power: self.power - rhs_power,
+                    power: $crate::internal::saturating_power_sub(self.power, rhs_power),
                 }
             }
         }
@@ -381,7 +399,7 @@ macro_rules! impl_quantity {
                 let (rhs_multiplier, rhs_power) = Self::split_value(rhs);
                 Self {
                     multiplier: self.multiplier * rhs_multiplier,
-                    power: self.power + rhs_power,
+                    power: $crate::internal::saturating_power_add(self.power, rhs_power),
                 }
             }
         }
@@ -396,9 +414,10 @@ macro_rules! impl_quantity {
 
         impl AddAssign for $type {
             fn add_assign(&mut self, other: Self) {
-                let common_power = (self.power + other.power) / 2;
-                self.multiplier = self.multiplier * 10_f64.powi(self.power - common_power)
-                    + other.multiplier * 10_f64.powi(other.power - common_power);
+                let common_power = $crate::internal::average_power(self.power, other.power);
+                self.multiplier = self.multiplier
+                    * $crate::internal::pow10_delta(self.power, common_power)
+                    + other.multiplier * $crate::internal::pow10_delta(other.power, common_power);
                 self.power = common_power;
                 self.optimize();
             }
@@ -406,9 +425,10 @@ macro_rules! impl_quantity {
 
         impl SubAssign for $type {
             fn sub_assign(&mut self, other: Self) {
-                let common_power = (self.power + other.power) / 2;
-                self.multiplier = self.multiplier * 10_f64.powi(self.power - common_power)
-                    - other.multiplier * 10_f64.powi(other.power - common_power);
+                let common_power = $crate::internal::average_power(self.power, other.power);
+                self.multiplier = self.multiplier
+                    * $crate::internal::pow10_delta(self.power, common_power)
+                    - other.multiplier * $crate::internal::pow10_delta(other.power, common_power);
                 self.power = common_power;
                 self.optimize();
             }
@@ -418,7 +438,7 @@ macro_rules! impl_quantity {
             fn mul_assign(&mut self, rhs: f64) {
                 let (rhs_multiplier, rhs_power) = Self::split_value(rhs);
                 self.multiplier *= rhs_multiplier;
-                self.power += rhs_power;
+                self.power = $crate::internal::saturating_power_add(self.power, rhs_power);
             }
         }
 
@@ -426,7 +446,7 @@ macro_rules! impl_quantity {
             fn div_assign(&mut self, rhs: f64) {
                 let (rhs_multiplier, rhs_power) = Self::split_value(rhs);
                 self.multiplier /= rhs_multiplier;
-                self.power -= rhs_power;
+                self.power = $crate::internal::saturating_power_sub(self.power, rhs_power);
             }
         }
 
@@ -594,10 +614,10 @@ macro_rules! impl_quantity {
 
         impl $type {
             pub fn optimal_unit(&self, choices: HashSet<$unit>) -> Option<$unit> {
-                let mut min_value = i32::MAX;
+                let mut min_value = i64::MAX;
                 let mut best_unit = None;
                 for unit in choices {
-                    let difference = (self.power - unit.base_per_x().1).abs();
+                    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);
@@ -650,7 +670,8 @@ macro_rules! impl_div_with_self_to_f64 {
             type Output = f64;
 
             fn div(self, rhs: Self) -> Self::Output {
-                (self.multiplier / rhs.multiplier) * 10_f64.powi(self.power - rhs.power)
+                (self.multiplier / rhs.multiplier)
+                    * $crate::internal::pow10_delta(self.power, rhs.power)
             }
         }
     };
@@ -665,7 +686,7 @@ macro_rules! impl_mul {
             fn mul(self, rhs: $rhs) -> Self::Output {
                 <$result>::from_exponential(
                     self.multiplier * rhs.multiplier,
-                    self.power + rhs.power,
+                    $crate::internal::saturating_power_add(self.power, rhs.power),
                 )
             }
         }
@@ -676,7 +697,7 @@ macro_rules! impl_mul {
             fn mul(self, rhs: $lhs) -> Self::Output {
                 <$result>::from_exponential(
                     self.multiplier * rhs.multiplier,
-                    self.power + rhs.power,
+                    $crate::internal::saturating_power_add(self.power, rhs.power),
                 )
             }
         }
@@ -774,7 +795,7 @@ macro_rules! impl_mul_with_self {
             fn mul(self, rhs: $lhs) -> Self::Output {
                 <$result>::from_exponential(
                     self.multiplier * rhs.multiplier,
-                    self.power + rhs.power,
+                    $crate::internal::saturating_power_add(self.power, rhs.power),
                 )
             }
         }
@@ -831,7 +852,7 @@ macro_rules! impl_div {
             fn div(self, rhs: $rhs) -> Self::Output {
                 <$result>::from_exponential(
                     self.multiplier / rhs.multiplier,
-                    self.power - rhs.power,
+                    $crate::internal::saturating_power_sub(self.power, rhs.power),
                 )
             }
         }
@@ -889,7 +910,7 @@ macro_rules! impl_sqrt {
                 } else {
                     <$res>::from_exponential(
                         self.multiplier.sqrt() * 10_f64.sqrt(),
-                        (self.power - 1) / 2,
+                        $crate::internal::saturating_power_sub(self.power, 1) / 2,
                     )
                 }
             }

unitforge-0.3.18/src/internal.rs

@@ -0,0 +1,16 @@
+pub fn saturating_power_add(lhs: i32, rhs: i32) -> i32 {
+    lhs.saturating_add(rhs)
+}
+
+pub fn saturating_power_sub(lhs: i32, rhs: i32) -> i32 {
+    lhs.saturating_sub(rhs)
+}
+
+pub fn average_power(lhs: i32, rhs: i32) -> i32 {
+    let average = (i64::from(lhs) + i64::from(rhs)) / 2;
+    average.clamp(i64::from(i32::MIN), i64::from(i32::MAX)) as i32
+}
+
+pub fn pow10_delta(lhs: i32, rhs: i32) -> f64 {
+    10_f64.powi(saturating_power_sub(lhs, rhs))
+}

{unitforge-0.3.17 → unitforge-0.3.18}/src/lib.rs

@@ -2,6 +2,7 @@
 pub mod impl_macros;
 pub use impl_macros::*;
 
+mod internal;
 pub mod prelude;
 mod relations;
 

{unitforge-0.3.17 → unitforge-0.3.18}/src/prelude.rs

@@ -252,7 +252,11 @@ impl PhysicsQuantity for f64 {
     }
 
     fn from_exponential(multiplier: f64, power: i32) -> Self {
-        multiplier * 10_f64.powi(power)
+        if multiplier.abs() < f64::EPSILON {
+            0.0
+        } else {
+            multiplier * 10_f64.powi(power)
+        }
     }
 
     fn min(self, other: Self) -> Self {

{unitforge-0.3.17 → unitforge-0.3.18}/src/small_linalg/matrix3.rs

@@ -405,7 +405,10 @@ where
     R: PhysicsQuantity,
 {
     pub fn inverse(&self) -> Option<Matrix3<R>> {
-        let det = self.det(); // det is of type V
+        let det = self.det();
+        if det.is_nan() || det.as_f64().abs() < f64::EPSILON {
+            return None;
+        }
 
         let a = self[(0, 0)];
         let b = self[(0, 1)];
@@ -435,18 +438,7 @@ where
             ],
         ];
 
-        if (inv[0][0]
-            + inv[0][1]
-            + inv[0][2]
-            + inv[1][0]
-            + inv[1][1]
-            + inv[1][2]
-            + inv[2][0]
-            + inv[2][1]
-            + inv[2][2])
-            .as_f64()
-            .is_nan()
-        {
+        if inv.iter().flatten().any(|entry| entry.is_nan()) {
             None
         } else {
             Some(Matrix3::new(inv))

{unitforge-0.3.17 → unitforge-0.3.18}/tests/matrix3.rs

@@ -90,6 +90,18 @@ mod matrix3_tests {
         assert!(diff.get_power() < -12);
     }
 
+    #[test]
+    fn test_inverse_singular_large_exponents_returns_none() {
+        let huge = Distance::from_exponential(1.0, i32::MAX / 2);
+        let zero = Distance::from_raw(0.0);
+        let one = Distance::from_raw(1.0);
+        let matrix: Matrix3<Distance> =
+            Matrix3::new([[one, zero, zero], [zero, huge, huge], [zero, huge, huge]]);
+
+        let inverse: Option<Matrix3<InverseDistance>> = matrix.inverse();
+        assert_eq!(inverse, None);
+    }
+
     #[test]
     fn test_dot() {
         let matrix = Matrix3::new([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]]);

{unitforge-0.3.17 → unitforge-0.3.18}/tests/quantities.rs

@@ -2,6 +2,21 @@ pub fn approx_eq(a: f64, b: f64, epsilon: f64) -> bool {
     (a - b).abs() < epsilon
 }
 
+#[cfg(test)]
+mod test_overflow_safety {
+    use unitforge::prelude::*;
+    use unitforge::quantities::{Distance, DistanceUnit};
+
+    #[test]
+    fn test_subtraction_with_large_powers_does_not_overflow() {
+        let lhs = Distance::from_exponential(1.0, i32::MAX);
+        let rhs = Distance::from_exponential(1.0, i32::MAX);
+        let diff = lhs - rhs;
+
+        assert_eq!(diff.to(DistanceUnit::m), 0.0);
+    }
+}
+
 #[cfg(test)]
 mod test_force {
     use ndarray::{arr1, arr2};