perf: avoid creating a temporary vec in slice ops mul add (#852)

# Rationale for this change
The `mul_add_assign` module has a `mul_add_assign` function that is only
used by the `MultilinearExtension` `mul_add` function. When calling
`mul_add_assign`, a temporary vector is created with the
`slice_ops::slice_cast(self) call. We don't need to create this
temporary vector. Avoiding this creation will improve performance and
memory allocation.

Before, `24.35ms`

![image](https://github.com/user-attachments/assets/02765073-b80c-43bb-9936-f06f99b0e6cc)

After, `15.72ms`, `1.55x` improvement

![image](https://github.com/user-attachments/assets/8f27c1b0-7db7-46bb-8024-995278051f98)


# What changes are included in this PR?
- `mul_add_assign` is updated to not require a temporary vector
- The `MultilinearExtension` trait no longer creates a temporary vector
when calling `mul_add_assign`
- Tests are updated to call `mul_add_assign` correctly

# Are these changes tested?
Yes

Author: jacobtrombetta

crates/proof-of-sql/src/base/polynomial/multilinear_extension.rs

@@ -39,7 +39,7 @@ where
     }
 
     fn mul_add(&self, res: &mut [S], multiplier: &S) {
-        slice_ops::mul_add_assign(res, *multiplier, &slice_ops::slice_cast(self));
+        slice_ops::mul_add_assign(res, *multiplier, self);
     }
 
     fn to_sumcheck_term(&self, num_vars: usize) -> Vec<S> {

crates/proof-of-sql/src/base/slice_ops/mul_add_assign.rs

@@ -3,22 +3,24 @@ use core::ops::{AddAssign, Mul};
 #[cfg(feature = "rayon")]
 use rayon::iter::{IndexedParallelIterator, IntoParallelRefMutIterator, ParallelIterator};
 
-/// This operation does `result[i] += multiplier * to_mul_add[i]` for `i` in `0..to_mul_add.len()`.
+/// This operation does `result[i] += multiplier * to_mul_add[i]` for `i` in `0..to_mul_add.len()`
+/// without creating temporary vectors. Works directly with slice references.
 ///
 /// # Panics
 /// Panics if the length of `result` is less than the length of `to_mul_add`.
-pub fn mul_add_assign<T, S>(result: &mut [T], multiplier: T, to_mul_add: &[S])
+pub fn mul_add_assign<'a, T, S>(result: &mut [T], multiplier: T, to_mul_add: &'a [S])
 where
     T: Send + Sync + Mul<Output = T> + AddAssign + Copy,
-    S: Into<T> + Sync + Copy,
+    &'a S: Into<T>,
+    S: Sync,
 {
     assert!(result.len() >= to_mul_add.len(), "The length of result must be greater than or equal to the length of the vector of values to be multiplied and added");
     if_rayon!(
         result.par_iter_mut().with_min_len(super::MIN_RAYON_LEN),
         result.iter_mut()
     )
     .zip(to_mul_add)
-    .for_each(|(res_i, &data_i)| {
+    .for_each(|(res_i, data_i)| {
         *res_i += multiplier * data_i.into();
     });
 }

crates/proof-of-sql/src/base/slice_ops/mul_add_assign_test.rs

@@ -3,20 +3,24 @@ use crate::base::scalar::test_scalar::TestScalar;
 
 #[test]
 fn test_mul_add_assign() {
-    let mut a = vec![1, 2, 3, 4];
+    let mut a = [1, 2, 3, 4].map(TestScalar::from).to_vec();
     let b = vec![2, 3, 4, 5];
-    mul_add_assign(&mut a, 10, &b);
-    let c = vec![1 + 10 * 2, 2 + 10 * 3, 3 + 10 * 4, 4 + 10 * 5];
+    mul_add_assign(&mut a, TestScalar::from(10i32), &b);
+    let c = [1 + 10 * 2, 2 + 10 * 3, 3 + 10 * 4, 4 + 10 * 5]
+        .map(TestScalar::from)
+        .to_vec();
     assert_eq!(a, c);
 }
 
 /// test [`mul_add_assign`] with uneven vectors
 #[test]
 fn test_mul_add_assign_uneven() {
-    let mut a = vec![1, 2, 3, 4, 5];
-    let b = vec![2, 3, 4, 5];
-    mul_add_assign(&mut a, 10, &b);
-    let c = vec![1 + 10 * 2, 2 + 10 * 3, 3 + 10 * 4, 4 + 10 * 5, 5];
+    let mut a = [1, 2, 3, 4, 5].map(TestScalar::from).to_vec();
+    let b = [2, 3, 4, 5].map(TestScalar::from).to_vec();
+    mul_add_assign(&mut a, TestScalar::from(10u32), &b);
+    let c = [1 + 10 * 2, 2 + 10 * 3, 3 + 10 * 4, 4 + 10 * 5, 5]
+        .map(TestScalar::from)
+        .to_vec();
     assert_eq!(a, c);
 }
 
@@ -26,38 +30,27 @@ fn test_mul_add_assign_uneven() {
     expected = "The length of result must be greater than or equal to the length of the vector of values to be multiplied and added"
 )]
 fn test_mul_add_assign_uneven_panic() {
-    let mut a = vec![1, 2, 3, 4];
+    let mut a = [1u32, 2u32, 3u32, 4u32].map(TestScalar::from).to_vec();
     let b = vec![2, 3, 4, 5, 6];
-    mul_add_assign(&mut a, 10, &b);
+    mul_add_assign(&mut a, TestScalar::from(10u32), &b);
 }
 
 /// test [`mul_add_assign`] with `TestScalar`
 #[test]
 fn test_mul_add_assign_testscalar() {
-    let mut a = vec![TestScalar::from(1u64), TestScalar::from(2u64)];
-    let b = vec![TestScalar::from(2u64), TestScalar::from(3u64)];
+    let mut a = [1, 2].map(TestScalar::from).to_vec();
+    let b = [2, 3].map(TestScalar::from).to_vec();
     mul_add_assign(&mut a, TestScalar::from(10u64), &b);
-    let c = vec![
-        TestScalar::from(1u64) + TestScalar::from(10u64) * TestScalar::from(2u64),
-        TestScalar::from(2u64) + TestScalar::from(10u64) * TestScalar::from(3u64),
-    ];
+    let c = [1 + 10 * 2, 2 + 10 * 3].map(TestScalar::from).to_vec();
     assert_eq!(a, c);
 }
 
 /// test [`mul_add_assign`] with uneven `TestScalar`
 #[test]
 fn test_mul_add_assign_testscalar_uneven() {
-    let mut a = vec![
-        TestScalar::from(1u64),
-        TestScalar::from(2u64),
-        TestScalar::from(3u64),
-    ];
-    let b = vec![TestScalar::from(2u64), TestScalar::from(3u64)];
+    let mut a = [1, 2, 3].map(TestScalar::from).to_vec();
+    let b = [2, 3].map(TestScalar::from).to_vec();
     mul_add_assign(&mut a, TestScalar::from(10u64), &b);
-    let c = vec![
-        TestScalar::from(1u64) + TestScalar::from(10u64) * TestScalar::from(2u64),
-        TestScalar::from(2u64) + TestScalar::from(10u64) * TestScalar::from(3u64),
-        TestScalar::from(3u64),
-    ];
+    let c = [1 + 10 * 2, 2 + 10 * 3, 3].map(TestScalar::from).to_vec();
     assert_eq!(a, c);
 }