update

core/src/ops/absmod.rs

@@ -59,51 +59,6 @@ where
 use core::ops::{Add, Rem};
 use num::traits::{Num, Signed};
 
-pub trait Floor {
-    type Output;
-
-    fn floor(self) -> Self::Output;
-}
-
-pub trait FloorDiv<Rhs = Self> {
-    type Output;
-
-    fn floor_div(self, rhs: Rhs) -> Self::Output;
-}
-
-macro_rules! impl_floor_div {
-    (@float $t:ty) => {
-        impl<T, O> FloorDiv<T> for $t where $t: ::core::ops::Div<T, Output = O> {
-            type Output = O;
-
-            fn floor_div(self, rhs: T) -> Self::Output {
-                (self / rhs).floor()
-            }
-        }
-    };
-    (@impl f32) => {
-        impl_floor_div!(@float f32);
-    };
-    (@impl f64) => {
-        impl_floor_div!(@float f64);
-    };
-    (@impl $t:ty) => {
-        impl<T, O> FloorDiv<T> for $t where $t: ::core::ops::Div<T, Output = O> {
-            type Output = O;
-
-            fn floor_div(self, rhs: T) -> Self::Output {
-                self / rhs
-            }
-        }
-    };
-    ($($t:ty),*) => {
-        $(
-            impl_floor_div!(@impl $t);
-        )*
-    };
-}
-
-impl_floor_div!(u8, u16, u32, u64, u128, usize, i8, i16, i32, i64, i128, isize, f32, f64);
 
 impl<T> PyMod<T> for T
 where

core/src/ops/arith.rs

@@ -0,0 +1,84 @@
+/*
+    Appellation: arith <module>
+    Contrib: FL03 <jo3mccain@icloud.com>
+*/
+
+pub trait Floor {
+    type Output;
+
+    fn floor(self) -> Self::Output;
+}
+
+pub trait FloorDiv<Rhs = Self> {
+    type Output;
+
+    fn floor_div(self, rhs: Rhs) -> Self::Output;
+}
+
+
+macro_rules! impl_floor {
+    (@base $t:ty) => {
+        impl Floor for $t {
+            type Output = $t;
+
+            fn floor(self) -> Self::Output {
+                <$t>::floor(self)
+            }
+        }
+    };
+    (@impl f32) => {
+        impl_floor!(@base f32);
+    };
+    (@impl f64) => {
+        impl_floor!(@base f64);
+    };
+    (@impl $t:ty) => {
+        impl Floor for $t {
+            type Output = $t;
+
+            fn floor(self) -> Self::Output {
+                self
+            }
+        }
+    };
+    ($($t:ty),*) => {
+        $(
+            impl_floor!(@impl $t);
+        )*
+    };
+}
+
+macro_rules! impl_floor_div {
+    (@float $t:ty) => {
+        impl<T, O> FloorDiv<T> for $t where $t: ::core::ops::Div<T, Output = O> {
+            type Output = O;
+
+            fn floor_div(self, rhs: T) -> Self::Output {
+                (self / rhs).floor()
+            }
+        }
+    };
+    (@impl f32) => {
+        impl_floor_div!(@float f32);
+    };
+    (@impl f64) => {
+        impl_floor_div!(@float f64);
+    };
+    (@impl $t:ty) => {
+        impl<T, O> FloorDiv<T> for $t where $t: ::core::ops::Div<T, Output = O> {
+            type Output = O;
+
+            fn floor_div(self, rhs: T) -> Self::Output {
+                self / rhs
+            }
+        }
+    };
+    ($($t:ty),*) => {
+        $(
+            impl_floor_div!(@impl $t);
+        )*
+    };
+}
+
+impl_floor!(u8, u16, u32, u64, u128, usize, i8, i16, i32, i64, i128, isize, f32, f64);
+impl_floor_div!(u8, u16, u32, u64, u128, usize, i8, i16, i32, i64, i128, isize, f32, f64);

core/src/ops/mod.rs

@@ -6,9 +6,11 @@
 pub use self::prelude::*;
 
 pub mod absmod;
+pub mod arith;
 pub mod distance;
 
 pub(crate) mod prelude {
     pub use super::absmod::*;
+    pub use super::arith::*;
     pub use super::distance::*;
 }

core/src/pitch/impls/pitch_ops.rs

@@ -2,7 +2,7 @@
     Appellation: pitch_ops <impl>
     Contrib: FL03 <jo3mccain@icloud.com>
 */
-use crate::{Pitch, PitchMod, PitchTy};
+use crate::{Pitch, PitchMod, PitchTy, PyMod};
 use num::{Num, One, Zero};
 
 macro_rules! impl_interval_method {
@@ -33,7 +33,7 @@ impl PitchMod for Pitch {
     type Output = Self;
 
     fn pitchmod(&self) -> Self::Output {
-        Self(self.0.pitchmod())
+        Self(self.0.pymod(Self::MOD))
     }
 }
 

core/src/pitch/pitch.rs

@@ -3,7 +3,7 @@
     Contrib: FL03 <jo3mccain@icloud.com>
 */
 use super::{PitchTy, Pitches};
-use crate::PitchMod;
+use crate::PyMod;
 
 /// A [pitch](Pitch) is a discrete tone with an individual frequency that may be
 /// classified as a [pitch class](Pitches).
@@ -13,12 +13,15 @@ use crate::PitchMod;
 pub struct Pitch(pub(crate) PitchTy);
 
 impl Pitch {
+    const MOD: PitchTy = crate::MODULUS;
+
     pub fn new(pitch: impl Into<PitchTy>) -> Self {
-        Self(pitch.into().pitchmod())
+        let val: PitchTy = pitch.into();
+        Self(val.pymod(Self::MOD))
     }
     /// Returns the absolute value of the remainder of the pitch divided by the modulus.
     pub fn abs(&self) -> Self {
-        self.pitchmod()
+        Self(self.0.pymod(Self::MOD).abs())
     }
     /// Returns a new instance of the class representing the given pitch.
     pub fn class(&self) -> Pitches {