finish msm

Author: quangvdao

ec/src/scalar_mul/variable_base/mod.rs

@@ -16,6 +16,7 @@ pub mod stream_pippenger;
 pub use stream_pippenger::*;
 
 use super::ScalarMul;
+use ark_ff::biginteger::{U128OrI128, U64OrI64};
 
 #[cfg(all(
     target_has_atomic = "8",
@@ -644,6 +645,106 @@ pub fn msm_u128<V: VariableBaseMSM>(
         .sum()
 }
 
+/// MSM over mixed-signed 64-bit integers using the small-scalar engine.
+pub fn msm_u64_or_i64<V: VariableBaseMSM>(
+    mut bases: &[V::MulBase],
+    mut scalars: &[U64OrI64],
+    serial: bool,
+) -> V {
+    // Partition by sign for better locality; build magnitudes as u64.
+    let (negative_bases, non_negative_bases): (Vec<V::MulBase>, Vec<V::MulBase>) =
+        bases
+            .iter()
+            .enumerate()
+            .partition_map(|(i, b)| if scalars[i].is_negative() {
+                Either::Left(b)
+            } else {
+                Either::Right(b)
+            });
+    let (negative_scalars, non_negative_scalars): (Vec<u64>, Vec<u64>) = scalars
+        .iter()
+        .partition_map(|s| match *s {
+            U64OrI64::Unsigned(u) => Either::Right(u),
+            U64OrI64::Signed(v) => {
+                if v < 0 {
+                    Either::Left(v.unsigned_abs())
+                } else {
+                    Either::Right(v as u64)
+                }
+            }
+        });
+
+    if serial {
+        return msm_serial::<V, _>(&non_negative_bases, &non_negative_scalars)
+            - msm_serial::<V, _>(&negative_bases, &negative_scalars);
+    } else {
+        let chunk_size = match preamble(&mut bases, &mut scalars, serial) {
+            Some(chunk_size) => chunk_size,
+            None => return V::zero(),
+        };
+
+        let non_negative_msm: V = cfg_chunks!(non_negative_bases, chunk_size)
+            .zip(cfg_chunks!(non_negative_scalars, chunk_size))
+            .map(|(b, s)| msm_serial::<V, _>(b, s))
+            .sum();
+        let negative_msm: V = cfg_chunks!(negative_bases, chunk_size)
+            .zip(cfg_chunks!(negative_scalars, chunk_size))
+            .map(|(b, s)| msm_serial::<V, _>(b, s))
+            .sum();
+        non_negative_msm - negative_msm
+    }
+}
+
+/// MSM over mixed-signed 128-bit integers.
+pub fn msm_u128_or_i128<V: VariableBaseMSM>(
+    mut bases: &[V::MulBase],
+    mut scalars: &[U128OrI128],
+    serial: bool,
+) -> V {
+    // u128 path with sign partitioning.
+    let (negative_bases, non_negative_bases): (Vec<V::MulBase>, Vec<V::MulBase>) = bases
+        .iter()
+        .enumerate()
+        .partition_map(|(i, b)| if match scalars[i] { U128OrI128::Signed(v) if v < 0 => true, _ => false } {
+            Either::Left(b)
+        } else {
+            Either::Right(b)
+        });
+    let (negative_scalars, non_negative_scalars): (Vec<u128>, Vec<u128>) = scalars
+        .iter()
+        .partition_map(|s| match *s {
+            U128OrI128::Unsigned(u) => Either::Right(u),
+            U128OrI128::Signed(v) => {
+                let abs = v.unsigned_abs();
+                if v < 0 {
+                    Either::Left(abs)
+                } else {
+                    Either::Right(abs)
+                }
+            }
+        });
+
+    if serial {
+        msm_serial::<V, _>(&non_negative_bases, &non_negative_scalars)
+            - msm_serial::<V, _>(&negative_bases, &negative_scalars)
+    } else {
+        let chunk_size = match preamble(&mut bases, &mut scalars, serial) {
+            Some(chunk_size) => chunk_size,
+            None => return V::zero(),
+        };
+
+        let non_negative_msm: V = cfg_chunks!(non_negative_bases, chunk_size)
+            .zip(cfg_chunks!(non_negative_scalars, chunk_size))
+            .map(|(b, s)| msm_serial::<V, _>(b, s))
+            .sum();
+        let negative_msm: V = cfg_chunks!(negative_bases, chunk_size)
+            .zip(cfg_chunks!(negative_scalars, chunk_size))
+            .map(|(b, s)| msm_serial::<V, _>(b, s))
+            .sum();
+        non_negative_msm - negative_msm
+    }
+}
+
 // Compute msm using windowed non-adjacent form
 fn msm_bigint_wnaf_parallel<V: VariableBaseMSM>(
     bases: &[V::MulBase],

ff/src/biginteger/mod.rs

@@ -29,6 +29,9 @@ use zeroize::Zeroize;
 #[macro_use]
 pub mod arithmetic;
 
+pub mod types;
+pub use types::{U128OrI128, U64OrI64};
+
 #[derive(Copy, Clone, PartialEq, Eq, Hash, Zeroize)]
 pub struct BigInt<const N: usize>(pub [u64; N]);
 

ff/src/biginteger/types.rs

@@ -6,18 +6,17 @@
 ///
 /// Helper methods provide width-aware projections to `u64`/`i64` and a
 /// canonical unsigned representation for lookup key construction.
-use allocative::Allocative;
 use ark_serialize::{
     CanonicalDeserialize, CanonicalSerialize, Compress, SerializationError, Valid, Validate,
 };
 
-#[derive(Copy, Clone, Debug, PartialEq, Eq, Allocative)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
 pub enum U64OrI64 {
     Unsigned(u64),
     Signed(i64),
 }
 
-#[derive(Copy, Clone, Debug, PartialEq, Eq, Allocative)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
 pub enum U128OrI128 {
     Unsigned(u128),
     Signed(i128),
@@ -101,6 +100,21 @@ impl U64OrI64 {
             _ => panic!("{XLEN}-bit word size is unsupported"),
         }
     }
+
+    /// Returns true if the value is negative.
+    #[inline]
+    pub fn is_negative(&self) -> bool {
+        match *self {
+            U64OrI64::Unsigned(_) => false,
+            U64OrI64::Signed(s) => s < 0,
+        }
+    }
+
+    /// Returns true if the value is nonnegative (>= 0).
+    #[inline]
+    pub fn is_positive(&self) -> bool {
+        !self.is_negative()
+    }
 }
 
 impl U128OrI128 {
@@ -119,6 +133,21 @@ impl U128OrI128 {
             U128OrI128::Signed(s) => s,
         }
     }
+
+    /// Returns true if the value is negative.
+    #[inline]
+    pub fn is_negative(&self) -> bool {
+        match *self {
+            U128OrI128::Unsigned(_) => false,
+            U128OrI128::Signed(s) => s < 0,
+        }
+    }
+
+    /// Returns true if the value is nonnegative (>= 0).
+    #[inline]
+    pub fn is_positive(&self) -> bool {
+        !self.is_negative()
+    }
 }
 
 impl core::cmp::PartialOrd for U64OrI64 {
@@ -208,7 +237,7 @@ impl Valid for U128OrI128 {
 }
 
 impl CanonicalSerialize for U64OrI64 {
-    fn serialize_with_mode<W: std::io::Write>(
+    fn serialize_with_mode<W: ark_std::io::Write>(
         &self,
         mut writer: W,
         compress: Compress,
@@ -235,7 +264,7 @@ impl CanonicalSerialize for U64OrI64 {
 }
 
 impl CanonicalDeserialize for U64OrI64 {
-    fn deserialize_with_mode<R: std::io::Read>(
+    fn deserialize_with_mode<R: ark_std::io::Read>(
         mut reader: R,
         compress: Compress,
         _validate: Validate,
@@ -256,7 +285,7 @@ impl CanonicalDeserialize for U64OrI64 {
 }
 
 impl CanonicalSerialize for U128OrI128 {
-    fn serialize_with_mode<W: std::io::Write>(
+    fn serialize_with_mode<W: ark_std::io::Write>(
         &self,
         mut writer: W,
         compress: Compress,
@@ -283,7 +312,7 @@ impl CanonicalSerialize for U128OrI128 {
 }
 
 impl CanonicalDeserialize for U128OrI128 {
-    fn deserialize_with_mode<R: std::io::Read>(
+    fn deserialize_with_mode<R: ark_std::io::Read>(
         mut reader: R,
         compress: Compress,
         _validate: Validate,