feat: impl LowerHex and UpperHex on UnsignedElement

Author: tdelabro

crates/math/src/fft/cpu/fft.rs

@@ -183,6 +183,7 @@ mod tests {
     use crate::fft::cpu::roots_of_unity::get_twiddles;
     use crate::fft::test_helpers::naive_matrix_dft_test;
     use crate::field::{test_fields::u64_test_field::U64TestField, traits::RootsConfig};
+    use alloc::format;
     use proptest::{collection, prelude::*};
 
     use super::*;

crates/math/src/fft/cpu/roots_of_unity.rs

@@ -83,6 +83,7 @@ mod tests {
         },
         field::{test_fields::u64_test_field::U64TestField, traits::RootsConfig},
     };
+    use alloc::format;
     use proptest::prelude::*;
 
     type F = U64TestField;

crates/math/src/fft/polynomial.rs

@@ -240,6 +240,7 @@ mod tests {
         test_fields::u64_test_field::{U64TestField, U64TestFieldExtension},
         traits::RootsConfig,
     };
+    use alloc::format;
     use proptest::{collection, prelude::*};
 
     use roots_of_unity::{get_powers_of_primitive_root, get_powers_of_primitive_root_coset};

crates/math/src/fft/test_helpers.rs

@@ -35,6 +35,7 @@ pub fn naive_matrix_dft_test<F: IsFFTField>(input: &[FieldElement<F>]) -> Vec<Fi
 mod fft_helpers_test {
     use super::*;
     use crate::{field::test_fields::u64_test_field::U64TestField, polynomial::Polynomial};
+    use alloc::format;
 
     use proptest::{collection, prelude::*};
 

crates/math/src/field/element.rs

@@ -6,10 +6,7 @@ use crate::unsigned_integer::element::UnsignedInteger;
 use crate::unsigned_integer::montgomery::MontgomeryAlgorithms;
 use crate::unsigned_integer::traits::IsUnsignedInteger;
 #[cfg(feature = "alloc")]
-use alloc::{
-    format,
-    string::{String, ToString},
-};
+use alloc::{format, string::String};
 use core::fmt;
 use core::fmt::Debug;
 use core::iter::Sum;
@@ -521,21 +518,11 @@ where
         Self: ByteConversion,
         F: IsPrimeField,
     {
-        let mod_minus_one = F::modulus_minus_one().to_string();
-
-        // We check if `mod_minus_one` is a hex string or a decimal string.
-        // In case it is a hex we remove the prefix `0x`.
-        let (digits, radix) = if let Some(hex) = mod_minus_one
-            .strip_prefix("0x")
-            .or_else(|| mod_minus_one.strip_prefix("0X"))
-        {
-            (hex, 16)
-        } else {
-            (mod_minus_one.as_str(), 10)
-        };
+        let mod_minus_one = format!("{:x}", F::modulus_minus_one());
 
-        let modulus =
-            BigUint::from_str_radix(digits, radix).expect("invalid modulus representation") + 1u32;
+        let modulus = BigUint::from_str_radix(&mod_minus_one, 16)
+            .expect("invalid modulus representation")
+            + 1u32;
 
         if value >= &modulus {
             Err(ByteConversionError::ValueNotReduced)

crates/math/src/msm/pippenger.rs

@@ -170,7 +170,7 @@ mod tests {
         },
         unsigned_integer::element::UnsignedInteger,
     };
-    use alloc::vec::Vec;
+    use alloc::{format, vec::Vec};
     use proptest::{collection, prelude::*, prop_assert_eq, prop_compose, proptest};
 
     const _CASES: u32 = 20;

crates/math/src/unsigned_integer/element.rs

@@ -19,7 +19,7 @@ use crate::traits::AsBytes;
 use crate::traits::ByteConversion;
 use crate::unsigned_integer::traits::IsUnsignedInteger;
 
-use core::fmt::{self, Debug, Display};
+use core::fmt::{self, Debug, Display, LowerHex, UpperHex};
 
 pub type U384 = UnsignedInteger<6>;
 pub type U256 = UnsignedInteger<4>;
@@ -108,6 +108,28 @@ impl<const NUM_LIMBS: usize> From<&str> for UnsignedInteger<NUM_LIMBS> {
 }
 
 impl<const NUM_LIMBS: usize> Display for UnsignedInteger<NUM_LIMBS> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "0x")?;
+
+        let mut limbs_iterator = self.limbs.iter().skip_while(|limb| **limb == 0).peekable();
+
+        if limbs_iterator.peek().is_none() {
+            write!(f, "0")?;
+        } else {
+            if let Some(most_significant_limb) = limbs_iterator.next() {
+                write!(f, "{most_significant_limb:x}")?;
+            }
+
+            for limb in limbs_iterator {
+                write!(f, "{limb:016x}")?;
+            }
+        }
+
+        Ok(())
+    }
+}
+
+impl<const NUM_LIMBS: usize> LowerHex for UnsignedInteger<NUM_LIMBS> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         if f.alternate() {
             write!(f, "0x")?;
@@ -131,6 +153,30 @@ impl<const NUM_LIMBS: usize> Display for UnsignedInteger<NUM_LIMBS> {
     }
 }
 
+impl<const NUM_LIMBS: usize> UpperHex for UnsignedInteger<NUM_LIMBS> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if f.alternate() {
+            write!(f, "0X")?;
+        }
+
+        let mut limbs_iterator = self.limbs.iter().skip_while(|limb| **limb == 0).peekable();
+
+        if limbs_iterator.peek().is_none() {
+            write!(f, "0")?;
+        } else {
+            if let Some(most_significant_limb) = limbs_iterator.next() {
+                write!(f, "{most_significant_limb:X}")?;
+            }
+
+            for limb in limbs_iterator {
+                write!(f, "{limb:016X}")?;
+            }
+        }
+
+        Ok(())
+    }
+}
+
 // impl Add for both references and variables
 
 impl<const NUM_LIMBS: usize> Add<&UnsignedInteger<NUM_LIMBS>> for &UnsignedInteger<NUM_LIMBS> {

crates/math/src/unsigned_integer/traits.rs

@@ -1,5 +1,5 @@
 use core::{
-    fmt::Display,
+    fmt::{Display, LowerHex, UpperHex},
     ops::{Add, BitAnd, Shr, ShrAssign},
 };
 
@@ -12,6 +12,8 @@ pub trait IsUnsignedInteger:
     + From<u16>
     + Copy
     + Display
+    + LowerHex
+    + UpperHex
     + Add<Self, Output = Self>
 {
 }