Remove kalinski_inverse function since it's not needed anymore

Also:
- refactored benchmarks.
- removed related tests.
- Bench all of the point ops benchmarks with
`RistrettoPoint` inputs.

Author: CPerezz

benchmarks/dusk_benchmarks.rs

@@ -487,6 +487,7 @@ mod ristretto_benches {
 mod comparaisons {
     use super::*;
     use rand::rngs::OsRng;
+    use zerocaf::constants::RISTRETTO_BASEPOINT;
 
     static P1_EXTENDED: RistrettoPoint = RistrettoPoint( EdwardsPoint {
         X: FieldElement([13, 0, 0, 0, 0]),
@@ -518,8 +519,8 @@ mod comparaisons {
 
     pub fn bench_point_ops_impl(c: &mut Criterion) {
         let i = P1_EXTENDED;
-        let mul = (P1_EXTENDED, D);
-        /*
+        let mul = (RISTRETTO_BASEPOINT, D);
+        
         // Equalty
         let mut group = c.benchmark_group("Equalty");
 
@@ -529,7 +530,7 @@ mod comparaisons {
             |b, &i| b.iter(|| i == i));
 
         group.finish();
-*/
+
         // Point Mul
         let mut group = c.benchmark_group("Point Multiplication");
 
@@ -539,6 +540,8 @@ mod comparaisons {
             |b, &mul| b.iter(|| ltr_bin_mul(&mul.0, &mul.1)));
         group.bench_with_input(BenchmarkId::new("NAF binary", "Fixed inputs"), &mul, 
             |b, &mul| b.iter(|| binary_naf_mul(&mul.0, &mul.1)));
+        group.bench_with_input(BenchmarkId::new("Window w-NAF binary", "Fixed inputs"), &mul, 
+            |b, &mul| b.iter(|| window_naf_mul(&mul.1, 5u8)));
 
         group.finish();
     }   

src/backend/u64/field.rs

@@ -882,119 +882,6 @@ impl FieldElement {
         FieldElement::montgomery_reduce(&limbs)
     }
 
-    /// Compute `a^-1 (mod l)` using the the Kalinski implementation
-    /// of the Montgomery Modular Inverse algorithm.
-    /// B. S. Kaliski Jr. - The  Montgomery  inverse  and  its  applications.
-    /// IEEE Transactions on Computers, 44(8):1064–1065, August-1995
-    #[allow(dead_code)]
-    pub(self) fn kalinski_inverse(&self) -> FieldElement {
-        /// This Phase I indeed is the Binary GCD algorithm, a version of Steins algorithm
-        /// which tries to remove the expensive division operation away from the Classical
-        /// Euclidean GDC algorithm by replacing it with Bit-shifting, subtraction and comparison.
-        ///
-        /// Output = `a^(-1) * 2^k (mod l)` where `k = log2(FIELD_L) == 253`.
-        ///
-        /// Stein, J.: Computational problems associated with Racah algebra.J. Comput. Phys.1, 397–405 (1967)
-        ///
-        ///
-        /// Mentioned on: SPECIAL ISSUE ON MONTGOMERY ARITHMETIC.
-        /// Montgomery inversion - Erkay Sava ̧s & Çetin Kaya Koç
-        /// J Cryptogr Eng (2018) 8:201–210
-        /// https://doi.org/10.1007/s13389-017-0161-x
-
-        fn phase1(a: &FieldElement) -> (FieldElement, u64) {
-            // Declare L = 2^252 + 27742317777372353535851937790883648493
-            let p = FieldElement([
-                671914833335277,
-                3916664325105025,
-                1367801,
-                0,
-                17592186044416,
-            ]);
-            let mut u = p.clone();
-            let mut v = *a;
-            let mut r = FieldElement::zero();
-            let mut s = FieldElement::one();
-            let two = FieldElement([2, 0, 0, 0, 0]);
-            let mut k = 0u64;
-
-            while v > FieldElement::zero() {
-                match (u.is_even(), v.is_even(), u > v, v >= u) {
-                    // u is even
-                    (true, _, _, _) => {
-                        u = u.inner_half();
-                        s = s * two;
-                    }
-                    // u isn't even but v is even
-                    (false, true, _, _) => {
-                        v = v.inner_half();
-                        r = r * two;
-                    }
-                    // u and v aren't even and u > v
-                    (false, false, true, _) => {
-                        u = u - v;
-                        u = u.inner_half();
-                        r = r + s;
-                        s = s * two;
-                    }
-                    // u and v aren't even and v > u
-                    (false, false, false, true) => {
-                        v = v - u;
-                        v = v.inner_half();
-                        s = r + s;
-                        r = r * two;
-                    }
-                    (false, false, false, false) => panic!("Unexpected error has ocurred."),
-                }
-                k += 1;
-            }
-            if r > p {
-                r = r - p;
-            }
-            (p - r, k)
-        }
-
-        /// Phase II performs some adjustments to obtain
-        /// the Montgomery inverse.
-        ///
-        /// Output: `a^(-1) * 2^n  (mod l)`  where `n = 253 = log2(p) = log2(FIELD_L)`
-
-        fn phase2(r: &FieldElement, k: u64) -> FieldElement {
-            let mut rr = *r;
-            let _p = &constants::FIELD_L;
-
-            for _i in 0..(k - 253) {
-                match rr.is_even() {
-                    true => {
-                        rr = rr.inner_half();
-                    }
-                    false => {
-                        rr = rr.plus_p_and_half();
-                    }
-                }
-            }
-            rr
-        }
-
-        let (mut r, z) = phase1(&self);
-
-        r = phase2(&r, z);
-
-        // Since the output of the Phase II is multiplied by `2^n`
-        // We can multiply it by the two power needed to achive the
-        // Montgomery modulus value and then convert it back to the
-        // normal FieldElement domain.
-        //
-        // In this case: `R = 2^260` & `n = 2^253`.
-        // So we multiply `r * 2^7` to get R on the Montgomery domain.
-        r = &r * &FieldElement::inner_two_pow_k(7);
-
-        // Now we apply `from_montgomery()` function which performs
-        // `r/2^260` carrying the `FieldElement` out of the
-        // Montgomery domain.
-        r.from_montgomery()
-    }
-
     /// Compute `a^-1 (mod l)` using the the Savas & Koç modular
     /// inverse algorithm. It's an optimization of the Kalinski
     /// modular inversion algorithm that extends the Binary GCD
@@ -1687,24 +1574,6 @@ pub mod tests {
         assert!(msb[31] < pos_sign);
     }
 
-    #[test]
-    fn kalinski_inverse() {
-        let res = FieldElement::kalinski_inverse(&A);
-        for i in 0..5 {
-            assert!(res[i] == INV_MOD_A[i]);
-        }
-
-        let res = FieldElement::kalinski_inverse(&B);
-        for i in 0..5 {
-            assert!(res[i] == INV_MOD_B[i]);
-        }
-
-        let res = FieldElement::kalinski_inverse(&C);
-        for i in 0..5 {
-            assert!(res[i] == INV_MOD_C[i]);
-        }
-    }
-
     #[test]
     fn savas_koc_inverse() {
         let res = FieldElement::inverse(&A);