avoid warnings

poulpy-backend/src/cpu_spqlios/fft64/vec_znx.rs

@@ -59,7 +59,7 @@ where
         res_basek: usize,
         res: &mut R,
         res_col: usize,
-        a_basek: usize,
+        _a_basek: usize,
         a: &A,
         a_col: usize,
         scratch: &mut Scratch<Self>,
@@ -74,7 +74,7 @@ where
         {
             assert_eq!(res.n(), a.n());
             assert_eq!(
-                res_basek, a_basek,
+                res_basek, _a_basek,
                 "res_basek != a_basek -> base2k conversion is not supported"
             )
         }

poulpy-hal/src/reference/vec_znx/merge_rings.rs

@@ -18,26 +18,26 @@ where
 {
     let mut res: VecZnx<&mut [u8]> = res.to_mut();
 
-    let (n_out, n_in) = (res.n(), a[0].to_ref().n());
+    let (_n_out, _n_in) = (res.n(), a[0].to_ref().n());
 
     #[cfg(debug_assertions)]
     {
         assert_eq!(tmp.len(), res.n());
 
         debug_assert!(
-            n_out > n_in,
+            _n_out > _n_in,
             "invalid a: output ring degree should be greater"
         );
         a[1..].iter().for_each(|ai| {
             debug_assert_eq!(
                 ai.to_ref().n(),
-                n_in,
+                _n_in,
                 "invalid input a: all VecZnx must have the same degree"
             )
         });
 
-        assert!(n_out.is_multiple_of(n_in));
+        assert!(_n_out.is_multiple_of(_n_in));
-        assert_eq!(a.len(), n_out / n_in);
+        assert_eq!(a.len(), _n_out / _n_in);
     }
 
     a.iter().for_each(|ai| {

poulpy-hal/src/reference/vec_znx/split_ring.rs

@@ -16,27 +16,27 @@ where
     let a: VecZnx<&[u8]> = a.to_ref();
     let a_size = a.size();
 
-    let (n_in, n_out) = (a.n(), res[0].to_mut().n());
+    let (_n_in, _n_out) = (a.n(), res[0].to_mut().n());
 
     #[cfg(debug_assertions)]
     {
         assert_eq!(tmp.len(), a.n());
 
         assert!(
-            n_out < n_in,
+            _n_out < _n_in,
             "invalid a: output ring degree should be smaller"
         );
 
         res[1..].iter_mut().for_each(|bi| {
             assert_eq!(
                 bi.to_mut().n(),
-                n_out,
+                _n_out,
                 "invalid input a: all VecZnx must have the same degree"
             )
         });
 
-        assert!(n_in.is_multiple_of(n_out));
+        assert!(_n_in.is_multiple_of(_n_out));
-        assert_eq!(res.len(), n_in / n_out);
+        assert_eq!(res.len(), _n_in / _n_out);
     }
 
     res.iter_mut().enumerate().for_each(|(i, bi)| {