Unify API

Author: thomasarmel

src/lib.rs

@@ -136,38 +136,16 @@ pub trait BooleanFunctionImpl: Debug {
             .sum()
     }
 
-    /// Computes the Walsh-Hadamard values for all points.
-    ///
-    /// # Returns
-    /// A vector containing the Walsh-Hadamard values for all points.
-    #[deprecated(note = "Use `fast_walsh_hadamard_values` instead")]
-    fn walsh_hadamard_values(&self) -> Vec<i32> {
-        (0..=self.get_max_input_value())
-            .map(|w| self.walsh_hadamard_transform(w))
-            .collect()
-    }
-
     /// Computes the Walsh-Hadamard values for all points using fast Fourier transform.
     ///
     /// # Returns
     /// A vector containing the Walsh-Hadamard values for all points.
-    fn fast_walsh_hadamard_values(&self) -> Vec<i32> {
+    fn walsh_hadamard_values(&self) -> Vec<i32> {
         let mut values = vec![0; (self.get_max_input_value() + 1) as usize];
         for i in 0..=self.get_max_input_value() {
             values[i as usize] = 1 | -((self.compute_cellular_automata_rule(i)) as i32);
         }
-        let mut h = 1usize;
-        while h <= self.get_max_input_value() as usize {
-            for i in (0..=self.get_max_input_value() as usize).step_by(h * 2) {
-                for j in 0..h {
-                    let a = values[i + j];
-                    let b = values[i + j + h];
-                    values[i + j] = a + b;
-                    values[i + j + h] = a - b;
-                }
-            }
-            h *= 2;
-        }
+        utils::fast_walsh_transform(&mut values);
         values
     }
 
@@ -233,38 +211,16 @@ pub trait BooleanFunctionImpl: Debug {
             .sum()
     }
 
-    /// Computes the Walsh-Fourier values for all points.
-    ///
-    /// # Returns
-    /// A vector containing the Walsh-Fourier values for all points.
-    #[deprecated(note = "Use `fast_walsh_fourier_values` instead")]
-    fn walsh_fourier_values(&self) -> Vec<i32> {
-        (0..=self.get_max_input_value())
-            .map(|w| self.walsh_fourier_transform(w))
-            .collect()
-    }
-
     /// Computes the Walsh-Fourier values for all points using fast Fourier transform.
     ///
     /// # Returns
     /// A vector containing the Walsh-Fourier values for all points.
-    fn fast_walsh_fourier_values(&self) -> Vec<i32> {
+    fn walsh_fourier_values(&self) -> Vec<i32> {
         let mut values = vec![0; (self.get_max_input_value() + 1) as usize];
         for i in 0..=self.get_max_input_value() {
             values[i as usize] = self.compute_cellular_automata_rule(i) as i32;
         }
-        let mut h = 1usize;
-        while h <= self.get_max_input_value() as usize {
-            for i in (0..=self.get_max_input_value() as usize).step_by(h * 2) {
-                for j in 0..h {
-                    let a = values[i + j];
-                    let b = values[i + j + h];
-                    values[i + j] = a + b;
-                    values[i + j + h] = a - b;
-                }
-            }
-            h *= 2;
-        }
+        utils::fast_walsh_transform(&mut values);
         values
     }
 
@@ -1882,27 +1838,6 @@ mod tests {
         );
     }
 
-    #[test]
-    fn test_fast_walsh_hadamard_values() {
-        let boolean_function = BooleanFunction::from_hex_string_truth_table("dd0e").unwrap();
-        assert_eq!(
-            boolean_function.fast_walsh_hadamard_values(),
-            [-2, -2, 6, -2, -6, 2, 2, 2, 6, 6, -2, 6, -6, 2, 2, 2]
-        );
-
-        let boolean_function = BooleanFunction::from_hex_string_truth_table("0000").unwrap();
-        assert_eq!(
-            boolean_function.fast_walsh_hadamard_values(),
-            [16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
-        );
-
-        let boolean_function = BooleanFunction::from_hex_string_truth_table("ffff").unwrap();
-        assert_eq!(
-            boolean_function.fast_walsh_hadamard_values(),
-            [-16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
-        );
-    }
-
     #[test]
     fn test_boolean_function_from_reverse_walsh_transform() {
         let boolean_function = BooleanFunction::from_reverse_walsh_hadamard_transform(&[
@@ -2479,45 +2414,6 @@ mod tests {
         );
     }
 
-    #[test]
-    fn test_fast_walsh_fourier_values() {
-        let boolean_function = BooleanFunction::from_hex_string_truth_table("ff").unwrap();
-        assert_eq!(
-            boolean_function.fast_walsh_fourier_values(),
-            [8, 0, 0, 0, 0, 0, 0, 0]
-        );
-
-        let boolean_function = BooleanFunction::from_hex_string_truth_table("00").unwrap();
-        assert_eq!(
-            boolean_function.fast_walsh_fourier_values(),
-            [0, 0, 0, 0, 0, 0, 0, 0]
-        );
-
-        let boolean_function = BooleanFunction::from_hex_string_truth_table("0f").unwrap();
-        assert_eq!(
-            boolean_function.fast_walsh_fourier_values(),
-            [4, 0, 0, 0, 4, 0, 0, 0]
-        );
-
-        let boolean_function = BooleanFunction::from_hex_string_truth_table("55").unwrap();
-        assert_eq!(
-            boolean_function.fast_walsh_fourier_values(),
-            [4, 4, 0, 0, 0, 0, 0, 0]
-        );
-
-        let boolean_function = BooleanFunction::from_hex_string_truth_table("aa").unwrap();
-        assert_eq!(
-            boolean_function.fast_walsh_fourier_values(),
-            [4, -4, 0, 0, 0, 0, 0, 0]
-        );
-
-        let boolean_function = BooleanFunction::from_hex_string_truth_table("8001").unwrap();
-        assert_eq!(
-            boolean_function.fast_walsh_fourier_values(),
-            [2, 0, 0, 2, 0, 2, 2, 0, 0, 2, 2, 0, 2, 0, 0, 2]
-        );
-    }
-
     #[test]
     fn test_boolean_function_from_reverse_walsh_fourier_transform() {
         let boolean_function =

src/utils.rs

@@ -134,6 +134,26 @@ pub(crate) fn fast_anf_transform_biguint(truth_table: &BigUint, variables_count:
     anf_form
 }
 
+pub(crate) fn fast_walsh_transform(values: &mut [i32]) {
+    let values_count = values.len();
+    #[cfg(not(feature = "unsafe_disable_safety_checks"))]
+    if values_count < 1 || !values_count.is_power_of_two() {
+        panic!("fast_walsh_transform: values length must be a power of 2");
+    }
+    let mut h = 1usize;
+    while h < values_count {
+        for i in (0..values_count).step_by(h * 2) {
+            for j in 0..h {
+                let a = values[i + j];
+                let b = values[i + j + h];
+                values[i + j] = a + b;
+                values[i + j + h] = a - b;
+            }
+        }
+        h <<= 1;
+    }
+}
+
 #[allow(dead_code)] // maybe useless, but I keep it for the beauty of the code
 pub(crate) fn walsh_matrix(dim: usize) -> Vec<Vec<i8>> {
     (0usize..(1 << dim))