add Zero impl for BigInt

Signed-off-by: Andrew Tretyakov <42178850+0xAndoroid@users.noreply.github.com>

Author: 0xAndoroid

ff-asm/src/lib.rs

@@ -59,6 +59,7 @@ pub fn x86_64_asm_mul(input: TokenStream) -> TokenStream {
     } else {
         panic!("The number of limbs must be a literal");
     };
+    #[allow(clippy::redundant_comparisons)]
     if num_limbs <= 6 && num_limbs <= 3 * MAX_REGS {
         let impl_block = generate_impl(num_limbs, true);
 
@@ -110,6 +111,7 @@ pub fn x86_64_asm_square(input: TokenStream) -> TokenStream {
     } else {
         panic!("The number of limbs must be a literal");
     };
+    #[allow(clippy::redundant_comparisons)]
     if num_limbs <= 6 && num_limbs <= 3 * MAX_REGS {
         let impl_block = generate_impl(num_limbs, false);
 

ff/src/biginteger/mod.rs

@@ -14,15 +14,16 @@ use ark_std::{
     fmt::{Debug, Display, UpperHex},
     io::{Read, Write},
     ops::{
-        BitAnd, BitAndAssign, BitOr, BitOrAssign, BitXor, BitXorAssign, Not, Shl, ShlAssign, Shr,
-        ShrAssign, Add, Sub, AddAssign, SubAssign,
+        Add, AddAssign, BitAnd, BitAndAssign, BitOr, BitOrAssign, BitXor, BitXorAssign, Not, Shl,
+        ShlAssign, Shr, ShrAssign, Sub, SubAssign,
     },
     rand::{
         distributions::{Distribution, Standard},
         Rng,
     },
     str::FromStr,
     vec::*,
+    Zero,
 };
 use num_bigint::BigUint;
 use zeroize::Zeroize;
@@ -346,13 +347,19 @@ impl<const N: usize> BigInt<N> {
     #[inline]
     #[unroll_for_loops(9)]
     pub fn add_assign_trunc<const M: usize>(&mut self, other: &BigInt<M>) {
-        debug_assert!(M <= N, "add_assign_trunc: right operand wider than self width N");
+        debug_assert!(
+            M <= N,
+            "add_assign_trunc: right operand wider than self width N"
+        );
         let mut carry = 0u64;
         for i in 0..N {
             let rhs = if i < M { other.0[i] } else { 0 };
             self.0[i] = adc!(self.0[i], rhs, &mut carry);
         }
-        debug_assert!(carry == 0, "add_assign_trunc overflow: carry beyond N limbs");
+        debug_assert!(
+            carry == 0,
+            "add_assign_trunc overflow: carry beyond N limbs"
+        );
     }
 
     /// Truncated-width subtraction that mutates self: self -= other, keeping N limbs (self's width).
@@ -363,13 +370,19 @@ impl<const N: usize> BigInt<N> {
     #[inline]
     #[unroll_for_loops(9)]
     pub fn sub_assign_trunc<const M: usize>(&mut self, other: &BigInt<M>) {
-        debug_assert!(M <= N, "sub_assign_trunc: right operand wider than self width N");
+        debug_assert!(
+            M <= N,
+            "sub_assign_trunc: right operand wider than self width N"
+        );
         let mut borrow = 0u64;
         for i in 0..N {
             let rhs = if i < M { other.0[i] } else { 0 };
             self.0[i] = sbb!(self.0[i], rhs, &mut borrow);
         }
-        debug_assert!(borrow == 0, "sub_assign_trunc underflow: borrow beyond N limbs");
+        debug_assert!(
+            borrow == 0,
+            "sub_assign_trunc underflow: borrow beyond N limbs"
+        );
     }
 
     /// Truncated-width multiplication that mutates self: self = (self * other) mod 2^(64*N).
@@ -378,12 +391,16 @@ impl<const N: usize> BigInt<N> {
     pub fn mul_assign_trunc<const M: usize>(&mut self, other: &BigInt<M>) {
         // Fast paths
         if self.is_zero() || other.is_zero() {
-            for i in 0..N { self.0[i] = 0; }
+            for i in 0..N {
+                self.0[i] = 0;
+            }
             return;
         }
         let left = *self; // snapshot original multiplicand
-        // zero self to use as accumulator buffer
-        for i in 0..N { self.0[i] = 0; }
+                          // zero self to use as accumulator buffer
+        for i in 0..N {
+            self.0[i] = 0;
+        }
         // Accumulate left * other directly into self within width N; propagate carries within N
         left.fm_limbs_into::<M, N>(&other.0, self, true);
     }
@@ -512,14 +529,29 @@ impl<const N: usize> BigInt<N> {
     /// Debug-asserts that M <= N.
     #[inline]
     pub fn zero_extend_from<const M: usize>(smaller: &BigInt<M>) -> BigInt<N> {
-        debug_assert!(M <= N, "cannot zero-extend: source has more limbs than destination");
+        debug_assert!(
+            M <= N,
+            "cannot zero-extend: source has more limbs than destination"
+        );
         let mut limbs = [0u64; N];
         let copy_len = if M < N { M } else { N };
         limbs[..copy_len].copy_from_slice(&smaller.0[..copy_len]);
         BigInt::<N>(limbs)
     }
 }
 
+impl<const N: usize> Zero for BigInt<N> {
+    #[inline]
+    fn zero() -> Self {
+        Self::zero()
+    }
+
+    #[inline]
+    fn is_zero(&self) -> bool {
+        self.0.iter().all(|&limb| limb == 0)
+    }
+}
+
 impl<const N: usize> From<[u64; N]> for BigInt<N> {
     fn from(limbs: [u64; N]) -> Self {
         BigInt(limbs)
@@ -795,11 +827,6 @@ impl<const N: usize> BigInteger for BigInt<N> {
         !self.is_odd()
     }
 
-    #[inline]
-    fn is_zero(&self) -> bool {
-        self.0.iter().all(|&e| e == 0)
-    }
-
     #[inline]
     fn num_bits(&self) -> u32 {
         let mut ret = N as u32 * 64;
@@ -1308,6 +1335,7 @@ pub trait BigInteger:
     + 'static
     + UniformRand
     + Zeroize
+    + Zero
     + AsMut<[u64]>
     + AsRef<[u64]>
     + From<u128>
@@ -1572,17 +1600,6 @@ pub trait BigInteger:
     /// ```
     fn is_even(&self) -> bool;
 
-    /// Returns true iff this number is zero.
-    /// # Example
-    ///
-    /// ```
-    /// use ark_ff::{biginteger::BigInteger64 as B, BigInteger as _};
-    ///
-    /// let mut zero = B::from(0u64);
-    /// assert!(zero.is_zero());
-    /// ```
-    fn is_zero(&self) -> bool;
-
     /// Compute the minimum number of bits needed to encode this number.
     /// # Example
     /// ```

ff/src/biginteger/signed.rs

@@ -4,6 +4,7 @@ use ark_serialize::{
     CanonicalDeserialize, CanonicalSerialize, Compress, Read, SerializationError, Valid, Validate,
     Write,
 };
+use ark_std::Zero;
 use core::cmp::Ordering;
 use core::ops::{Add, AddAssign, Mul, MulAssign, Neg, Sub, SubAssign};
 
@@ -27,6 +28,18 @@ impl<const N: usize> Default for SignedBigInt<N> {
     }
 }
 
+impl<const N: usize> Zero for SignedBigInt<N> {
+    #[inline]
+    fn zero() -> Self {
+        Self::zero()
+    }
+
+    #[inline]
+    fn is_zero(&self) -> bool {
+        self.magnitude.is_zero()
+    }
+}
+
 pub type S64 = SignedBigInt<1>;
 pub type S128 = SignedBigInt<2>;
 pub type S192 = SignedBigInt<3>;
@@ -87,12 +100,6 @@ impl<const N: usize> SignedBigInt<N> {
         }
     }
 
-    /// Return true if magnitude is zero (sign is not considered).
-    #[inline]
-    pub fn is_zero(&self) -> bool {
-        self.magnitude.is_zero()
-    }
-
     /// Borrow the magnitude (absolute value).
     #[inline]
     pub fn as_magnitude(&self) -> &BigInt<N> {

ff/src/biginteger/tests.rs

@@ -5,6 +5,7 @@ pub mod tests {
         biginteger::{BigInteger, SignedBigInt},
         UniformRand,
     };
+    use ark_std::Zero;
     use num_bigint::BigUint;
 
     // Test elementary math operations for BigInteger.