use a bincode PR to implement derived Encode and Decode with StateMap as context

Author: lcnbr

Cargo.toml

@@ -21,7 +21,7 @@ inherits = "dev"
 opt-level = 3
 
 [lib]
-crate-type = ["lib"]
+crate-type = ["lib", "cdylib"]
 name = "symbolica"
 
 [features]
@@ -32,25 +32,28 @@ faster_alloc = ["tikv-jemallocator"]
 # sort functions based on an argument-by-argument comparison
 full_fn_cmp = []
 mathematica_api = ["wolfram-library-link"]
-python_api = ["pyo3", "bincode"]
+python_api = ["pyo3"]
 # do not create a Python module but allow other crates to do so
 python_no_module = ["python_api"]
 # build a module that is independent of the specific Python version
 python_abi3 = ["pyo3/abi3", "pyo3/abi3-py37"]
 tracing_only_warnings = ["tracing/release_max_level_warn"]
+# bincode = ["dep:bincode"]
 
 [dependencies.pyo3]
 features = ["extension-module", "abi3", "py-clone"]
 optional = true
 version = "0.23"
 
 [dev-dependencies]
-tracing-subscriber = {version = "0.3.18", features = ["env-filter"]}
+tracing-subscriber = { version = "0.3.18", features = ["env-filter"] }
 
 [dependencies]
 ahash = "0.8.7"
 append-only-vec = "0.1"
-bincode = {version = "1.3", optional = true}
+bincode = { git = "https://github.com/branchseer/bincode", branch = "decode_context", features = [
+    "serde",
+] }
 brotli = "5.0"
 byteorder = "1.5"
 bytes = "1.5"
@@ -63,11 +66,19 @@ rand_xoshiro = "0.6"
 rayon = "1.8"
 rug = "=1.25.0"
 self_cell = "1.0"
-serde = {version = "1.0", features = ["derive"]}
+serde = { version = "1.0", features = ["derive"] }
 smallvec = "1.13"
 smartstring = "1.0"
-tikv-jemallocator = {version = "0.5.4", optional = true}
+tikv-jemallocator = { version = "0.5.4", optional = true }
 tinyjson = "2.5"
 tracing = "0.1"
 wide = "0.7"
-wolfram-library-link = {version = "0.2.9", optional = true}
+wolfram-library-link = { version = "0.2.9", optional = true }
+
+
+[build-dependencies]
+pyo3-build-config = "*"
+
+
+[patch.crates-io]
+bincode = { git = "https://github.com/branchseer/bincode", branch = "decode_context" }

build.rs

@@ -1,5 +1,9 @@
 use std::process::Command;
 fn main() {
+    if cfg!(target_os = "macos") {
+        pyo3_build_config::add_extension_module_link_args();
+        println!("cargo:rustc-link-lib=gcc_s");
+    }
     let output = Command::new("git")
         .args(["describe", "--tags"])
         .output()

patch_symbolica.py

@@ -0,0 +1 @@
+../../bin/patch_symbolica.py

src/atom.rs

@@ -43,6 +43,7 @@ mod coefficient;
 mod core;
 pub mod representation;
 
+use bincode::{de::read::Reader, enc::write::Writer, Decode, Encode};
 use representation::InlineVar;
 use smartstring::{LazyCompact, SmartString};
 
@@ -63,6 +64,7 @@ pub use self::representation::{
 };
 use self::representation::{FunView, RawAtom};
 
+
 /// A function that is called after normalization of the arguments.
 /// If the input, the first argument, is normalized, the function should return `false`.
 /// Otherwise, the function must return `true` and set the second argument to the normalized value.
@@ -97,6 +99,7 @@ pub enum FunctionAttribute {
     Linear,
 }
 
+use std::result;
 /// A symbol, for example the name of a variable or the name of a function,
 /// together with its properties.
 ///
@@ -124,6 +127,49 @@ pub struct Symbol {
     is_linear: bool,
 }
 
+impl<__Context> ::bincode::Decode<__Context> for Symbol {
+    fn decode<__D: ::bincode::de::Decoder<Context = __Context>>(
+        decoder: &mut __D,
+    ) -> Result<Self, ::bincode::error::DecodeError> {
+        Ok(Self {
+            id: ::bincode::Decode::decode(decoder)?,
+            wildcard_level: ::bincode::Decode::decode(decoder)?,
+            is_symmetric: ::bincode::Decode::decode(decoder)?,
+            is_antisymmetric: ::bincode::Decode::decode(decoder)?,
+            is_cyclesymmetric: ::bincode::Decode::decode(decoder)?,
+            is_linear: ::bincode::Decode::decode(decoder)?,
+        })
+    }
+}
+impl<'__de, __Context> ::bincode::BorrowDecode<'__de, __Context> for Symbol {
+    fn borrow_decode<__D: ::bincode::de::BorrowDecoder<'__de, Context = __Context>>(
+        decoder: &mut __D,
+    ) -> Result<Self, ::bincode::error::DecodeError> {
+        Ok(Self {
+            id: ::bincode::BorrowDecode::<'_, __Context>::borrow_decode(decoder)?,
+            wildcard_level: ::bincode::BorrowDecode::<'_, __Context>::borrow_decode(decoder)?,
+            is_symmetric: ::bincode::BorrowDecode::<'_, __Context>::borrow_decode(decoder)?,
+            is_antisymmetric: ::bincode::BorrowDecode::<'_, __Context>::borrow_decode(decoder)?,
+            is_cyclesymmetric: ::bincode::BorrowDecode::<'_, __Context>::borrow_decode(decoder)?,
+            is_linear: ::bincode::BorrowDecode::<'_, __Context>::borrow_decode(decoder)?,
+        })
+    }
+}
+
+impl ::bincode::Encode for Symbol {
+    fn encode<__E: ::bincode::enc::Encoder>(
+        &self,
+        encoder: &mut __E,
+    ) -> Result<(), ::bincode::error::EncodeError> {
+        ::bincode::Encode::encode(&self.id, encoder)?;
+        ::bincode::Encode::encode(&self.wildcard_level, encoder)?;
+        ::bincode::Encode::encode(&self.is_symmetric, encoder)?;
+        ::bincode::Encode::encode(&self.is_antisymmetric, encoder)?;
+        ::bincode::Encode::encode(&self.is_cyclesymmetric, encoder)?;
+        ::bincode::Encode::encode(&self.is_linear, encoder)?;
+        Ok(())
+    }
+}
 impl std::fmt::Debug for Symbol {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.write_fmt(format_args!("{}", self.id))?;

src/atom/representation.rs

@@ -1,13 +1,16 @@
 //! Low-level representation of expressions.
-
+use bincode::{
+    de::read::Reader, enc::write::Writer, impl_borrow_decode_with_context, BorrowDecode, Decode,
+    Encode,
+};
 use byteorder::{LittleEndian, WriteBytesExt};
 use bytes::{Buf, BufMut};
 use smartstring::alias::String;
 use std::{
     borrow::Borrow,
     cmp::Ordering,
     hash::Hash,
-    io::{Read, Write},
+    io::{Cursor, Read, Write},
 };
 
 use crate::{
@@ -161,6 +164,77 @@ impl InlineNum {
     }
 }
 
+impl Encode for Atom {
+    fn encode<E: bincode::enc::Encoder>(
+        &self,
+        encoder: &mut E,
+    ) -> Result<(), bincode::error::EncodeError> {
+        let d = self.as_view().get_data();
+        let writer = encoder.writer();
+        writer.write(&[0])?;
+        writer.write(&d.len().to_le_bytes())?;
+        writer.write(d)?;
+        Ok(())
+    }
+}
+
+#[test]
+fn encode_decode() {
+    let a = Atom::new_num(1);
+    let encoded_a = bincode::encode_to_vec(a, bincode::config::standard()).unwrap();
+    let mut export = vec![];
+    State::export(&mut export).unwrap();
+
+    let mut i = State::import(&mut Cursor::new(&export), None).unwrap();
+
+    let (atom, d) = bincode::decode_from_slice_with_context::<_, Atom, _>(
+        &encoded_a,
+        bincode::config::standard(),
+        &mut i,
+    )
+    .unwrap();
+}
+impl_borrow_decode_with_context!(Atom, StateMap);
+impl Decode<StateMap> for Atom {
+    fn decode<D: bincode::de::Decoder<Context = StateMap>>(
+        decoder: &mut D,
+    ) -> Result<Self, bincode::error::DecodeError> {
+        let atom = {
+            let source = decoder.reader();
+
+            let mut dest = Atom::Zero.into_raw();
+
+            // should also set whether rat poly coefficient needs to be converted
+            let mut flags_buf = [0; 1];
+            let mut size_buf = [0; 8];
+
+            source.read(&mut flags_buf)?;
+            source.read(&mut size_buf)?;
+
+            let n_size = u64::from_le_bytes(size_buf);
+
+            dest.extend(size_buf);
+            dest.resize(n_size as usize, 0);
+            source.read(&mut dest)?;
+
+            unsafe {
+                match dest[0] & TYPE_MASK {
+                    NUM_ID => Atom::Num(Num::from_raw(dest)),
+                    VAR_ID => Atom::Var(Var::from_raw(dest)),
+                    FUN_ID => Atom::Fun(Fun::from_raw(dest)),
+                    MUL_ID => Atom::Mul(Mul::from_raw(dest)),
+                    ADD_ID => Atom::Add(Add::from_raw(dest)),
+                    POW_ID => Atom::Pow(Pow::from_raw(dest)),
+                    _ => unreachable!("Unknown type {}", dest[0]),
+                }
+            }
+        };
+
+        let state_map = decoder.context();
+        Ok(atom.as_view().rename(&state_map))
+    }
+}
+
 impl Atom {
     /// Read from a binary stream. The format is the byte-length first
     /// followed by the data.

src/domains/integer.rs

@@ -7,6 +7,12 @@ use std::{
     str::FromStr,
 };
 
+use bincode::{
+    de::read::Reader,
+    enc::write::Writer,
+    error::{DecodeError, EncodeError},
+    impl_borrow_decode, Decode, Encode,
+};
 use rand::Rng;
 use rug::{
     ops::{Pow, RemRounding},
@@ -67,6 +73,65 @@ pub enum Integer {
     Large(MultiPrecisionInteger),
 }
 
+impl Encode for Integer {
+    fn encode<E: bincode::enc::Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
+        match self {
+            Integer::Natural(val) => {
+                // Variant tag
+                0u8.encode(encoder)?;
+                val.encode(encoder)
+            }
+            Integer::Double(val) => {
+                1u8.encode(encoder)?;
+                val.encode(encoder)
+            }
+            Integer::Large(val) => {
+                2u8.encode(encoder)?;
+                // Convert the MultiPrecisionInteger to bytes.
+                // For rug::Integer, `to_digits` allows conversion to a Vec<u8>.
+                // Use Order::MsfBe for most-significant-first (big-endian).
+                let bytes = val.to_digits::<u8>(rug::integer::Order::MsfBe);
+
+                // Encode the length of the byte array
+                (bytes.len() as u64).encode(encoder)?;
+                encoder.writer().write(&bytes)
+            }
+        }
+    }
+}
+
+impl<C> Decode<C> for Integer {
+    fn decode<D: bincode::de::Decoder<Context = C>>(decoder: &mut D) -> Result<Self, DecodeError> {
+        let variant = u8::decode(decoder)?;
+        match variant {
+            0 => {
+                let val = i64::decode(decoder)?;
+                Ok(Integer::Natural(val))
+            }
+            1 => {
+                let val = i128::decode(decoder)?;
+                Ok(Integer::Double(val))
+            }
+            2 => {
+                // Decode the length
+                let length = u64::decode(decoder)? as usize;
+                let mut bytes = vec![0u8; length];
+                decoder.reader().read(&mut bytes)?;
+
+                // Convert bytes back into a MultiPrecisionInteger
+                // For rug::Integer, from_digits can reconstruct from big-endian bytes:
+                let val = MultiPrecisionInteger::from_digits(&bytes, rug::integer::Order::MsfBe);
+                Ok(Integer::Large(val))
+            }
+            _ => Err(bincode::error::DecodeError::OtherString(format!(
+                "Invalid variant for Integer: {}",
+                variant
+            ))),
+        }
+    }
+}
+
+impl_borrow_decode!(Integer);
 impl InternalOrdering for Integer {
     fn internal_cmp(&self, other: &Self) -> std::cmp::Ordering {
         Ord::cmp(self, other)

src/domains/rational.rs

@@ -6,6 +6,13 @@ use std::{
     ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign},
 };
 
+use bincode::{
+    de::{BorrowDecoder, Decoder},
+    enc::Encoder,
+    error::{DecodeError, EncodeError},
+    impl_borrow_decode, BorrowDecode, Decode, Encode,
+};
+
 use crate::{
     poly::{gcd::LARGE_U32_PRIMES, polynomial::PolynomialRing, Exponent},
     printer::{PrintOptions, PrintState},
@@ -120,6 +127,42 @@ pub struct Fraction<R: Ring> {
     denominator: R::Element,
 }
 
+impl<R: Ring> Encode for Fraction<R>
+where
+    R::Element: Encode,
+{
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
+        self.numerator.encode(encoder)?;
+        self.denominator.encode(encoder)
+    }
+}
+
+impl<C, R: Ring> Decode<C> for Fraction<R>
+where
+    R::Element: Decode<C>,
+{
+    fn decode<D: Decoder<Context = C>>(decoder: &mut D) -> Result<Self, DecodeError> {
+        Ok(Fraction {
+            numerator: R::Element::decode(decoder)?,
+            denominator: R::Element::decode(decoder)?,
+        })
+    }
+}
+
+impl<'de, C, R: Ring> BorrowDecode<'de, C> for Fraction<R>
+where
+    R::Element: BorrowDecode<'de, C>,
+{
+    fn borrow_decode<D: BorrowDecoder<'de, Context = C>>(
+        decoder: &mut D,
+    ) -> Result<Self, DecodeError> {
+        Ok(Fraction {
+            numerator: R::Element::borrow_decode(decoder)?,
+            denominator: R::Element::borrow_decode(decoder)?,
+        })
+    }
+}
+
 impl<R: Ring> Fraction<R> {
     pub fn numerator(&self) -> R::Element {
         self.numerator.clone()