Add support for ADD and MUL operation on BooleanFunction, SmallBooleanFunction, BigBooleanFunction and AnfPolynomial

Author: thomasarmel

src/anf_polynom.rs

@@ -6,7 +6,7 @@ use itertools::Itertools;
 use num_bigint::BigUint;
 use num_traits::{FromPrimitive, One, ToPrimitive, Zero};
 use std::fmt::Display;
-use std::ops::{BitAnd, BitAndAssign, BitXor, BitXorAssign};
+use std::ops::{Add, AddAssign, BitAnd, BitAndAssign, BitXor, BitXorAssign, Mul, MulAssign};
 use fast_boolean_anf_transform::fast_bool_anf_transform_unsigned;
 use crate::{BigBooleanFunction, BooleanFunction, BooleanFunctionError, SmallBooleanFunction};
 use crate::utils::fast_anf_transform_biguint;
@@ -307,6 +307,31 @@ impl BitXor for AnfPolynomial {
     }
 }
 
+/// ADD operator for Boolean functions ANF polynomial.
+///
+/// It is equivalent to [crate::AnfPolynomial::bitxor] operator.
+///
+/// # Panics
+/// If the Boolean functions have different number of variables, and the `unsafe_disable_safety_checks` feature is not enabled.
+impl Add for AnfPolynomial {
+    type Output = Self;
+    fn add(self, rhs: Self) -> Self::Output {
+        self ^ rhs
+    }
+}
+
+/// In-place ADD operator for Boolean functions ANF polynomial.
+///
+/// It is equivalent to [crate::AnfPolynomial::bitxor_assign] operator.
+///
+/// # Panics
+/// If the Boolean functions have different number of variables, and the `unsafe_disable_safety_checks` feature is not enabled.
+impl AddAssign for AnfPolynomial {
+    fn add_assign(&mut self, rhs: Self) {
+        *self ^= rhs;
+    }
+}
+
 /// In-place AND operator for Boolean functions ANF polynomial
 ///
 /// # Panics
@@ -391,6 +416,31 @@ impl BitAnd for AnfPolynomial {
     }
 }
 
+/// MUL operator for Boolean functions ANF polynomial.
+///
+/// It is equivalent to [crate::AnfPolynomial::bitand] operator.
+///
+/// # Panics
+/// If the Boolean functions have different number of variables, and the `unsafe_disable_safety_checks` feature is not enabled.
+impl Mul for AnfPolynomial {
+    type Output = Self;
+    fn mul(self, rhs: Self) -> Self::Output {
+        self & rhs
+    }
+}
+
+/// In-place MUL operator for Boolean functions ANF polynomial.
+///
+/// It is equivalent to [crate::AnfPolynomial::bitand_assign] operator.
+///
+/// # Panics
+/// If the Boolean functions have different number of variables, and the `unsafe_disable_safety_checks` feature is not enabled.
+impl MulAssign for AnfPolynomial {
+    fn mul_assign(&mut self, rhs: Self) {
+        *self &= rhs;
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use crate::anf_polynom::AnfPolynomial;
@@ -594,6 +644,23 @@ mod tests {
         assert_eq!(anf_2.to_string(), "x0*x1*x2 + x0*x2 + x0 + x2 + 1");
     }
 
+    #[test]
+    fn test_add() {
+        let anf_1 = AnfPolynomial::from_str("x0*x1*x4*x7 + x2*x3 + x1 + 0", 8).unwrap();
+        let mut anf_2 = AnfPolynomial::from_str("x0*x1*x2*x4*x7 + x2*x3 + x3 + 1", 8).unwrap();
+        let anf_3 = anf_1.clone() + anf_2.clone();
+        assert_eq!(anf_3.to_string(), "x0*x1*x2*x4*x7 + x0*x1*x4*x7 + x1 + x3 + 1");
+        anf_2 += anf_1;
+        assert_eq!(anf_2.to_string(), "x0*x1*x2*x4*x7 + x0*x1*x4*x7 + x1 + x3 + 1");
+
+        let anf_1 = AnfPolynomial::from_str("x0*x1 + x0 + x1 + x2", 3).unwrap();
+        let mut anf_2 = AnfPolynomial::from_str("x0*x1*x2 + x0*x2 + x1*x0 + x1 + 1", 3).unwrap();
+        let anf_3 = anf_1.clone() + anf_2.clone();
+        assert_eq!(anf_3.to_string(), "x0*x1*x2 + x0*x2 + x0 + x2 + 1");
+        anf_2 += anf_1;
+        assert_eq!(anf_2.to_string(), "x0*x1*x2 + x0*x2 + x0 + x2 + 1");
+    }
+
     #[test]
     fn test_and() {
         let anf_1 = AnfPolynomial::from_str("x0*x1", 3).unwrap();
@@ -687,4 +754,21 @@ mod tests {
         anf_2 &= anf_1;
         assert_eq!(anf_2.to_string(), "x5*x6*x7 + x4*x5 + x4*x6 + x3*x7 + x3 + x6 + x7 + 1");
     }
+
+    #[test]
+    fn test_mul() {
+        let anf_1 = AnfPolynomial::from_str("x0*x1 + x0 + x1 + x2", 3).unwrap();
+        let mut anf_2 = AnfPolynomial::from_str("x0*x1 + x0*x1*x2 + x1 + 1", 3).unwrap();
+        let anf_3 = anf_1.clone() * anf_2.clone();
+        assert_eq!(anf_3.to_string(), "x0*x1*x2 + x1*x2 + x0 + x2");
+        anf_2 *= anf_1;
+        assert_eq!(anf_2.to_string(), "x0*x1*x2 + x1*x2 + x0 + x2");
+
+        let anf_1 = AnfPolynomial::from_str("x3*x7 + x3 + x4*x5 + x4*x6 + x5*x6*x7 + x6 + x7 + 1", 8).unwrap();
+        let mut anf_2 = AnfPolynomial::from_str("x3*x5*x6*x7 + x3*x6*x7 + x3*x6 + x3*x7 + x3 + x4*x5*x6 + x4*x5*x7 + x4*x7 + x4 + x6*x7 + x6 + x7 + 1", 8).unwrap();
+        let anf_3 = anf_1.clone() * anf_2.clone();
+        assert_eq!(anf_3.to_string(), "x3*x4*x5*x7 + x3*x4*x5 + x4*x5*x6 + x3*x4*x7 + x4*x5*x7 + x3*x6*x7 + x3*x4 + x3*x6 + x3*x7 + x4*x7 + x6*x7 + x3 + x4 + x6 + x7 + 1");
+        anf_2 *= anf_1;
+        assert_eq!(anf_2.to_string(), "x3*x4*x5*x7 + x3*x4*x5 + x4*x5*x6 + x3*x4*x7 + x4*x5*x7 + x3*x6*x7 + x3*x4 + x3*x6 + x3*x7 + x4*x7 + x6*x7 + x3 + x4 + x6 + x7 + 1");
+    }
 }

src/big_boolean_function.rs

@@ -10,7 +10,7 @@ use itertools::{enumerate, Itertools};
 use num_bigint::BigUint;
 use num_integer::binomial;
 use num_traits::{FromPrimitive, One, Zero};
-use std::ops::{BitAnd, BitAndAssign, BitXor, BitXorAssign, Not};
+use std::ops::{Add, AddAssign, BitAnd, BitAndAssign, BitXor, BitXorAssign, Mul, MulAssign, Not};
 
 /// Struct representing a boolean function with a big truth table.
 ///
@@ -461,6 +461,32 @@ impl BitXor for BigBooleanFunction {
     }
 }
 
+/// ADD operator for Boolean functions truth tables.
+///
+/// It is equivalent to [crate::BigBooleanFunction::bitxor] operator.
+///
+/// # Panics
+/// If the Boolean functions have different number of variables, and the `unsafe_disable_safety_checks` feature is not enabled.
+impl Add for BigBooleanFunction {
+    type Output = Self;
+
+    fn add(self, rhs: Self) -> Self::Output {
+        self ^ rhs
+    }
+}
+
+/// In-place ADD operator for Boolean functions truth tables.
+///
+/// It is equivalent to [crate::BigBooleanFunction::bitxor_assign] operator.
+///
+/// # Panics
+/// If the Boolean functions have different number of variables, and the `unsafe_disable_safety_checks` feature is not enabled.
+impl AddAssign for BigBooleanFunction {
+    fn add_assign(&mut self, rhs: Self) {
+        *self ^= rhs;
+    }
+}
+
 /// In-place AND operator for Boolean functions truth tables.
 ///
 /// # Panics
@@ -488,6 +514,31 @@ impl BitAnd for BigBooleanFunction {
     }
 }
 
+/// MUL operator for Boolean functions truth tables.
+///
+/// It is equivalent to [crate::BigBooleanFunction::bitand] operator.
+///
+/// # Panics
+/// If the Boolean functions have different number of variables, and the `unsafe_disable_safety_checks` feature is not enabled.
+impl Mul for BigBooleanFunction {
+    type Output = Self;
+    fn mul(self, rhs: Self) -> Self::Output {
+        self & rhs
+    }
+}
+
+/// In-place MUL operator for Boolean functions truth tables.
+///
+/// It is equivalent to [crate::BigBooleanFunction::bitand_assign] operator.
+///
+/// # Panics
+/// If the Boolean functions have different number of variables, and the `unsafe_disable_safety_checks` feature is not enabled.
+impl MulAssign for BigBooleanFunction {
+    fn mul_assign(&mut self, rhs: Self) {
+        *self &= rhs;
+    }
+}
+
 /// NOT operator for Boolean functions.
 ///
 /// This is equivalent to the [crate::BooleanFunctionImpl::reverse] operation: it reverses each output of the Boolean function.
@@ -936,6 +987,30 @@ mod tests {
         assert_eq!(boolean_function3.variables_count(), 7);
     }
 
+    #[test]
+    fn test_add() {
+        let mut boolean_function = BigBooleanFunction::from_truth_table(
+            BigUint::from_str_radix("80921c010276c440400810a80e200425", 16).unwrap(),
+            7,
+        );
+        let boolean_function2 = BigBooleanFunction::from_truth_table(
+            BigUint::from_str_radix("22442244118811882244224411881188", 16).unwrap(),
+            7,
+        );
+        let boolean_function3 = boolean_function.clone() + boolean_function2.clone();
+        boolean_function += boolean_function2;
+        assert_eq!(
+            boolean_function.printable_hex_truth_table(),
+            "a2d63e4513fed5c8624c32ec1fa815ad"
+        );
+        assert_eq!(boolean_function.variables_count(), 7);
+        assert_eq!(
+            boolean_function3.printable_hex_truth_table(),
+            "a2d63e4513fed5c8624c32ec1fa815ad"
+        );
+        assert_eq!(boolean_function3.variables_count(), 7);
+    }
+
     #[test]
     fn test_and() {
         let mut boolean_function = BigBooleanFunction::from_truth_table(
@@ -960,6 +1035,30 @@ mod tests {
         assert_eq!(boolean_function3.variables_count(), 8);
     }
 
+    #[test]
+    fn test_mul() {
+        let mut boolean_function = BigBooleanFunction::from_truth_table(
+            BigUint::from_str_radix("4f1ead396f247a0410bdb210c006eab568ab4bfa8acb7a13b14ede67096c6eed", 16).unwrap(),
+            8,
+        );
+        let boolean_function2 = BigBooleanFunction::from_truth_table(
+            BigUint::from_str_radix("c870974094ead8a96a450b2ef33486b4e61a4c5e97816f7a7bae007d4c53fc7d", 16).unwrap(),
+            8,
+        );
+        let boolean_function3 = boolean_function.clone() * boolean_function2.clone();
+        boolean_function *= boolean_function2;
+        assert_eq!(
+            boolean_function.printable_hex_truth_table(),
+            "481085000420580000050200c00482b4600a485a82816a12310e006508406c6d"
+        );
+        assert_eq!(boolean_function.variables_count(), 8);
+        assert_eq!(
+            boolean_function3.printable_hex_truth_table(),
+            "481085000420580000050200c00482b4600a485a82816a12310e006508406c6d"
+        );
+        assert_eq!(boolean_function3.variables_count(), 8);
+    }
+
     #[test]
     fn test_biguint_truth_table() {
         let boolean_function = BigBooleanFunction::from_truth_table(