feat: impl Add and Sub for all "input" newtypes.

demes/src/cloning_rate.rs

@@ -33,16 +33,23 @@ impl TryFrom<f64> for CloningRate {
 impl_newtype_traits!(CloningRate);
 
 /// Input value for [`CloningRate`], used when loading or building graphs.
+///
+/// # Examples
+///
+/// ```
+/// let t = demes::InputCloningRate::from(1.0);
+/// assert_eq!(t, 1.0);
+/// let t = t - 1.0;
+/// assert_eq!(t, 0.0);
+/// let t = 1.0 + t;
+/// assert_eq!(t, 1.0);
+/// ```
 #[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq, PartialOrd)]
 #[repr(transparent)]
 #[serde(from = "f64")]
 pub struct InputCloningRate(f64);
 
-impl From<f64> for InputCloningRate {
-    fn from(value: f64) -> Self {
-        Self(value)
-    }
-}
+impl_input_newtype_traits!(InputCloningRate);
 
 impl TryFrom<InputCloningRate> for CloningRate {
     type Error = DemesError;

demes/src/deme_size.rs

@@ -68,16 +68,23 @@ impl TryFrom<f64> for DemeSize {
 impl_newtype_traits!(DemeSize);
 
 /// Input value for [`DemeSize`], used when loading or building graphs.
+///
+/// # Examples
+///
+/// ```
+/// let t = demes::InputDemeSize::from(1.0);
+/// assert_eq!(t, 1.0);
+/// let t = t - 1.0;
+/// assert_eq!(t, 0.0);
+/// let t = 1.0 + t;
+/// assert_eq!(t, 1.0);
+/// ```
 #[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq, PartialOrd)]
 #[repr(transparent)]
 #[serde(from = "f64")]
 pub struct InputDemeSize(f64);
 
-impl From<f64> for InputDemeSize {
-    fn from(value: f64) -> Self {
-        Self(value)
-    }
-}
+impl_input_newtype_traits!(InputDemeSize);
 
 impl TryFrom<InputDemeSize> for DemeSize {
     type Error = DemesError;
@@ -88,9 +95,3 @@ impl TryFrom<InputDemeSize> for DemeSize {
         Ok(rv)
     }
 }
-
-impl From<InputDemeSize> for f64 {
-    fn from(value: InputDemeSize) -> Self {
-        value.0
-    }
-}

demes/src/macros.rs

@@ -62,3 +62,61 @@ macro_rules! impl_newtype_traits {
         }
     };
 }
+
+macro_rules! impl_input_newtype_arithmetic {
+    ($type: ty, $op: ident, $fn: ident) => {
+        impl std::ops::$op for $type {
+            type Output = Self;
+            fn $fn(self, value: Self) -> Self::Output {
+                self.0.$fn(value.0).into()
+            }
+        }
+
+        impl std::ops::$op<f64> for $type {
+            type Output = Self;
+            fn $fn(self, value: f64) -> Self::Output {
+                self.0.$fn(value).into()
+            }
+        }
+
+        impl std::ops::$op<$type> for f64 {
+            type Output = Self;
+            fn $fn(self, value: $type) -> Self::Output {
+                self.$fn(value.0).into()
+            }
+        }
+    };
+}
+
+macro_rules! impl_input_newtype_traits {
+    ($type: ty) => {
+        impl From<f64> for $type {
+            fn from(value: f64) -> Self {
+                Self(value)
+            }
+        }
+
+        impl From<$type> for f64 {
+            fn from(value: $type) -> Self {
+                value.0
+            }
+        }
+
+        impl PartialEq<$type> for f64 {
+            fn eq(&self, other: &$type) -> bool {
+                self.eq(&other.0)
+            }
+        }
+
+        impl PartialEq<f64> for $type {
+            fn eq(&self, other: &f64) -> bool {
+                self.0.eq(other)
+            }
+        }
+
+        impl_input_newtype_arithmetic!($type, Add, add);
+        impl_input_newtype_arithmetic!($type, Sub, sub);
+        impl_input_newtype_arithmetic!($type, Mul, mul);
+        impl_input_newtype_arithmetic!($type, Div, div);
+    };
+}

demes/src/migration_rate.rs

@@ -24,16 +24,21 @@ impl TryFrom<f64> for MigrationRate {
 /// ## Using [`GraphBuilder`](crate::GraphBuilder)
 ///
 /// * [`GraphBuilder::migration`](crate::GraphBuilder::add_migration)
+///
+/// ```
+/// let t = demes::InputMigrationRate::from(0.1);
+/// assert_eq!(t, 0.1);
+/// let t = t - 1.0;
+/// assert_eq!(t, 0.1 - 1.0);
+/// let t = 1.0 + t;
+/// assert_eq!(t, 0.1 - 1.0 + 1.0);
+/// ```
 #[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq)]
 #[repr(transparent)]
 #[serde(from = "f64")]
 pub struct InputMigrationRate(f64);
 
-impl From<f64> for InputMigrationRate {
-    fn from(value: f64) -> Self {
-        Self(value)
-    }
-}
+impl_input_newtype_traits!(InputMigrationRate);
 
 impl TryFrom<InputMigrationRate> for MigrationRate {
     type Error = DemesError;

demes/src/proportion.rs

@@ -106,22 +106,23 @@ impl TryFrom<f64> for Proportion {
 impl_newtype_traits!(Proportion);
 
 /// Input value for [`Proportion`], used when loading or building graphs.
+///
+/// # Examples
+///
+/// ```
+/// let t = demes::InputProportion::from(1.0);
+/// assert_eq!(t, 1.0);
+/// let t = t - 1.0;
+/// assert_eq!(t, 0.0);
+/// let t = 1.0 + t;
+/// assert_eq!(t, 1.0);
+/// ```
 #[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq, PartialOrd)]
 #[repr(transparent)]
 #[serde(from = "f64")]
 pub struct InputProportion(f64);
 
-impl From<f64> for InputProportion {
-    fn from(value: f64) -> Self {
-        Self(value)
-    }
-}
-
-impl From<InputProportion> for f64 {
-    fn from(value: InputProportion) -> Self {
-        value.0
-    }
-}
+impl_input_newtype_traits!(InputProportion);
 
 impl TryFrom<InputProportion> for Proportion {
     type Error = DemesError;

demes/src/selfing_rate.rs

@@ -33,16 +33,23 @@ impl TryFrom<f64> for SelfingRate {
 }
 
 /// Input value for [`SelfingRate`], used when loading or building graphs.
+///
+/// # Examples
+///
+/// ```
+/// let t = demes::InputSelfingRate::from(1.0);
+/// assert_eq!(t, 1.0);
+/// let t = t - 1.0;
+/// assert_eq!(t, 0.0);
+/// let t = 1.0 + t;
+/// assert_eq!(t, 1.0);
+/// ```
 #[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq, PartialOrd)]
 #[repr(transparent)]
 #[serde(from = "f64")]
 pub struct InputSelfingRate(f64);
 
-impl From<f64> for InputSelfingRate {
-    fn from(value: f64) -> Self {
-        Self(value)
-    }
-}
+impl_input_newtype_traits!(InputSelfingRate);
 
 impl TryFrom<InputSelfingRate> for SelfingRate {
     type Error = DemesError;

demes/src/time.rs

@@ -80,6 +80,17 @@ impl TryFrom<f64> for Time {
 }
 
 /// Input value for [`Time`], used when loading or building graphs.
+///
+/// # Examples
+///
+/// ```
+/// let t = demes::InputTime::from(1.0);
+/// assert_eq!(t, 1.0);
+/// let t = t - 1.0;
+/// assert_eq!(t, 0.0);
+/// let t = 1.0 + t;
+/// assert_eq!(t, 1.0);
+/// ```
 #[derive(Clone, Copy, Debug, Deserialize, PartialEq, PartialOrd)]
 #[repr(transparent)]
 #[serde(try_from = "TimeTrampoline")]
@@ -117,17 +128,7 @@ impl InputTime {
     }
 }
 
-impl From<f64> for InputTime {
-    fn from(value: f64) -> Self {
-        Self(value)
-    }
-}
-
-impl From<InputTime> for f64 {
-    fn from(value: InputTime) -> Self {
-        value.0
-    }
-}
+impl_input_newtype_traits!(InputTime);
 
 impl TryFrom<InputTime> for Time {
     type Error = DemesError;