Add binxgcd_; switches between the classic and optimized binxgcd algorithms.

Author: erik-3milabs

src/modular/bingcd/xgcd.rs

@@ -130,7 +130,7 @@ impl<const LIMBS: usize> OddUint<LIMBS> {
         let (abs_diff, rhs_gt_lhs) = lhs_.abs_diff(rhs_);
         let odd_rhs = Odd(Uint::select(rhs_, &abs_diff, rhs_is_even));
 
-        let mut output = self.classic_binxgcd(&odd_rhs).divide();
+        let mut output = self.binxgcd_(&odd_rhs).divide();
         let matrix = &mut output.matrix;
 
         // Modify the output to negate the transformation applied to the input.
@@ -144,6 +144,20 @@ impl<const LIMBS: usize> OddUint<LIMBS> {
         output
     }
 
+    /// Given `(self, rhs)`, computes `(g, x, y)` s.t. `self * x + rhs * y = g = gcd(self, rhs)`,
+    /// leveraging the Binary Extended GCD algorithm.
+    ///
+    /// This function switches between the "classic" and "optimized" algorithm at a best-effort
+    /// threshold. When using [Uint]s with `LIMBS` close to the threshold, it may be useful to
+    /// manually test whether the classic or optimized algorithm is faster for your machine.
+    pub(crate) const fn binxgcd_(&self, rhs: &Self) -> DividedPatternXgcdOutput<LIMBS> {
+        if LIMBS < 4 {
+            self.classic_binxgcd(rhs)
+        } else {
+            self.optimized_binxgcd(rhs)
+        }
+    }
+
     /// Execute the classic Binary Extended GCD algorithm.
     ///
     /// Given `(self, rhs)`, computes `(g, x, y)` s.t. `self * x + rhs * y = g = gcd(self, rhs)`.

src/uint/gcd.rs

@@ -188,7 +188,7 @@ impl<const LIMBS: usize> OddUint<LIMBS> {
     ///
     /// Given `(self, rhs)`, computes `(g, x, y)` s.t. `self * x + rhs * y = g = gcd(self, rhs)`.
     pub const fn binxgcd(&self, rhs: &Self) -> OddUintXgcdOutput<LIMBS> {
-        OddUintXgcdOutput::from_pattern_output(self.classic_binxgcd(rhs).divide())
+        OddUintXgcdOutput::from_pattern_output(self.binxgcd_(rhs).divide())
     }
 }