Define extended GCD, combined GCD+LCM

Author: strake

src/lib.rs

@@ -22,7 +22,8 @@ extern crate std;
 
 extern crate num_traits as traits;
 
-use core::ops::Add;
+use core::mem;
+use core::ops::{Add, SubAssign};
 
 use traits::{Num, Signed, Zero};
 
@@ -96,6 +97,69 @@ pub trait Integer: Sized + Num + PartialOrd + Ord + Eq {
     /// ~~~
     fn lcm(&self, other: &Self) -> Self;
 
+    /// Greatest Common Divisor (GCD) and
+    /// Lowest Common Multiple (LCM) together.
+    ///
+    /// Potentially more efficient than calling `gcd` and `lcm`
+    /// individually for identical inputs.
+    ///
+    /// # Examples
+    ///
+    /// ~~~
+    /// # use num_integer::Integer;
+    /// assert_eq!(10.gcd_lcm(&4), (2, 20));
+    /// assert_eq!(8.gcd_lcm(&9), (1, 72));
+    /// ~~~
+    #[inline]
+    fn gcd_lcm(&self, other: &Self) -> (Self, Self) {
+        (self.gcd(other), self.lcm(other))
+    }
+
+    /// Greatest common divisor and Bézout coefficients.
+    ///
+    /// # Examples
+    ///
+    /// ~~~
+    /// # extern crate num_traits;
+    /// # use num_integer::{ExtendedGcd, Integer};
+    /// # use num_traits::NumAssign;
+    /// fn check<A: Clone + Integer + NumAssign>(a: A, b: A) -> bool {
+    ///     let ExtendedGcd { gcd, coeffs: [x, y], .. } = a.extended_gcd(&b);
+    ///     gcd == x * a + y * b
+    /// }
+    /// assert!(check(10isize, 4isize));
+    /// assert!(check(8isize,  9isize));
+    /// ~~~
+    #[inline]
+    fn extended_gcd(&self, other: &Self) -> ExtendedGcd<Self>
+      where Self: Clone + SubAssign<Self> {
+        let mut s = (Self::zero(), Self::one());
+        let mut t = (Self::one(), Self::zero());
+        let mut r = (other.clone(), self.clone());
+
+        while !r.0.is_zero() {
+            let q = r.1.clone() / r.0.clone();
+            let f = |r: &mut (Self, Self)| {
+                mem::swap(&mut r.0, &mut r.1);
+                r.0 -= q.clone() * r.1.clone();
+            };
+            f(&mut r);
+            f(&mut s);
+            f(&mut t);
+        }
+
+        if r.1 >= Self::zero() { ExtendedGcd { gcd: r.1, coeffs: [s.1, t.1], _hidden: () } }
+        else { ExtendedGcd { gcd: Self::zero() - r.1,
+                             coeffs: [Self::zero() - s.1, Self::zero() - t.1], _hidden: () } }
+    }
+
+    /// Greatest common divisor, least common multiple, and Bézout coefficients.
+    #[inline]
+    fn extended_gcd_lcm(&self, other: &Self) -> (ExtendedGcd<Self>, Self)
+      where Self: Clone + SubAssign<Self> {
+        (self.extended_gcd(other), self.lcm(other))
+    }
+
     /// Deprecated, use `is_multiple_of` instead.
     fn divides(&self, other: &Self) -> bool;
 
@@ -174,6 +238,14 @@ pub trait Integer: Sized + Num + PartialOrd + Ord + Eq {
     }
 }
 
+/// Greatest common divisor and Bézout coefficients
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct ExtendedGcd<A> {
+    pub gcd: A,
+    pub coeffs: [A; 2],
+    _hidden: (),
+}
+
 /// Simultaneous integer division and modulus
 #[inline]
 pub fn div_rem<T: Integer>(x: T, y: T) -> (T, T) {
@@ -207,6 +279,13 @@ pub fn lcm<T: Integer>(x: T, y: T) -> T {
     x.lcm(&y)
 }
 
+/// Calculates the Greatest Common Divisor (GCD) and
+/// Lowest Common Multiple (LCM) of the number and `other`.
+#[inline(always)]
+pub fn gcd_lcm<T: Integer>(x: T, y: T) -> (T, T) {
+    x.gcd_lcm(&y)
+}
+
 macro_rules! impl_integer_for_isize {
     ($T:ty, $test_mod:ident) => (
         impl Integer for $T {
@@ -290,13 +369,31 @@ macro_rules! impl_integer_for_isize {
                 m << shift
             }
 
+            #[inline]
+            fn extended_gcd_lcm(&self, other: &Self) -> (ExtendedGcd<Self>, Self) {
+                let egcd = self.extended_gcd(other);
+                // should not have to recalculate abs
+                let lcm = if egcd.gcd.is_zero() { Self::zero() }
+                          else { (*self * (*other / egcd.gcd)).abs() };
+                (egcd, lcm)
+            }
+
             /// Calculates the Lowest Common Multiple (LCM) of the number and
             /// `other`.
             #[inline]
             fn lcm(&self, other: &Self) -> Self {
-                if self.is_zero() && other.is_zero() { Self::zero() }
-                else { // should not have to recalculate abs
-                       (*self * (*other / self.gcd(other))).abs() }
+                self.gcd_lcm(other).1
+            }
+
+            /// Calculates the Greatest Common Divisor (GCD) and
+            /// Lowest Common Multiple (LCM) of the number and `other`.
+            #[inline]
+            fn gcd_lcm(&self, other: &Self) -> (Self, Self) {
+                if self.is_zero() && other.is_zero() { return (Self::zero(), Self::zero()) }
+                let gcd = self.gcd(other);
+                // should not have to recalculate abs
+                let lcm = (*self * (*other / gcd)).abs();
+                (gcd, lcm)
             }
 
             /// Deprecated, use `is_multiple_of` instead.
@@ -477,6 +574,38 @@ macro_rules! impl_integer_for_isize {
                 assert_eq!((11 as $T).lcm(&5), 55 as $T);
             }
 
+            #[test]
+            fn test_gcd_lcm() {
+                use core::iter::once;
+                let r = once(0).chain((1..).take(127).flat_map(|a| once(a).chain(once(-a)))).chain(once(-128));
+                for i in r.clone() {
+                    for j in r.clone() {
+                        assert_eq!(i.gcd_lcm(&j), (i.gcd(&j), i.lcm(&j)));
+                    }
+                }
+            }
+
+            #[test]
+            fn test_extended_gcd_lcm() {
+                use ExtendedGcd;
+                use traits::NumAssign;
+
+                fn check<A: Clone + Integer + NumAssign>(a: A, b: A) -> bool {
+                    let ExtendedGcd { gcd, coeffs: [x, y], .. } = a.extended_gcd(&b);
+                    gcd == x * a + y * b
+                }
+
+                use core::iter::once;
+                let r = once(0).chain((1..).take(127).flat_map(|a| once(a).chain(once(-a)))).chain(once(-128));
+                for i in r.clone() {
+                    for j in r.clone() {
+                        check(i, j);
+                        let (ExtendedGcd { gcd, .. }, lcm) = i.extended_gcd_lcm(&j);
+                        assert_eq!((gcd, lcm), (i.gcd(&j), i.lcm(&j)));
+                    }
+                }
+            }
+
             #[test]
             fn test_even() {
                 assert_eq!((-4 as $T).is_even(), true);
@@ -556,11 +685,29 @@ macro_rules! impl_integer_for_usize {
                 m << shift
             }
 
+            #[inline]
+            fn extended_gcd_lcm(&self, other: &Self) -> (ExtendedGcd<Self>, Self) {
+                let egcd = self.extended_gcd(other);
+                // should not have to recalculate abs
+                let lcm = if egcd.gcd.is_zero() { Self::zero() }
+                          else { *self * (*other / egcd.gcd) };
+                (egcd, lcm)
+            }
+
             /// Calculates the Lowest Common Multiple (LCM) of the number and `other`.
             #[inline]
             fn lcm(&self, other: &Self) -> Self {
-                if self.is_zero() && other.is_zero() { Self::zero() }
-                else { *self * (*other / self.gcd(other)) }
+                self.gcd_lcm(other).1
+            }
+
+            /// Calculates the Greatest Common Divisor (GCD) and
+            /// Lowest Common Multiple (LCM) of the number and `other`.
+            #[inline]
+            fn gcd_lcm(&self, other: &Self) -> (Self, Self) {
+                if self.is_zero() && other.is_zero() { return (Self::zero(), Self::zero()) }
+                let gcd = self.gcd(other);
+                let lcm = *self * (*other / gcd);
+                (gcd, lcm)
             }
 
             /// Deprecated, use `is_multiple_of` instead.
@@ -656,6 +803,15 @@ macro_rules! impl_integer_for_usize {
                 assert_eq!((15 as $T).lcm(&17), 255 as $T);
             }
 
+            #[test]
+            fn test_gcd_lcm() {
+                for i in (0..).take(256) {
+                    for j in (0..).take(256) {
+                        assert_eq!(i.gcd_lcm(&j), (i.gcd(&j), i.lcm(&j)));
+                    }
+                }
+            }
+
             #[test]
             fn test_is_multiple_of() {
                 assert!((6 as $T).is_multiple_of(&(6 as $T)));