feat: Add is_zero

src/bignum.nr

@@ -5,7 +5,8 @@ use crate::params::BigNumParamsGetter;
 use crate::fns::{
     constrained_ops::{
         add, assert_is_not_equal, conditional_select, derive_from_seed, div, eq, from_field,
-        limbs_to_field, mul, neg, sub, udiv, udiv_mod, umod, validate_in_field, validate_in_range,
+        is_zero, limbs_to_field, mul, neg, sub, udiv, udiv_mod, umod, validate_in_field,
+        validate_in_range,
     },
     expressions::{__compute_quadratic_expression, evaluate_quadratic_expression},
     serialization::{from_be_bytes, to_le_bytes},
@@ -84,6 +85,7 @@ pub trait BigNumTrait: Neg + Add + Sub + Mul + Div + Eq {
     pub fn umod(self, divisor: Self) -> Self;
 
     pub fn conditional_select(lhs: Self, rhs: Self, predicate: bool) -> Self;
+    pub fn is_zero(self) -> bool;
 }
 
 impl<let N: u32, let MOD_BITS: u32, Params> std::convert::From<Field> for BigNum<N, MOD_BITS, Params>
@@ -317,6 +319,10 @@ where
     fn conditional_select(lhs: Self, rhs: Self, predicate: bool) -> Self {
         Self { limbs: conditional_select(lhs.limbs, rhs.limbs, predicate) }
     }
+
+    fn is_zero(self) -> bool {
+        is_zero::<N, MOD_BITS>(self.limbs)
+    }
 }
 
 // impl<let N: u32, Params> BigNumTrait<N, Params> for BigNum<N, Params> where Params: BigNumParamsGetter<N> {}

src/fns/constrained_ops.nr

@@ -276,6 +276,10 @@ pub(crate) fn eq<let N: u32, let MOD_BITS: u32>(
     is_equal_modulus | is_equal_zero
 }
 
+pub(crate) fn is_zero<let N: u32, let MOD_BITS: u32>(val: [Field; N]) -> bool {
+    val.all(|limb| limb == 0)
+}
+
 pub(crate) fn validate_in_field<let N: u32, let MOD_BITS: u32>(
     params: P<N, MOD_BITS>,
     val: [Field; N],

src/runtime_bignum.nr

@@ -3,8 +3,8 @@ use crate::utils::map::map;
 
 use crate::fns::{
     constrained_ops::{
-        add, assert_is_not_equal, conditional_select, derive_from_seed, div, eq, mul, neg, sub,
-        udiv, udiv_mod, umod, validate_in_field, validate_in_range,
+        add, assert_is_not_equal, conditional_select, derive_from_seed, div, eq, is_zero, mul, neg,
+        sub, udiv, udiv_mod, umod, validate_in_field, validate_in_range,
     },
     expressions::{__compute_quadratic_expression, evaluate_quadratic_expression},
     serialization::{from_be_bytes, to_le_bytes},
@@ -112,6 +112,7 @@ pub(crate) trait RuntimeBigNumTrait<let N: u32, let MOD_BITS: u32>: Neg + Add +
     pub fn umod(numerator: Self, divisor: Self) -> Self;
 
     pub fn conditional_select(lhs: Self, rhs: Self, predicate: bool) -> Self;
+    pub fn is_zero(self) -> bool;
 }
 
 impl<let N: u32, let MOD_BITS: u32> Neg for RuntimeBigNum<N, MOD_BITS> {
@@ -379,6 +380,10 @@ impl<let N: u32, let MOD_BITS: u32> RuntimeBigNumTrait<N, MOD_BITS> for RuntimeB
         assert(params == rhs.params);
         Self { limbs: conditional_select(lhs.limbs, rhs.limbs, predicate), params }
     }
+
+    fn is_zero(self) -> bool {
+        is_zero::<N, MOD_BITS>(self.limbs)
+    }
 }
 
 impl<let N: u32, let MOD_BITS: u32> std::ops::Add for RuntimeBigNum<N, MOD_BITS> {

src/tests/bignum_test.nr

@@ -255,6 +255,16 @@ where
     assert(c.eq(a) == false);
 }
 
+fn test_is_zero<let N: u32, BN>()
+where
+    BN: BigNumTrait,
+{
+    let a = BN::derive_from_seed([1, 2, 3, 4]);
+    let zero = BN::zero();
+    assert(a.is_zero() == false);
+    assert(zero.is_zero() == true);
+}
+
 // fn test_eq<let N: u32, Params>(_: BigNum<N, Params>) where Params: BigNumParamsGetter<N> + RuntimeBigNumParamsTrait<N> {
 //     let a = BigNum::__derive_from_seed([1, 2, 3, 4]);
 //     let b = BigNum::__derive_from_seed([1, 2, 3, 4]);
@@ -410,6 +420,12 @@ fn test_eq_BN() {
     // let stub: Fq = BigNum::new();
     test_eq::<3, Fq>();
 }
+
+#[test]
+fn test_is_zero_BN() {
+    test_is_zero::<3, Fq>();
+}
+
 #[test]
 fn test_add_BN() {
     let mut a: Fq = BigNum::modulus();
@@ -544,6 +560,11 @@ fn test_eq_2048() {
     test_eq::<18, BN2048>();
 }
 
+#[test]
+fn test_is_zero_2048() {
+    test_is_zero::<18, BN2048>();
+}
+
 #[test]
 fn test_mul_2048() {
     test_mul::<18, BN2048>();
@@ -584,6 +605,11 @@ fn test_eq_U256() {
     test_eq::<3, BN256>();
 }
 
+#[test]
+fn test_is_zero_U256() {
+    test_is_zero::<3, BN256>();
+}
+
 #[test]
 fn test_mul_U256() {
     test_mul::<3, BN256>();

src/tests/runtime_bignum_test.nr

@@ -509,6 +509,17 @@ fn test_eq() {
     assert((c == a) == false);
 }
 
+#[test]
+fn test_is_zero() {
+    let params = $typ ::get_params();
+
+    let a: $RuntimeBigNum<$N, $MOD_BITS> = $RuntimeBigNum::new(params);
+    let b: $RuntimeBigNum<$N, $MOD_BITS> = $RuntimeBigNum::derive_from_seed(params, [1, 2, 3, 4]);
+
+    assert(a.is_zero() == true);
+    assert(b.is_zero() == false);
+}
+
 }
 }