unitforge 0.4.0__tar.gz → 0.4.1__tar.gz

{unitforge-0.4.0 → unitforge-0.4.1}/Cargo.lock

@@ -369,7 +369,7 @@ checksum = "7264e107f553ccae879d21fbea1d6724ac785e8c3bfc762137959b5802826ef3"
 
 [[package]]
 name = "unitforge"
-version = "0.4.0"
+version = "0.4.1"
 dependencies = [
  "ndarray",
  "num-traits",
@@ -384,7 +384,7 @@ dependencies = [
 
 [[package]]
 name = "unitforge_macros"
-version = "0.4.0"
+version = "0.4.1"
 dependencies = [
  "regex",
 ]

{unitforge-0.4.0 → unitforge-0.4.1}/Cargo.toml

@@ -4,7 +4,7 @@ crate-type = ["cdylib", "rlib"]
 
 [package]
 name = "unitforge"
-version = "0.4.0"
+version = "0.4.1"
 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"
@@ -23,7 +23,7 @@ pyo3 = { version = "0.26.0", features = ["extension-module", "auto-initialize",
 numpy = { version = "0.26.0", optional = true }
 strum = { version = "0.28.0", optional = true }
 strum_macros = { version = "0.28.0", optional = true }
-unitforge_macros = { version = "0.4.0", path = "unitforge_macros" }
+unitforge_macros = { version = "0.4.1", path = "unitforge_macros" }
 
 [features]
 serde = ["dep:serde", "dep:serde_json", "ndarray/serde"]

{unitforge-0.4.0 → unitforge-0.4.1}/PKG-INFO

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

{unitforge-0.4.0 → unitforge-0.4.1}/src/impl_macros.rs

@@ -275,6 +275,23 @@ macro_rules! impl_quantity {
             fn __rmul__(&self, rhs: f64) -> PyResult<Self> {
                 Ok(*self * rhs)
             }
+
+            fn __pow__(
+                lhs: PyRef<Self>,
+                rhs: i32,
+                _modulo: Option<Py<PyAny>>,
+            ) -> PyResult<Py<PyAny>> {
+                let py = lhs.py();
+                let lhs_ref = lhs.into_pyobject(py)?;
+                let lhs_quantity = Quantity::from_py_any(&lhs_ref)
+                    .map_err(|e| PyValueError::new_err(e.to_string()))?;
+                match lhs_quantity.powi(rhs) {
+                    Ok(value) => Ok(value.to_pyobject(py)?),
+                    Err(_) => Err(PyValueError::new_err(
+                        "Power of given object is not possible.",
+                    )),
+                }
+            }
         }
 
         impl fmt::Display for $type {

{unitforge-0.4.0 → unitforge-0.4.1}/src/quantities.template.rs

@@ -12,6 +12,7 @@ pub enum QuantityOperationError {
     SubError,
     MulError,
     DivError,
+    PowError,
     SqrtError,
     ComparisonError,
 }
@@ -23,6 +24,7 @@ impl fmt::Display for QuantityOperationError {
             QuantityOperationError::SubError => write!(f, "Subtraction operation failed"),
             QuantityOperationError::MulError => write!(f, "Multiplication operation failed"),
             QuantityOperationError::DivError => write!(f, "Division operation failed"),
+            QuantityOperationError::PowError => write!(f, "Power operation failed"),
             QuantityOperationError::SqrtError => write!(f, "Sqrt operation failed"),
             QuantityOperationError::ComparisonError => write!(f, "Comparison operation failed"),
         }
@@ -171,6 +173,33 @@ impl Quantity {
             _=> Err(QuantityOperationError::SqrtError)
         }
     }
+
+    pub fn reciprocal(&self) -> Result<Self, QuantityOperationError> {
+        match self {
+            Quantity::FloatQuantity(v) => Ok(Self::FloatQuantity(1.0 / v)),
+            // __QUANTITY_RECIPROCALS__
+            _ => Err(QuantityOperationError::PowError),
+        }
+    }
+
+    pub fn powi(&self, exponent: i32) -> Result<Self, QuantityOperationError> {
+        if exponent == 0 {
+            return Ok(Self::FloatQuantity(1.0));
+        }
+
+        let base = if exponent < 0 {
+            self.reciprocal()?
+        } else {
+            *self
+        };
+        let mut result = base;
+
+        for _ in 1..exponent.unsigned_abs() {
+            result = (result * base).map_err(|_| QuantityOperationError::PowError)?;
+        }
+
+        Ok(result)
+    }
 }
 
 impl PartialOrd for Quantity {

{unitforge-0.4.0 → unitforge-0.4.1}/tests/quantity_core/runtime_quantity.rs

@@ -1,7 +1,8 @@
 use crate::common::approx_eq;
 use unitforge::{
-    Distance, DistanceUnit, Force, ForceDistanceUnit, ForceUnit, Mass, MassUnit, Quantity,
-    PhysicsQuantity, StiffnessUnit, Unit,
+    AreaUnit, Distance, DistanceUnit, Force, ForceDistanceUnit, ForceUnit, InverseAreaUnit,
+    InverseDistanceUnit, Mass, MassUnit, PhysicsQuantity, Quantity, StiffnessUnit, Unit,
+    VolumeUnit,
 };
 
 #[test]
@@ -168,6 +169,54 @@ fn sqrt_rejects_non_square_quantity() {
     assert!(quantity.sqrt().is_err());
 }
 
+#[test]
+fn powi_builds_higher_order_quantity_when_relations_exist() {
+    let quantity = Quantity::DistanceQuantity(Distance::new(2.0, DistanceUnit::m));
+
+    let squared = quantity.powi(2).unwrap();
+    let cubed = quantity.powi(3).unwrap();
+
+    assert!(approx_eq(
+        squared.to(Unit::AreaUnit(AreaUnit::msq)).unwrap(),
+        4.0,
+        1e-10
+    ));
+    assert!(approx_eq(
+        cubed.to(Unit::VolumeUnit(VolumeUnit::mcb)).unwrap(),
+        8.0,
+        1e-10
+    ));
+}
+
+#[test]
+fn powi_builds_inverse_quantity_when_relations_exist() {
+    let quantity = Quantity::DistanceQuantity(Distance::new(2.0, DistanceUnit::m));
+
+    let inverse = quantity.powi(-1).unwrap();
+    let inverse_squared = quantity.powi(-2).unwrap();
+
+    assert!(approx_eq(
+        inverse
+            .to(Unit::InverseDistanceUnit(InverseDistanceUnit::_m))
+            .unwrap(),
+        0.5,
+        1e-10
+    ));
+    assert!(approx_eq(
+        inverse_squared
+            .to(Unit::InverseAreaUnit(InverseAreaUnit::_msq))
+            .unwrap(),
+        0.25,
+        1e-10
+    ));
+}
+
+#[test]
+fn powi_rejects_missing_quantity_relation() {
+    let quantity = Quantity::DistanceQuantity(Distance::new(2.0, DistanceUnit::m));
+    assert!(quantity.powi(5).is_err());
+}
+
 #[test]
 fn inf_multiplication() {
     let distance = Quantity::DistanceQuantity(Distance::new(1.0, DistanceUnit::m));

{unitforge-0.4.0 → unitforge-0.4.1}/tests/test_quantities.py

@@ -31,3 +31,8 @@ def test_force_stress_from_stress_squared_times_area():
     result = stress_squared * area
     assert isinstance(result, ForceStress)
     assert result.to(ForceStressUnit.Nsq_msq) == pytest.approx(6.0)
+
+def test_power_operator():
+    a = Distance(2., DistanceUnit.mm)
+    b = a**2
+    assert b == Area(4., AreaUnit.mmsq)

{unitforge-0.4.0 → unitforge-0.4.1}/unitforge_macros/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "unitforge_macros"
-version = "0.4.0"
+version = "0.4.1"
 edition = "2021"
 authors = ["Dr.Q team <info@askdrq.com>", "Henrik Stromberg <henrik@askdrq.com>"]
 description = "Proc macros for generating units, quantities, and Python bindings in unitforge"

{unitforge-0.4.0 → unitforge-0.4.1}/unitforge_macros/src/lib.rs

@@ -339,6 +339,7 @@ fn write_quantity_code(
     let mut add_matches = String::new();
     let mut sub_matches = String::new();
     let mut sqrt_matches = String::new();
+    let mut reciprocal_matches = String::new();
     let mut quantity_kind_id_impls = String::new();
     let mut unit_kind_id_impls = String::new();
     let mut unit_variant_id_impls = String::new();
@@ -464,8 +465,15 @@ fn write_quantity_code(
         for caps in mul_macro_re.captures_iter(content) {
             let lhs = &caps[1];
             let rhs = &caps[2];
-            let mut res = caps[3].to_string();
-            if res == "f64" {
+            let raw_res = &caps[3];
+            let mut res = raw_res.to_string();
+            if raw_res == "f64" {
+                reciprocal_matches += &format!(
+                    "            Quantity::{lhs}Quantity(v) => Ok(Quantity::{rhs}Quantity(<{rhs} as crate::PhysicsQuantity>::from_raw(1.0 / v.as_f64()))),\n",
+                );
+                reciprocal_matches += &format!(
+                    "            Quantity::{rhs}Quantity(v) => Ok(Quantity::{lhs}Quantity(<{lhs} as crate::PhysicsQuantity>::from_raw(1.0 / v.as_f64()))),\n",
+                );
                 res = "Float".to_string();
             }
             mul_matches += &format!(
@@ -555,6 +563,7 @@ fn write_quantity_code(
         .replace("// __ADD_QUANTITY_MATCHES__", &add_matches)
         .replace("// __SUB_QUANTITY_MATCHES__", &sub_matches)
         .replace("// __QUANTITY_SQRTS__", &sqrt_matches)
+        .replace("// __QUANTITY_RECIPROCALS__", &reciprocal_matches)
         .replace("// __QUANTITY_KIND_ID_IMPLS__", &quantity_kind_id_impls)
         .replace("// __UNIT_KIND_ID_IMPLS__", &unit_kind_id_impls)
         .replace("// __UNIT_VARIANT_ID_IMPLS__", &unit_variant_id_impls)