module-lattice: fix ci failures

Author: tob-scott-a

module-lattice/tests/algebra.rs

@@ -322,7 +322,7 @@ fn ntt_polynomial_from_array() {
 
     let coeffs: Array<Elem<KyberField>, hybrid_array::typenum::U256> =
         core::array::from_fn(|i| Elem::new((i % 3329) as u16)).into();
-    let p: NttPolynomial<KyberField> = coeffs.clone().into();
+    let p: NttPolynomial<KyberField> = coeffs.into();
 
     assert_eq!(p.0[0].0, 0);
     assert_eq!(p.0[1].0, 1);

module-lattice/tests/encode.rs

@@ -2,7 +2,7 @@
 
 use hybrid_array::typenum::{U1, U4, U10, U12};
 use module_lattice::algebra::{Elem, NttPolynomial, NttVector, Polynomial, Vector};
-use module_lattice::encode::{byte_decode, byte_encode, Encode};
+use module_lattice::encode::{Encode, byte_decode, byte_encode};
 
 // Field used by ML-KEM.
 module_lattice::define_field!(KyberField, u16, u32, u64, 3329);
@@ -14,88 +14,69 @@ module_lattice::define_field!(KyberField, u16, u32, u64, 3329);
 #[test]
 fn byte_encode_decode_d1_roundtrip() {
     // D=1: Single bit encoding
-    let mut vals = [Elem::<KyberField>::new(0); 256];
-    for i in 0..256 {
-        vals[i] = Elem::new((i % 2) as u16);
-    }
+    let vals: [Elem<KyberField>; 256] = core::array::from_fn(|i| Elem::new((i % 2) as u16));
 
     let encoded = byte_encode::<KyberField, U1>(&vals.into());
     let decoded = byte_decode::<KyberField, U1>(&encoded);
 
-    for i in 0..256 {
-        assert_eq!(decoded[i].0, vals[i].0, "Mismatch at index {i}");
+    for (i, (dec, val)) in decoded.iter().zip(vals.iter()).enumerate() {
+        assert_eq!(dec.0, val.0, "Mismatch at index {i}");
     }
 }
 
 #[test]
 fn byte_encode_decode_d4_roundtrip() {
     // D=4: 4-bit encoding
-    let mut vals = [Elem::<KyberField>::new(0); 256];
-    for i in 0..256 {
-        vals[i] = Elem::new((i % 16) as u16);
-    }
+    let vals: [Elem<KyberField>; 256] = core::array::from_fn(|i| Elem::new((i % 16) as u16));
 
     let encoded = byte_encode::<KyberField, U4>(&vals.into());
     let decoded = byte_decode::<KyberField, U4>(&encoded);
 
-    for i in 0..256 {
-        assert_eq!(decoded[i].0, vals[i].0, "Mismatch at index {i}");
+    for (i, (dec, val)) in decoded.iter().zip(vals.iter()).enumerate() {
+        assert_eq!(dec.0, val.0, "Mismatch at index {i}");
     }
 }
 
 #[test]
 fn byte_encode_decode_d10_roundtrip() {
     // D=10: 10-bit encoding
-    let mut vals = [Elem::<KyberField>::new(0); 256];
-    for i in 0..256 {
-        vals[i] = Elem::new((i % 1024) as u16);
-    }
+    let vals: [Elem<KyberField>; 256] = core::array::from_fn(|i| Elem::new((i % 1024) as u16));
 
     let encoded = byte_encode::<KyberField, U10>(&vals.into());
     let decoded = byte_decode::<KyberField, U10>(&encoded);
 
-    for i in 0..256 {
-        assert_eq!(decoded[i].0, vals[i].0, "Mismatch at index {i}");
+    for (i, (dec, val)) in decoded.iter().zip(vals.iter()).enumerate() {
+        assert_eq!(dec.0, val.0, "Mismatch at index {i}");
     }
 }
 
 #[test]
 fn byte_encode_decode_d12_roundtrip() {
     // D=12: 12-bit encoding (special case with modular reduction)
-    let mut vals = [Elem::<KyberField>::new(0); 256];
-    for i in 0..256 {
-        // Values up to q-1 (3328)
-        vals[i] = Elem::new((i * 13) as u16 % 3329);
-    }
+    // Values up to q-1 (3328)
+    let vals: [Elem<KyberField>; 256] = core::array::from_fn(|i| Elem::new((i * 13) as u16 % 3329));
 
     let encoded = byte_encode::<KyberField, U12>(&vals.into());
     let decoded = byte_decode::<KyberField, U12>(&encoded);
 
-    for i in 0..256 {
-        assert_eq!(decoded[i].0, vals[i].0, "Mismatch at index {i}");
+    for (i, (dec, val)) in decoded.iter().zip(vals.iter()).enumerate() {
+        assert_eq!(dec.0, val.0, "Mismatch at index {i}");
     }
 }
 
 #[test]
 fn byte_encode_decode_d12_modular_reduction() {
     // Test that D=12 properly reduces values >= Q
-    let mut vals = [Elem::<KyberField>::new(0); 256];
-
     // Fill with values near and above Q
-    for i in 0..256 {
-        vals[i] = Elem::new(3329 + (i as u16) % 100); // Values >= Q
-    }
+    let vals: [Elem<KyberField>; 256] =
+        core::array::from_fn(|i| Elem::new(3329 + (i as u16) % 100));
 
     let encoded = byte_encode::<KyberField, U12>(&vals.into());
     let decoded = byte_decode::<KyberField, U12>(&encoded);
 
     // After decode, values should be reduced mod Q
-    for i in 0..256 {
-        assert!(
-            decoded[i].0 < 3329,
-            "Value at {i} not reduced: {}",
-            decoded[i].0
-        );
+    for (i, dec) in decoded.iter().enumerate() {
+        assert!(dec.0 < 3329, "Value at {i} not reduced: {}", dec.0);
     }
 }
 
@@ -106,8 +87,8 @@ fn byte_encode_zero_values() {
     let encoded = byte_encode::<KyberField, U4>(&vals.into());
     let decoded = byte_decode::<KyberField, U4>(&encoded);
 
-    for i in 0..256 {
-        assert_eq!(decoded[i].0, 0);
+    for dec in &decoded {
+        assert_eq!(dec.0, 0);
     }
 }
 
@@ -119,8 +100,8 @@ fn byte_encode_max_values() {
     let encoded = byte_encode::<KyberField, U4>(&vals.into());
     let decoded = byte_decode::<KyberField, U4>(&encoded);
 
-    for i in 0..256 {
-        assert_eq!(decoded[i].0, 15);
+    for dec in &decoded {
+        assert_eq!(dec.0, 15);
     }
 }
 
@@ -130,10 +111,7 @@ fn byte_encode_max_values() {
 
 #[test]
 fn polynomial_encode_decode_roundtrip() {
-    let mut coeffs = [Elem::<KyberField>::new(0); 256];
-    for i in 0..256 {
-        coeffs[i] = Elem::new((i * 7) as u16 % 16);
-    }
+    let coeffs: [Elem<KyberField>; 256] = core::array::from_fn(|i| Elem::new((i * 7) as u16 % 16));
     let p = Polynomial::<KyberField>::new(coeffs.into());
 
     let encoded = <Polynomial<KyberField> as Encode<U4>>::encode(&p);
@@ -144,10 +122,8 @@ fn polynomial_encode_decode_roundtrip() {
 
 #[test]
 fn polynomial_encode_decode_d12() {
-    let mut coeffs = [Elem::<KyberField>::new(0); 256];
-    for i in 0..256 {
-        coeffs[i] = Elem::new((i * 13) as u16 % 3329);
-    }
+    let coeffs: [Elem<KyberField>; 256] =
+        core::array::from_fn(|i| Elem::new((i * 13) as u16 % 3329));
     let p = Polynomial::<KyberField>::new(coeffs.into());
 
     let encoded = <Polynomial<KyberField> as Encode<U12>>::encode(&p);
@@ -164,12 +140,8 @@ fn polynomial_encode_decode_d12() {
 fn vector_encode_decode_roundtrip() {
     use hybrid_array::typenum::U2;
 
-    let mut coeffs1 = [Elem::<KyberField>::new(0); 256];
-    let mut coeffs2 = [Elem::<KyberField>::new(0); 256];
-    for i in 0..256 {
-        coeffs1[i] = Elem::new((i * 3) as u16 % 16);
-        coeffs2[i] = Elem::new((i * 5) as u16 % 16);
-    }
+    let coeffs1: [Elem<KyberField>; 256] = core::array::from_fn(|i| Elem::new((i * 3) as u16 % 16));
+    let coeffs2: [Elem<KyberField>; 256] = core::array::from_fn(|i| Elem::new((i * 5) as u16 % 16));
 
     let p1 = Polynomial::<KyberField>::new(coeffs1.into());
     let p2 = Polynomial::<KyberField>::new(coeffs2.into());
@@ -187,10 +159,7 @@ fn vector_encode_decode_roundtrip() {
 
 #[test]
 fn ntt_polynomial_encode_decode_roundtrip() {
-    let mut coeffs = [Elem::<KyberField>::new(0); 256];
-    for i in 0..256 {
-        coeffs[i] = Elem::new((i * 7) as u16 % 16);
-    }
+    let coeffs: [Elem<KyberField>; 256] = core::array::from_fn(|i| Elem::new((i * 7) as u16 % 16));
     let p = NttPolynomial::<KyberField>::new(coeffs.into());
 
     let encoded = <NttPolynomial<KyberField> as Encode<U4>>::encode(&p);
@@ -201,10 +170,8 @@ fn ntt_polynomial_encode_decode_roundtrip() {
 
 #[test]
 fn ntt_polynomial_encode_decode_d12() {
-    let mut coeffs = [Elem::<KyberField>::new(0); 256];
-    for i in 0..256 {
-        coeffs[i] = Elem::new((i * 13) as u16 % 3329);
-    }
+    let coeffs: [Elem<KyberField>; 256] =
+        core::array::from_fn(|i| Elem::new((i * 13) as u16 % 3329));
     let p = NttPolynomial::<KyberField>::new(coeffs.into());
 
     let encoded = <NttPolynomial<KyberField> as Encode<U12>>::encode(&p);
@@ -221,12 +188,8 @@ fn ntt_polynomial_encode_decode_d12() {
 fn ntt_vector_encode_decode_roundtrip() {
     use hybrid_array::typenum::U2;
 
-    let mut coeffs1 = [Elem::<KyberField>::new(0); 256];
-    let mut coeffs2 = [Elem::<KyberField>::new(0); 256];
-    for i in 0..256 {
-        coeffs1[i] = Elem::new((i * 3) as u16 % 16);
-        coeffs2[i] = Elem::new((i * 5) as u16 % 16);
-    }
+    let coeffs1: [Elem<KyberField>; 256] = core::array::from_fn(|i| Elem::new((i * 3) as u16 % 16));
+    let coeffs2: [Elem<KyberField>; 256] = core::array::from_fn(|i| Elem::new((i * 5) as u16 % 16));
 
     let p1 = NttPolynomial::<KyberField>::new(coeffs1.into());
     let p2 = NttPolynomial::<KyberField>::new(coeffs2.into());
@@ -269,7 +232,7 @@ fn encoded_vector_size() {
     // D=4, K=3: 128 bytes per polynomial * 3 = 384 bytes
     let coeffs = [Elem::<KyberField>::new(0); 256];
     let p = Polynomial::<KyberField>::new(coeffs.into());
-    let v: Vector<KyberField, U3> = Vector::new([p.clone(), p.clone(), p].into());
+    let v: Vector<KyberField, U3> = Vector::new([p, p, p].into());
 
     let encoded = <Vector<KyberField, U3> as Encode<U4>>::encode(&v);
     assert_eq!(encoded.len(), 384);
@@ -282,31 +245,26 @@ fn encoded_vector_size() {
 #[test]
 fn byte_encode_alternating_bits() {
     // Test alternating patterns to catch bit manipulation issues
-    let mut vals = [Elem::<KyberField>::new(0); 256];
-    for i in 0..256 {
-        vals[i] = Elem::new(if i % 2 == 0 { 0b0101 } else { 0b1010 });
-    }
+    let vals: [Elem<KyberField>; 256] =
+        core::array::from_fn(|i| Elem::new(if i % 2 == 0 { 0b0101 } else { 0b1010 }));
 
     let encoded = byte_encode::<KyberField, U4>(&vals.into());
     let decoded = byte_decode::<KyberField, U4>(&encoded);
 
-    for i in 0..256 {
-        assert_eq!(decoded[i].0, vals[i].0, "Mismatch at index {i}");
+    for (i, (dec, val)) in decoded.iter().zip(vals.iter()).enumerate() {
+        assert_eq!(dec.0, val.0, "Mismatch at index {i}");
     }
 }
 
 #[test]
 fn byte_encode_sequential_values() {
     // Sequential values to catch ordering issues
-    let mut vals = [Elem::<KyberField>::new(0); 256];
-    for i in 0..256 {
-        vals[i] = Elem::new(i as u16 % 16);
-    }
+    let vals: [Elem<KyberField>; 256] = core::array::from_fn(|i| Elem::new(i as u16 % 16));
 
     let encoded = byte_encode::<KyberField, U4>(&vals.into());
     let decoded = byte_decode::<KyberField, U4>(&encoded);
 
-    for i in 0..256 {
-        assert_eq!(decoded[i].0, vals[i].0, "Mismatch at index {i}");
+    for (i, (dec, val)) in decoded.iter().zip(vals.iter()).enumerate() {
+        assert_eq!(dec.0, val.0, "Mismatch at index {i}");
     }
 }