Implement sub for MatZ and MatQ

Author: jnsiemer

src/integer/mat_z/arithmetic/sub.rs

@@ -14,6 +14,7 @@ use crate::integer_mod_q::MatZq;
 use crate::macros::arithmetics::{
     arithmetic_trait_borrowed_to_owned, arithmetic_trait_mixed_borrowed_owned,
 };
+use crate::rational::MatQ;
 use crate::traits::MatrixDimensions;
 use flint_sys::fmpz_mat::fmpz_mat_sub;
 use flint_sys::fmpz_mod_mat::_fmpz_mod_mat_reduce;
@@ -105,6 +106,43 @@ impl Sub<&MatZq> for &MatZ {
 arithmetic_trait_borrowed_to_owned!(Sub, sub, MatZ, MatZq, MatZq);
 arithmetic_trait_mixed_borrowed_owned!(Sub, sub, MatZ, MatZq, MatZq);
 
+impl Sub<&MatQ> for &MatZ {
+    type Output = MatQ;
+
+    /// Implements the [`Sub`] trait for two matrices.
+    /// Furthermore, it is available for any combination of [`MatZ`] and [`MatQ`].
+    ///
+    /// Parameters:
+    /// - `other`: specifies the value to subtract from `self`
+    ///
+    /// Returns the result of the subtraction as a [`MatQ`].
+    ///
+    /// # Examples
+    /// ```
+    /// use qfall_math::{rational::MatQ, integer::MatZ};
+    /// use std::str::FromStr;
+    ///
+    /// let a: MatQ = MatQ::from_str("[[1/2, 2/3, 3/4],[3/4, 4/5, 5/7]]").unwrap();
+    /// let b: MatZ = MatZ::identity(2, 3);
+    ///
+    /// let d: MatQ = &a - &b;
+    /// let e: MatQ = a.clone() - b.clone();
+    /// let f: MatQ = &a - b.clone();
+    /// let g: MatQ = a - b;
+    /// ```
+    ///
+    /// # Panics ...
+    /// - if the dimensions of both matrices mismatch.
+    fn sub(self, other: &MatQ) -> Self::Output {
+        let new_self = MatQ::from(self);
+
+        other.sub_safe(&new_self).unwrap()
+    }
+}
+
+arithmetic_trait_borrowed_to_owned!(Sub, sub, MatZ, MatQ, MatQ);
+arithmetic_trait_mixed_borrowed_owned!(Sub, sub, MatZ, MatQ, MatQ);
+
 impl MatZ {
     /// Implements subtraction for two [`MatZ`] matrices.
     ///

src/rational/mat_q/arithmetic/add.rs

@@ -122,25 +122,9 @@ impl Add<&MatZ> for &MatQ {
 
     /// Documentation at [`MatQ::add`].
     fn add(self, other: &MatZ) -> Self::Output {
-        if self.get_num_rows() != other.get_num_rows()
-            || self.get_num_columns() != other.get_num_columns()
-        {
-            panic!(
-                "Tried to add a '{}x{}' matrix and a '{}x{}' matrix.",
-                self.get_num_rows(),
-                self.get_num_columns(),
-                other.get_num_rows(),
-                other.get_num_columns()
-            );
-        }
-
         let other = MatQ::from(other);
-        let mut out = MatQ::new(self.get_num_rows(), self.get_num_columns());
-        unsafe {
-            fmpq_mat_add(&mut out.matrix, &self.matrix, &other.matrix);
-        }
 
-        out
+        self.add_safe(&other).unwrap()
     }
 }
 
@@ -321,22 +305,6 @@ mod test_add {
         }
     }
 
-    /// Ensure that `add` is available for all types between [`MatZ`] and [`MatQ`].
-    #[test]
-    fn availability() {
-        let a = MatQ::new(2, 2);
-        let b = MatZ::new(2, 2);
-
-        let _ = &a + &b;
-        let _ = &a + b.clone();
-        let _ = a.clone() + &b;
-        let _ = a.clone() + b.clone();
-        let _ = &b + &a;
-        let _ = &b + a.clone();
-        let _ = b.clone() + &a;
-        let _ = b.clone() + a.clone();
-    }
-
     /// Testing addition for two [`MatQ`]
     #[test]
     fn add() {
@@ -417,4 +385,30 @@ mod test_add {
         assert!(a.add_safe(&b).is_err());
         assert!(c.add_safe(&b).is_err());
     }
+
+    /// Ensure that `add` is available for all types between [`MatZ`] and [`MatQ`].
+    #[test]
+    fn availability() {
+        let a = MatQ::new(2, 2);
+        let b = MatZ::new(2, 2);
+        let c = MatQ::new(2, 2);
+
+        let _ = &a + &b;
+        let _ = &a + b.clone();
+        let _ = a.clone() + &b;
+        let _ = a.clone() + b.clone();
+        let _ = &b + &a;
+        let _ = &b + a.clone();
+        let _ = b.clone() + &a;
+        let _ = b.clone() + a.clone();
+
+        let _ = &a + &c;
+        let _ = &a + c.clone();
+        let _ = a.clone() + &c;
+        let _ = a.clone() + c.clone();
+        let _ = &c + &a;
+        let _ = &c + a.clone();
+        let _ = c.clone() + &a;
+        let _ = c.clone() + a.clone();
+    }
 }

src/rational/mat_q/arithmetic/sub.rs

@@ -10,6 +10,7 @@
 
 use super::super::MatQ;
 use crate::error::MathError;
+use crate::integer::MatZ;
 use crate::macros::arithmetics::{
     arithmetic_trait_borrowed_to_owned, arithmetic_trait_mixed_borrowed_owned,
 };
@@ -19,26 +20,30 @@ use std::ops::Sub;
 
 impl Sub for &MatQ {
     type Output = MatQ;
-    /// Implements the [`Sub`] trait for two [`MatQ`] values.
+    /// Implements the [`Sub`] trait for two matrices.
     /// [`Sub`] is implemented for any combination of [`MatQ`] and borrowed [`MatQ`].
+    /// Furthermore, it is available for any combination of [`MatZ`] and [`MatQ`].
     ///
     /// Parameters:
-    /// - `other`: specifies the value to subtract from`self`
+    /// - `other`: specifies the value to subtract from `self`
     ///
     /// Returns the result of the subtraction as a [`MatQ`].
     ///
     /// # Examples
     /// ```
-    /// use qfall_math::rational::MatQ;
+    /// use qfall_math::{rational::MatQ, integer::MatZ};
     /// use std::str::FromStr;
     ///
     /// let a: MatQ = MatQ::from_str("[[1/2, 2/3, 3/4],[3/4, 4/5, 5/7]]").unwrap();
     /// let b: MatQ = MatQ::from_str("[[1/4, 9/7, 3/7],[1, 0, 5]]").unwrap();
+    /// let c: MatZ = MatZ::identity(2, 3);
     ///
-    /// let c: MatQ = &a - &b;
-    /// let d: MatQ = a - b;
-    /// let e: MatQ = &c - d;
-    /// let f: MatQ = c - &e;
+    /// let d: MatQ = &a - &b;
+    /// let e: MatQ = a - b;
+    /// let f: MatQ = &d - e;
+    /// let g: MatQ = d - &f;
+    /// let h: MatQ = &f - &c;
+    /// let i: MatQ = f - c;
     /// ```
     ///
     /// # Panics ...
@@ -48,6 +53,20 @@ impl Sub for &MatQ {
     }
 }
 
+impl Sub<&MatZ> for &MatQ {
+    type Output = MatQ;
+
+    /// Documentation at [`MatQ::sub`].
+    fn sub(self, other: &MatZ) -> Self::Output {
+        let other = MatQ::from(other);
+
+        self.sub_safe(&other).unwrap()
+    }
+}
+
+arithmetic_trait_borrowed_to_owned!(Sub, sub, MatQ, MatZ, MatQ);
+arithmetic_trait_mixed_borrowed_owned!(Sub, sub, MatQ, MatZ, MatQ);
+
 impl MatQ {
     /// Implements subtraction for two [`MatQ`] matrices.
     ///
@@ -98,7 +117,7 @@ arithmetic_trait_mixed_borrowed_owned!(Sub, sub, MatQ, MatQ, MatQ);
 #[cfg(test)]
 mod test_sub {
     use super::MatQ;
-    use crate::rational::Q;
+    use crate::{integer::MatZ, rational::Q};
     use std::str::FromStr;
 
     /// Testing subtraction for two [`MatQ`]
@@ -174,4 +193,30 @@ mod test_sub {
         assert!(a.sub_safe(&b).is_err());
         assert!(c.sub_safe(&b).is_err());
     }
+
+    /// Ensure that `sub` is available for all types between [`MatZ`] and [`MatQ`].
+    #[test]
+    fn availability() {
+        let a = MatQ::new(2, 2);
+        let b = MatZ::new(2, 2);
+        let c = MatQ::new(2, 2);
+
+        let _ = &a - &b;
+        let _ = &a - b.clone();
+        let _ = a.clone() - &b;
+        let _ = a.clone() - b.clone();
+        let _ = &b - &a;
+        let _ = &b - a.clone();
+        let _ = b.clone() - &a;
+        let _ = b.clone() - a.clone();
+
+        let _ = &a - &c;
+        let _ = &a - c.clone();
+        let _ = a.clone() - &c;
+        let _ = a.clone() - c.clone();
+        let _ = &c - &a;
+        let _ = &c - a.clone();
+        let _ = c.clone() - &a;
+        let _ = c.clone() - a.clone();
+    }
 }