binfield: usize -> enum (#126)

src/field/binary_towers/extension.rs

@@ -300,7 +300,7 @@ pub(super) fn multiply(a: &[BinaryField], b: &[BinaryField], k: usize) -> Vec<Bi
 
   // r1r2*X_{i-2}
   // X_{i-2}: a+b*x where a, b are vectors of length K/4, with a = 0, b = 1
-  let mut x_i_high = vec![BinaryField::new(0); 1 << (k - 1)];
+  let mut x_i_high = vec![BinaryField::Zero; 1 << (k - 1)];
   x_i_high[quarterlen] = BinaryField::ONE;
   let r1r2_high = multiply(&x_i_high, &r1r2, k - 1);
 
@@ -321,9 +321,12 @@ fn add_vec(lhs: &[BinaryField], rhs: &[BinaryField]) -> Vec<BinaryField> {
 pub(super) fn to_bool_vec(mut num: u64, length: usize) -> Vec<BinaryField> {
   let mut result = Vec::new();
   while num > 0 {
-    result.push(BinaryField::new(((num & 1) != 0) as u8));
+    result.push(match num & 1 {
+      0 => BinaryField::Zero,
+      _ => BinaryField::One,
+    });
     num >>= 1;
   }
-  result.extend(std::iter::repeat(BinaryField::new(0)).take(length - result.len()));
+  result.extend(std::iter::repeat(BinaryField::Zero).take(length - result.len()));
   result
 }

src/field/binary_towers/mod.rs

@@ -13,41 +13,51 @@ pub use extension::BinaryTowers;
 
 /// binary field containing element `{0,1}`
 #[derive(Debug, Default, Hash, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
-pub struct BinaryField(u8);
-
-impl BinaryField {
-  /// create new binary field element
-  pub const fn new(value: u8) -> Self {
-    debug_assert!(value < 2, "value should be less than 2");
-    Self(value)
-  }
+pub enum BinaryField {
+  /// binary field element `0`
+  #[default]
+  Zero,
+  /// binary field element `1`
+  One,
 }
 
 impl FiniteField for BinaryField {
-  const ONE: Self = BinaryField(1);
+  const ONE: Self = BinaryField::One;
   const ORDER: usize = 2;
   const PRIMITIVE_ELEMENT: Self = Self::ONE;
-  const ZERO: Self = BinaryField(0);
+  const ZERO: Self = BinaryField::Zero;
 
   fn inverse(&self) -> Option<Self> {
-    if *self == Self::ZERO {
-      return None;
+    match *self {
+      Self::Zero => None,
+      Self::One => Some(Self::One),
     }
-    Some(*self)
   }
 
   fn pow(self, _: usize) -> Self { self }
 }
 
 impl From<usize> for BinaryField {
-  fn from(value: usize) -> Self { Self::new(value as u8) }
+  fn from(value: usize) -> Self {
+    match value {
+      0 => BinaryField::Zero,
+      1 => BinaryField::One,
+      _ => panic!("Invalid `usize` value. Must be 0 or 1."),
+    }
+  }
 }
 
 impl Add for BinaryField {
   type Output = Self;
 
   #[allow(clippy::suspicious_arithmetic_impl)]
-  fn add(self, rhs: Self) -> Self::Output { BinaryField::new(self.0 ^ rhs.0) }
+  fn add(self, rhs: Self) -> Self::Output {
+    if self == rhs {
+      Self::ZERO
+    } else {
+      Self::ONE
+    }
+  }
 }
 
 impl AddAssign for BinaryField {
@@ -64,7 +74,13 @@ impl Sub for BinaryField {
   type Output = Self;
 
   #[allow(clippy::suspicious_arithmetic_impl)]
-  fn sub(self, rhs: Self) -> Self::Output { BinaryField(self.0 ^ rhs.0) }
+  fn sub(self, rhs: Self) -> Self::Output {
+    if self == rhs {
+      Self::ZERO
+    } else {
+      Self::ONE
+    }
+  }
 }
 
 impl SubAssign for BinaryField {
@@ -81,7 +97,12 @@ impl Mul for BinaryField {
   type Output = Self;
 
   #[allow(clippy::suspicious_arithmetic_impl)]
-  fn mul(self, rhs: Self) -> Self::Output { BinaryField(self.0 & rhs.0) }
+  fn mul(self, rhs: Self) -> Self::Output {
+    match (self, rhs) {
+      (Self::One, Self::One) => Self::ONE,
+      _ => Self::ZERO,
+    }
+  }
 }
 
 impl MulAssign for BinaryField {
@@ -98,7 +119,7 @@ impl Div for BinaryField {
   type Output = Self;
 
   #[allow(clippy::suspicious_arithmetic_impl)]
-  fn div(self, rhs: Self) -> Self::Output { self * rhs.inverse().unwrap() }
+  fn div(self, rhs: Self) -> Self::Output { self * rhs.inverse().expect("divide by zero") }
 }
 
 impl DivAssign for BinaryField {

src/field/binary_towers/tests.rs

@@ -133,7 +133,7 @@ pub(super) fn num_digits(n: u64) -> usize {
 fn from_bool_vec(num: Vec<BinaryField>) -> u64 {
   let mut result: u64 = 0;
   for (i, &bit) in num.iter().rev().enumerate() {
-    if bit.0 == 1 {
+    if bit == BinaryField::One {
       result |= 1 << (num.len() - 1 - i);
     }
   }
@@ -146,20 +146,20 @@ fn from_bool_vec(num: Vec<BinaryField>) -> u64 {
 #[should_panic]
 #[case(1, 0)]
 fn binary_field_arithmetic(#[case] a: usize, #[case] b: usize) {
-  let arg1 = BinaryField::new(a as u8);
-  let arg2 = BinaryField::new(b as u8);
+  let arg1 = BinaryField::from(a);
+  let arg2 = BinaryField::from(b);
   let a_test = TestBinaryField::new(a);
   let b_test = TestBinaryField::new(b);
 
-  assert_eq!((arg1 + arg2).0, (a_test + b_test).value as u8);
+  assert_eq!((arg1 + arg2), BinaryField::from((a_test + b_test).value));
   assert_eq!(arg1 - arg2, arg1 + arg2);
-  assert_eq!((arg1 * arg2).0, (a_test * b_test).value as u8);
+  assert_eq!((arg1 * arg2), BinaryField::from((a_test * b_test).value));
 
   let inv_res = arg2.inverse();
   assert!(inv_res.is_some());
   assert_eq!(inv_res.unwrap(), arg2);
 
-  assert_eq!((arg1 / arg2).0, (a_test / b_test).value as u8);
+  assert_eq!((arg1 / arg2), BinaryField::from((a_test / b_test).value));
 }
 
 #[rstest]