Remove field macros

starkware-libs · Apr 25, 2024 · 41de2e8 · 41de2e8
1 parent eca8057
commit 41de2e8
Show file tree

Hide file tree

Showing 18 changed files with 100 additions and 102 deletions.
diff --git a/crates/prover/src/core/air/accumulation.rs b/crates/prover/src/core/air/accumulation.rs
@@ -183,7 +183,7 @@ mod tests {
             .iter()
             .map(|_| M31::from_u32_unchecked(rng.gen::<u32>() & MASK))
             .collect::<Vec<_>>();
-        let alpha = qm31!(2, 3, 4, 5);
+        let alpha = qm31(2, 3, 4, 5);
 
         // Use accumulator.
         let mut accumulator = PointEvaluationAccumulator::new(alpha);
@@ -222,7 +222,7 @@ mod tests {
                     .collect::<Vec<_>>()
             })
             .collect::<Vec<_>>();
-        let alpha = qm31!(2, 3, 4, 5);
+        let alpha = qm31(2, 3, 4, 5);
 
         // Use accumulator.
         let mut accumulator = DomainEvaluationAccumulator::<CPUBackend>::new(

diff --git a/crates/prover/src/core/backend/avx512/circle.rs b/crates/prover/src/core/backend/avx512/circle.rs
@@ -438,17 +438,17 @@ mod tests {
             );
             let poly = evaluation.bit_reverse().interpolate();
 
-            let x = qm31!(
+            let x = qm31(
+                rng.gen::<u32>(),
                 rng.gen::<u32>(),
                 rng.gen::<u32>(),
                 rng.gen::<u32>(),
-                rng.gen::<u32>()
             );
-            let y = qm31!(
+            let y = qm31(
+                rng.gen::<u32>(),
                 rng.gen::<u32>(),
                 rng.gen::<u32>(),
                 rng.gen::<u32>(),
-                rng.gen::<u32>()
             );
 
             let p = CirclePoint { x, y };

diff --git a/crates/prover/src/core/backend/avx512/fri.rs b/crates/prover/src/core/backend/avx512/fri.rs
@@ -105,9 +105,9 @@ mod tests {
     fn test_fold_line() {
         const LOG_SIZE: u32 = 7;
         let values: Vec<SecureField> = (0..(1 << LOG_SIZE))
-            .map(|i| qm31!(4 * i, 4 * i + 1, 4 * i + 2, 4 * i + 3))
+            .map(|i| qm31(4 * i, 4 * i + 1, 4 * i + 2, 4 * i + 3))
             .collect();
-        let alpha = qm31!(1, 3, 5, 7);
+        let alpha = qm31(1, 3, 5, 7);
         let domain = LineDomain::new(CanonicCoset::new(LOG_SIZE + 1).half_coset());
         let cpu_fold = CPUBackend::fold_line(
             &LineEvaluation::new(domain, values.iter().copied().collect()),
@@ -128,9 +128,9 @@ mod tests {
     fn test_fold_circle_into_line() {
         const LOG_SIZE: u32 = 7;
         let values: Vec<SecureField> = (0..(1 << LOG_SIZE))
-            .map(|i| qm31!(4 * i, 4 * i + 1, 4 * i + 2, 4 * i + 3))
+            .map(|i| qm31(4 * i, 4 * i + 1, 4 * i + 2, 4 * i + 3))
             .collect();
-        let alpha = qm31!(1, 3, 5, 7);
+        let alpha = qm31(1, 3, 5, 7);
         let circle_domain = CanonicCoset::new(LOG_SIZE).circle_domain();
         let line_domain = LineDomain::new(circle_domain.half_coset);
 

diff --git a/crates/prover/src/core/backend/avx512/quotients.rs b/crates/prover/src/core/backend/avx512/quotients.rs
@@ -182,9 +182,9 @@ mod tests {
             CircleEvaluation::<AVX512Backend, _, BitReversedOrder>::new(domain, e0),
             CircleEvaluation::<AVX512Backend, _, BitReversedOrder>::new(domain, e1),
         ];
-        let random_coeff = qm31!(1, 2, 3, 4);
-        let a = qm31!(3, 6, 9, 12);
-        let b = qm31!(4, 8, 12, 16);
+        let random_coeff = qm31(1, 2, 3, 4);
+        let a = qm31(3, 6, 9, 12);
+        let b = qm31(4, 8, 12, 16);
         let samples = vec![ColumnSampleBatch {
             point: SECURE_FIELD_CIRCLE_GEN,
             columns_and_values: vec![(0, a), (1, b)],

diff --git a/crates/prover/src/core/backend/cpu/quotients.rs b/crates/prover/src/core/backend/cpu/quotients.rs
@@ -178,12 +178,12 @@ mod tests {
     #[test]
     fn test_quotients_are_low_degree() {
         const LOG_SIZE: u32 = 7;
-        let polynomial = CPUCirclePoly::new((0..1 << LOG_SIZE).map(|i| m31!(i)).collect());
+        let polynomial = CPUCirclePoly::new((0..1 << LOG_SIZE).map(m31).collect());
         let eval_domain = CanonicCoset::new(LOG_SIZE + 1).circle_domain();
         let eval = polynomial.evaluate(eval_domain);
         let point = SECURE_FIELD_CIRCLE_GEN;
         let value = polynomial.eval_at_point(point);
-        let coeff = qm31!(1, 2, 3, 4);
+        let coeff = qm31(1, 2, 3, 4);
         let quot_eval = CPUBackend::accumulate_quotients(
             eval_domain,
             &[&eval],

diff --git a/crates/prover/src/core/channel.rs b/crates/prover/src/core/channel.rs
@@ -257,7 +257,7 @@ mod tests {
         let initial_digest = Blake2sHash::from(vec![0; 32]);
         let mut channel = Blake2sChannel::new(initial_digest);
         let felts: Vec<SecureField> = (0..2)
-            .map(|i| SecureField::from(m31!(i + 1923782)))
+            .map(|i| SecureField::from(m31(i + 1923782)))
             .collect();
 
         channel.mix_felts(felts.as_slice());

diff --git a/crates/prover/src/core/constraints.rs b/crates/prover/src/core/constraints.rs
@@ -198,7 +198,7 @@ mod tests {
     #[test]
     fn test_complex_conjugate_symmetry() {
         // Create a polynomial over a base circle domain.
-        let polynomial = CPUCirclePoly::new((0..1 << 7).map(|i| m31!(i)).collect());
+        let polynomial = CPUCirclePoly::new((0..1 << 7).map(m31).collect());
         let oods_point = CirclePoint::get_point(9834759221);
 
         // Assert that the base field polynomial is complex conjugate symmetric.
@@ -213,7 +213,7 @@ mod tests {
         // Create a polynomial over a circle domain.
         let log_domain_size = 7;
         let domain_size = 1 << log_domain_size;
-        let polynomial = CPUCirclePoly::new((0..domain_size).map(|i| m31!(i)).collect());
+        let polynomial = CPUCirclePoly::new((0..domain_size).map(m31).collect());
 
         // Create a larger domain.
         let log_large_domain_size = log_domain_size + 1;

diff --git a/crates/prover/src/core/fields/cm31.rs b/crates/prover/src/core/fields/cm31.rs
@@ -61,11 +61,8 @@ impl FieldExpOps for CM31 {
 }
 
 #[cfg(test)]
-#[macro_export]
-macro_rules! cm31 {
-    ($m0:expr, $m1:expr) => {
-        CM31::from_u32_unchecked($m0, $m1)
-    };
+pub const fn cm31(m0: u32, m1: u32) -> CM31 {
+    CM31::from_u32_unchecked(m0, m1)
 }
 
 #[cfg(test)]
@@ -75,39 +72,39 @@ mod tests {
     use super::CM31;
     use crate::core::fields::m31::P;
     use crate::core::fields::{FieldExpOps, IntoSlice};
-    use crate::m31;
+    use crate::{cm31, m31};
 
     #[test]
     fn test_inverse() {
-        let cm = cm31!(1, 2);
+        let cm = cm31(1, 2);
         let cm_inv = cm.inverse();
-        assert_eq!(cm * cm_inv, cm31!(1, 0));
+        assert_eq!(cm * cm_inv, cm31(1, 0));
     }
 
     #[test]
     fn test_ops() {
-        let cm0 = cm31!(1, 2);
-        let cm1 = cm31!(4, 5);
-        let m = m31!(8);
+        let cm0 = cm31(1, 2);
+        let cm1 = cm31(4, 5);
+        let m = m31(8);
         let cm = CM31::from(m);
-        let cm0_x_cm1 = cm31!(P - 6, 13);
+        let cm0_x_cm1 = cm31(P - 6, 13);
 
-        assert_eq!(cm0 + cm1, cm31!(5, 7));
+        assert_eq!(cm0 + cm1, cm31(5, 7));
         assert_eq!(cm1 + m, cm1 + cm);
         assert_eq!(cm0 * cm1, cm0_x_cm1);
         assert_eq!(cm1 * m, cm1 * cm);
-        assert_eq!(-cm0, cm31!(P - 1, P - 2));
-        assert_eq!(cm0 - cm1, cm31!(P - 3, P - 3));
+        assert_eq!(-cm0, cm31(P - 1, P - 2));
+        assert_eq!(cm0 - cm1, cm31(P - 3, P - 3));
         assert_eq!(cm1 - m, cm1 - cm);
-        assert_eq!(cm0_x_cm1 / cm1, cm31!(1, 2));
+        assert_eq!(cm0_x_cm1 / cm1, cm31(1, 2));
         assert_eq!(cm1 / m, cm1 / cm);
     }
 
     #[test]
     fn test_into_slice() {
         let mut rng = rand::thread_rng();
         let x = (0..100)
-            .map(|_| cm31!(rng.gen::<u32>(), rng.gen::<u32>()))
+            .map(|_| cm31(rng.gen::<u32>(), rng.gen::<u32>()))
             .collect::<Vec<CM31>>();
 
         let slice = CM31::into_slice(&x);
@@ -116,7 +113,7 @@ mod tests {
             let corresponding_sub_slice = &slice[i * 8..(i + 1) * 8];
             assert_eq!(
                 x[i],
-                cm31!(
+                cm31(
                     u32::from_le_bytes(corresponding_sub_slice[..4].try_into().unwrap()),
                     u32::from_le_bytes(corresponding_sub_slice[4..].try_into().unwrap())
                 )

diff --git a/crates/prover/src/core/fields/m31.rs b/crates/prover/src/core/fields/m31.rs
@@ -126,18 +126,16 @@ impl From<i32> for M31 {
 }
 
 #[cfg(test)]
-#[macro_export]
-macro_rules! m31 {
-    ($m:expr) => {
-        $crate::core::fields::m31::M31::from_u32_unchecked($m)
-    };
+pub const fn m31(value: u32) -> M31 {
+    M31::from_u32_unchecked(value)
 }
 
 #[cfg(test)]
 mod tests {
     use rand::Rng;
 
     use super::{M31, P};
+    use crate::core::fields::m31::m31;
     use crate::core::fields::IntoSlice;
 
     fn mul_p(a: u32, b: u32) -> u32 {
@@ -162,25 +160,25 @@ mod tests {
         for _ in 0..10000 {
             let x: u32 = rng.gen::<u32>() % P;
             let y: u32 = rng.gen::<u32>() % P;
-            assert_eq!(m31!(add_p(x, y)), m31!(x) + m31!(y));
-            assert_eq!(m31!(mul_p(x, y)), m31!(x) * m31!(y));
-            assert_eq!(m31!(neg_p(x)), -m31!(x));
+            assert_eq!(m31(add_p(x, y)), m31(x) + m31(y));
+            assert_eq!(m31(mul_p(x, y)), m31(x) * m31(y));
+            assert_eq!(m31(neg_p(x)), -m31(x));
         }
     }
 
     #[test]
     fn test_into_slice() {
         let mut rng = rand::thread_rng();
         let x = (0..100)
-            .map(|_| m31!(rng.gen::<u32>()))
+            .map(|_| m31(rng.gen::<u32>()))
             .collect::<Vec<M31>>();
 
         let slice = M31::into_slice(&x);
 
         for i in 0..100 {
             assert_eq!(
                 x[i],
-                m31!(u32::from_le_bytes(
+                m31(u32::from_le_bytes(
                     slice[i * 4..(i + 1) * 4].try_into().unwrap()
                 ))
             );

diff --git a/crates/prover/src/core/fields/qm31.rs b/crates/prover/src/core/fields/qm31.rs
@@ -79,12 +79,8 @@ impl FieldExpOps for QM31 {
 }
 
 #[cfg(test)]
-#[macro_export]
-macro_rules! qm31 {
-    ($m0:expr, $m1:expr, $m2:expr, $m3:expr) => {{
-        use $crate::core::fields::qm31::QM31;
-        QM31::from_u32_unchecked($m0, $m1, $m2, $m3)
-    }};
+pub const fn qm31(m0: u32, m1: u32, m2: u32, m3: u32) -> QM31 {
+    QM31::from_u32_unchecked(m0, m1, m2, m3)
 }
 
 #[cfg(test)]
@@ -95,31 +91,31 @@ mod tests {
     use super::QM31;
     use crate::core::fields::m31::P;
     use crate::core::fields::{FieldExpOps, IntoSlice};
-    use crate::m31;
+    use crate::{m31, qm31};
 
     #[test]
     fn test_inverse() {
-        let qm = qm31!(1, 2, 3, 4);
+        let qm = qm31(1, 2, 3, 4);
         let qm_inv = qm.inverse();
         assert_eq!(qm * qm_inv, QM31::one());
     }
 
     #[test]
     fn test_ops() {
-        let qm0 = qm31!(1, 2, 3, 4);
-        let qm1 = qm31!(4, 5, 6, 7);
-        let m = m31!(8);
+        let qm0 = qm31(1, 2, 3, 4);
+        let qm1 = qm31(4, 5, 6, 7);
+        let m = m31(8);
         let qm = QM31::from(m);
-        let qm0_x_qm1 = qm31!(P - 71, 93, P - 16, 50);
+        let qm0_x_qm1 = qm31(P - 71, 93, P - 16, 50);
 
-        assert_eq!(qm0 + qm1, qm31!(5, 7, 9, 11));
+        assert_eq!(qm0 + qm1, qm31(5, 7, 9, 11));
         assert_eq!(qm1 + m, qm1 + qm);
         assert_eq!(qm0 * qm1, qm0_x_qm1);
         assert_eq!(qm1 * m, qm1 * qm);
-        assert_eq!(-qm0, qm31!(P - 1, P - 2, P - 3, P - 4));
-        assert_eq!(qm0 - qm1, qm31!(P - 3, P - 3, P - 3, P - 3));
+        assert_eq!(-qm0, qm31(P - 1, P - 2, P - 3, P - 4));
+        assert_eq!(qm0 - qm1, qm31(P - 3, P - 3, P - 3, P - 3));
         assert_eq!(qm1 - m, qm1 - qm);
-        assert_eq!(qm0_x_qm1 / qm1, qm31!(1, 2, 3, 4));
+        assert_eq!(qm0_x_qm1 / qm1, qm31(1, 2, 3, 4));
         assert_eq!(qm1 / m, qm1 / qm);
     }
 
@@ -128,11 +124,11 @@ mod tests {
         let mut rng = rand::thread_rng();
         let x = (0..100)
             .map(|_| {
-                qm31!(
+                qm31(
+                    rng.gen::<u32>(),
                     rng.gen::<u32>(),
                     rng.gen::<u32>(),
                     rng.gen::<u32>(),
-                    rng.gen::<u32>()
                 )
             })
             .collect::<Vec<QM31>>();
@@ -143,7 +139,7 @@ mod tests {
             let corresponding_sub_slice = &slice[i * 16..(i + 1) * 16];
             assert_eq!(
                 x[i],
-                qm31!(
+                qm31(
                     u32::from_le_bytes(corresponding_sub_slice[..4].try_into().unwrap()),
                     u32::from_le_bytes(corresponding_sub_slice[4..8].try_into().unwrap()),
                     u32::from_le_bytes(corresponding_sub_slice[8..12].try_into().unwrap()),

diff --git a/crates/prover/src/core/pcs/quotients.rs b/crates/prover/src/core/pcs/quotients.rs
@@ -187,12 +187,12 @@ mod tests {
     #[test]
     fn test_quotients_are_low_degree() {
         const LOG_SIZE: u32 = 7;
-        let polynomial = CPUCirclePoly::new((0..1 << LOG_SIZE).map(|i| m31!(i)).collect());
+        let polynomial = CPUCirclePoly::new((0..1 << LOG_SIZE).map(m31).collect());
         let eval_domain = CanonicCoset::new(LOG_SIZE + 1).circle_domain();
         let eval = polynomial.evaluate(eval_domain);
         let point = SECURE_FIELD_CIRCLE_GEN;
         let value = polynomial.eval_at_point(point);
-        let coeff = qm31!(1, 2, 3, 4);
+        let coeff = qm31(1, 2, 3, 4);
         let quot_eval =
             compute_fri_quotients(&[&eval], &[vec![PointSample { point, value }]], coeff)
                 .pop()

diff --git a/crates/prover/src/core/poly/circle/evaluation.rs b/crates/prover/src/core/poly/circle/evaluation.rs
@@ -170,7 +170,7 @@ mod tests {
         .bit_reverse();
         let poly = evaluation.interpolate();
         for (i, point) in domain.iter().enumerate() {
-            assert_eq!(poly.eval_at_point(point.into_ef()), m31!(i as u32).into());
+            assert_eq!(poly.eval_at_point(point.into_ef()), m31(i as u32).into());
         }
     }
 
@@ -183,14 +183,14 @@ mod tests {
         );
         let poly = evaluation.interpolate();
         for (i, point) in Coset::odds(3).iter().enumerate() {
-            assert_eq!(poly.eval_at_point(point.into_ef()), m31!(i as u32).into());
+            assert_eq!(poly.eval_at_point(point.into_ef()), m31(i as u32).into());
         }
     }
 
     #[test]
     pub fn test_get_at_circle_evaluation() {
         let domain = CanonicCoset::new(7).circle_domain();
-        let values = (0..domain.size()).map(|i| m31!(i as u32)).collect();
+        let values = (0..domain.size()).map(|i| m31(i as u32)).collect();
         let circle_evaluation = CPUCircleEvaluation::<_, NaturalOrder>::new(domain, values);
         let bit_reversed_circle_evaluation = circle_evaluation.clone().bit_reverse();
         for index in domain.iter_indices() {
@@ -204,7 +204,7 @@ mod tests {
     #[test]
     fn test_sub_evaluation() {
         let domain = CanonicCoset::new(7).circle_domain();
-        let values = (0..domain.size()).map(|i| m31!(i as u32)).collect();
+        let values = (0..domain.size()).map(|i| m31(i as u32)).collect();
         let circle_evaluation = CPUCircleEvaluation::new(domain, values);
         let coset = Coset::new(domain.index_at(17), 3);
         let sub_eval = circle_evaluation.fetch_eval_on_coset(coset);

diff --git a/crates/prover/src/core/prover/mod.rs b/crates/prover/src/core/prover/mod.rs
@@ -327,7 +327,7 @@ mod tests {
             _mask: &crate::core::ColumnVec<Vec<SecureField>>,
             evaluation_accumulator: &mut PointEvaluationAccumulator,
         ) {
-            evaluation_accumulator.accumulate(qm31!(0, 0, 0, 1))
+            evaluation_accumulator.accumulate(qm31(0, 0, 0, 1))
         }
     }