fmt batch_size of cpa

examples/cpa.rs

@@ -20,21 +20,21 @@ fn cpa() {
     let start_sample: usize = 0;
     let end_sample: usize = 5000;
     let size: usize = end_sample - start_sample; // Number of samples
-    let patch: usize = 500;
+    let batch: usize = 500;
     let guess_range = 256; // 2**(key length)
     let folder = String::from("../../data/cw");
     let dir_l = format!("{folder}/leakages.npy");
     let dir_p = format!("{folder}/plaintexts.npy");
     let leakages: Array2<FormatTraces> = read_array_2_from_npy_file::<FormatTraces>(&dir_l);
     let plaintext: Array2<FormatMetadata> = read_array_2_from_npy_file::<FormatMetadata>(&dir_p);
     let len_traces = leakages.shape()[0];
-    let mut cpa_parallel = ((0..len_traces).step_by(patch))
+    let mut cpa_parallel = ((0..len_traces).step_by(batch))
         .progress_with(progress_bar(len_traces))
         .map(|row| row)
         .par_bridge()
         .map(|row_number| {
-            let mut cpa = Cpa::new(size, patch, guess_range, leakage_model);
-            let range_rows = row_number..row_number + patch;
+            let mut cpa = Cpa::new(size, batch, guess_range, leakage_model);
+            let range_rows = row_number..row_number + batch;
             let range_samples = start_sample..end_sample;
             let sample_traces = leakages
                 .slice(s![range_rows.clone(), range_samples])
@@ -45,7 +45,7 @@ fn cpa() {
             cpa
         })
         .reduce(
-            || Cpa::new(size, patch, guess_range, leakage_model),
+            || Cpa::new(size, batch, guess_range, leakage_model),
             |x, y| x + y,
         );
     cpa_parallel.finalize();
@@ -58,12 +58,12 @@ fn success() {
     let start_sample: usize = 0;
     let end_sample: usize = 5000;
     let size: usize = end_sample - start_sample; // Number of samples
-    let patch: usize = 500;
+    let batch: usize = 500;
     let guess_range = 256; // 2**(key length)
     let folder = String::from("../data/log_584012"); // "../../../intenship/scripts/log_584012"
     let nfiles = 13; // Number of files in the directory. TBD: Automating this value
     let rank_traces: usize = 1000;
-    let mut cpa = Cpa::new(size, patch, guess_range, leakage_model);
+    let mut cpa = Cpa::new(size, batch, guess_range, leakage_model);
     cpa.success_traces(rank_traces);
     for i in (0..nfiles).progress() {
         let dir_l = format!("{folder}/l/{i}.npy");
@@ -72,9 +72,9 @@ fn success() {
         let plaintext: Array2<FormatMetadata> =
             read_array_2_from_npy_file::<FormatMetadata>(&dir_p);
         let len_leakages = leakages.shape()[0];
-        for row in (0..len_leakages).step_by(patch) {
+        for row in (0..len_leakages).step_by(batch) {
             let range_samples = start_sample..end_sample;
-            let range_rows: std::ops::Range<usize> = row..row + patch;
+            let range_rows: std::ops::Range<usize> = row..row + batch;
             let range_metadat = 0..plaintext.shape()[1];
             let sample_traces = leakages
                 .slice(s![range_rows.clone(), range_samples])

src/cpa_normal.rs

@@ -25,19 +25,19 @@ https://www.iacr.org/archive/ches2004/31560016/31560016.pdf */
 impl Cpa {
     pub fn new(
         size: usize,
-        patch: usize,
+        batch: usize,
         guess_range: i32,
         f: fn(ArrayView1<usize>, usize) -> usize,
     ) -> Self {
         Self {
             len_samples: size,
-            chunk: patch,
+            chunk: batch,
             guess_range,
             sum_leakages: Array1::zeros(size),
             sum2_leakages: Array1::zeros(size),
             sum_keys: Array1::zeros(guess_range as usize),
             sum2_keys: Array1::zeros(guess_range as usize),
-            values: Array2::zeros((patch, guess_range as usize)),
+            values: Array2::zeros((batch, guess_range as usize)),
             cov: Array2::zeros((guess_range as usize, size)),
             corr: Array2::zeros((guess_range as usize, size)),
             max_corr: Array2::zeros((guess_range as usize, 1)),
@@ -48,15 +48,15 @@ impl Cpa {
         }
     }
 
-    pub fn update<T: Copy, U: Copy>(&mut self, trace_patch: Array2<T>, plaintext_patch: Array2<U>)
+    pub fn update<T: Copy, U: Copy>(&mut self, trace_batch: Array2<T>, plaintext_batch: Array2<U>)
     where
         f32: From<T>,
         usize: From<U>,
     {
         /* This function updates the internal arrays of the CPA
-        It accepts trace_patch and plaintext_patch to update them*/
-        let tmp_traces = trace_patch.map(|t| f32::from(*t));
-        let metadat = plaintext_patch.map(|m| usize::from(*m));
+        It accepts trace_batch and plaintext_batch to update them*/
+        let tmp_traces = trace_batch.map(|t| f32::from(*t));
+        let metadat = plaintext_batch.map(|m| usize::from(*m));
         self.len_leakages += self.chunk;
         self.update_values(&metadat, &tmp_traces, self.guess_range);
         self.update_key_leakages(tmp_traces, self.guess_range);
@@ -98,14 +98,14 @@ impl Cpa {
 
     pub fn update_success<T: Copy, U: Copy>(
         &mut self,
-        trace_patch: Array2<T>,
-        plaintext_patch: Array2<U>,
+        trace_batch: Array2<T>,
+        plaintext_batch: Array2<U>,
     ) where
         f32: From<T>,
         usize: From<U>,
     {
         /* This function updates the main arrays of the CPA for the success rate*/
-        self.update(trace_patch, plaintext_patch);
+        self.update(trace_batch, plaintext_batch);
         if self.len_leakages % self.rank_traces == 0 {
             self.finalize();
             if self.len_leakages == self.rank_traces {