Unify vector-like structs

ext/crates/fp/src/matrix/matrix_inner.rs

@@ -367,12 +367,12 @@ impl Matrix {
 
     pub fn row(&self, row: usize) -> FpSlice<'_> {
         let limb_range = row_to_limb_range(row, self.stride);
-        FpSlice::new(self.prime(), &self.data[limb_range], 0, self.columns)
+        FpSlice::_new(self.prime(), &self.data[limb_range], 0, self.columns)
     }
 
     pub fn row_mut(&mut self, row: usize) -> FpSliceMut<'_> {
         let limb_range = row_to_limb_range(row, self.stride);
-        FpSliceMut::new(self.prime(), &mut self.data[limb_range], 0, self.columns)
+        FpSliceMut::_new(self.prime(), &mut self.data[limb_range], 0, self.columns)
     }
 }
 
@@ -393,7 +393,7 @@ impl Matrix {
                 .data
                 .chunks_mut(self.stride)
                 .take(logical_rows) // Only iterate over logical rows
-                .map(move |row| FpSliceMut::new(p, row, 0, columns));
+                .map(move |row| FpSliceMut::_new(p, row, 0, columns));
             Either::Right(rows)
         }
     }
@@ -412,7 +412,7 @@ impl Matrix {
                 .data
                 .maybe_par_chunks_mut(self.stride)
                 .take(logical_rows) // Only iterate over logical rows
-                .map(move |row| FpSliceMut::new(p, row, 0, columns));
+                .map(move |row| FpSliceMut::_new(p, row, 0, columns));
             Either::Right(rows)
         }
     }
@@ -516,8 +516,8 @@ impl Matrix {
         let row1 = unsafe { std::slice::from_raw_parts_mut(ptr.add(i * self.stride), self.stride) };
         let row2 = unsafe { std::slice::from_raw_parts_mut(ptr.add(j * self.stride), self.stride) };
         (
-            FpSliceMut::new(self.prime(), row1, 0, self.columns),
-            FpSliceMut::new(self.prime(), row2, 0, self.columns),
+            FpSliceMut::_new(self.prime(), row1, 0, self.columns),
+            FpSliceMut::_new(self.prime(), row2, 0, self.columns),
         )
     }
 
@@ -1263,7 +1263,7 @@ impl<const N: usize> AugmentedMatrix<N> {
         let start_idx = self.start[start];
         let end_idx = self.end[end];
         let limb_range = row_to_limb_range(i, self.stride);
-        FpSliceMut::new(self.prime(), &mut self.data[limb_range], start_idx, end_idx)
+        FpSliceMut::_new(self.prime(), &mut self.data[limb_range], start_idx, end_idx)
     }
 
     pub fn row_segment(&self, i: usize, start: usize, end: usize) -> FpSlice<'_> {
@@ -1414,7 +1414,7 @@ impl<'a> MatrixSliceMut<'a> {
         let end = self.col_end;
         (0..self.rows).map(move |row_idx| {
             let limb_range = row_to_limb_range(row_idx, self.stride);
-            FpSlice::new(self.prime(), &self.data[limb_range], start, end)
+            FpSlice::_new(self.prime(), &self.data[limb_range], start, end)
         })
     }
 
@@ -1429,7 +1429,7 @@ impl<'a> MatrixSliceMut<'a> {
             let rows = self
                 .data
                 .chunks_mut(self.stride)
-                .map(move |row| FpSliceMut::new(p, row, start, end));
+                .map(move |row| FpSliceMut::_new(p, row, start, end));
             Either::Right(rows)
         }
     }
@@ -1447,14 +1447,14 @@ impl<'a> MatrixSliceMut<'a> {
             let rows = self
                 .data
                 .maybe_par_chunks_mut(self.stride)
-                .map(move |row| FpSliceMut::new(p, row, start, end));
+                .map(move |row| FpSliceMut::_new(p, row, start, end));
             Either::Right(rows)
         }
     }
 
     pub fn row(&mut self, row: usize) -> FpSlice<'_> {
         let limb_range = row_to_limb_range(row, self.stride);
-        FpSlice::new(
+        FpSlice::_new(
             self.prime(),
             &self.data[limb_range],
             self.col_start,
@@ -1464,7 +1464,7 @@ impl<'a> MatrixSliceMut<'a> {
 
     pub fn row_mut(&mut self, row: usize) -> FpSliceMut<'_> {
         let limb_range = row_to_limb_range(row, self.stride);
-        FpSliceMut::new(
+        FpSliceMut::_new(
             self.prime(),
             &mut self.data[limb_range],
             self.col_start,

ext/crates/fp/src/vector/fp_wrapper/helpers.rs

@@ -14,38 +14,36 @@
 
 use itertools::Itertools;
 
-use super::{FqSlice, FqSliceMut, FqVector, FqVectorIterator, FqVectorNonZeroIterator};
+use super::{
+    FqSlice, FqSliceMut, FqVector, FqVectorBase, FqVectorIterator, FqVectorNonZeroIterator, Repr,
+    ReprMut,
+};
 use crate::field::Field;
 
-impl<F: Field> FqVector<F> {
-    pub(super) fn scale_helper(&mut self, c: F::ElementContainer) {
-        self.scale(self.fq().el(c))
-    }
-
+impl<const A: bool, R: Repr, F: Field> FqVectorBase<A, R, F> {
     pub(super) fn entry_helper(&self, index: usize) -> F::ElementContainer {
         self.entry(index).val()
     }
+}
 
-    pub(super) fn set_entry_helper(&mut self, index: usize, value: F::ElementContainer) {
-        self.set_entry(index, self.fq().el(value))
-    }
-
-    pub(super) fn add_helper(&mut self, other: &Self, c: F::ElementContainer) {
-        self.add(other, self.fq().el(c))
+impl<const A: bool, R: ReprMut, F: Field> FqVectorBase<A, R, F> {
+    pub(super) fn scale_helper(&mut self, c: F::ElementContainer) {
+        self.scale(self.fq().el(c))
     }
 
-    pub(super) fn add_offset_helper(
-        &mut self,
-        other: &Self,
-        c: F::ElementContainer,
-        offset: usize,
-    ) {
-        self.add_offset(other, self.fq().el(c), offset)
+    pub(super) fn set_entry_helper(&mut self, index: usize, value: F::ElementContainer) {
+        self.set_entry(index, self.fq().el(value))
     }
 
     pub(super) fn add_basis_element_helper(&mut self, index: usize, value: F::ElementContainer) {
         self.add_basis_element(index, self.fq().el(value))
     }
+}
+
+impl<F: Field> FqVector<F> {
+    pub(super) fn add_helper(&mut self, other: &Self, c: F::ElementContainer) {
+        self.add(other, self.fq().el(c))
+    }
 
     pub(super) fn copy_from_slice_helper(&mut self, other: &[F::ElementContainer]) {
         self.copy_from_slice(&other.iter().map(|x| self.fq().el(x.clone())).collect_vec())
@@ -71,26 +69,27 @@ impl<F: Field> FqVector<F> {
         self.add_carry(other, self.fq().el(c), rest)
     }
 
+    pub(super) fn add_offset_helper(
+        &mut self,
+        other: &Self,
+        c: F::ElementContainer,
+        offset: usize,
+    ) {
+        self.add_offset(other, self.fq().el(c), offset)
+    }
+
     pub(super) fn first_nonzero_helper(&self) -> Option<(usize, F::ElementContainer)> {
         self.first_nonzero().map(|(idx, c)| (idx, c.val()))
     }
 }
 
 impl<F: Field> FqSlice<'_, F> {
-    pub(super) fn entry_helper(&self, index: usize) -> F::ElementContainer {
-        self.entry(index).val()
-    }
-
     pub(super) fn first_nonzero_helper(&self) -> Option<(usize, F::ElementContainer)> {
         self.first_nonzero().map(|(idx, c)| (idx, c.val()))
     }
 }
 
 impl<F: Field> FqSliceMut<'_, F> {
-    pub(super) fn scale_helper(&mut self, c: F::ElementContainer) {
-        self.scale(self.fq().el(c))
-    }
-
     pub(super) fn add_helper(&mut self, other: FqSlice<F>, c: F::ElementContainer) {
         self.add(other, self.fq().el(c))
     }
@@ -104,14 +103,6 @@ impl<F: Field> FqSliceMut<'_, F> {
         self.add_offset(other, self.fq().el(c), offset)
     }
 
-    pub(super) fn set_entry_helper(&mut self, index: usize, value: F::ElementContainer) {
-        self.set_entry(index, self.fq().el(value))
-    }
-
-    pub(super) fn add_basis_element_helper(&mut self, index: usize, value: F::ElementContainer) {
-        self.add_basis_element(index, self.fq().el(value))
-    }
-
     pub(super) fn add_masked_helper(
         &mut self,
         other: FqSlice<F>,