rust-ndarray · MiyakoMeow · Jun 18, 2025 · Jun 20, 2025 · Jun 20, 2025 · Jun 20, 2025
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -44,6 +44,8 @@ matrixmultiply = { version = "0.3.2", default-features = false, features=["cgemm
 serde = { version = "1.0", optional = true, default-features = false, features = ["alloc"] }
 rawpointer = { version = "0.2" }
 
+bincode = { version = "2.0", optional = true, default-features = false, features = ["alloc", "derive"] }
+
 [dev-dependencies]
 defmac = "0.2"
 quickcheck = { workspace = true }

diff --git a/crates/bincode-store-tests/Cargo.toml b/crates/bincode-store-tests/Cargo.toml
@@ -0,0 +1,23 @@
+[package]
+name = "bincode-store-tests"
+version = "0.1.0"
+authors = ["MiyakoMeow"]
+publish = false
+edition = "2018"
+
+[lib]
+test = false
+doc = false
+doctest = false
+
+[dependencies]
+ndarray = { workspace = true, features = ["bincode"] }
+
+bincode = { version = "2" }
+
+[dev-dependencies]
+# >=0.8.11 to avoid rmp-serde security vulnerability
+# <0.8.14 to allows MSRV 1.64.0
+rmp = { version = ">=0.8.11,<0.8.14" }
+# Old version to work with Rust 1.64+
+rmp-serde = { version = ">=1.1.1" }
diff --git a/crates/bincode-store-tests/src/lib.rs b/crates/bincode-store-tests/src/lib.rs
@@ -0,0 +1 @@
+
diff --git a/crates/bincode-store-tests/tests/serialize.rs b/crates/bincode-store-tests/tests/serialize.rs
@@ -0,0 +1,78 @@
+extern crate ndarray;
+
+use ndarray::{arr0, arr1, arr2, s, ArcArray, ArcArray2, ArrayD, IxDyn};
+
+#[test]
+fn store_many_dim_excrate() {
+    {
+        let a = arr0::<f32>(2.72);
+        let store_bytes = bincode::encode_to_vec(a, bincode::config::standard()).unwrap();
+        println!("Bincode encode {:?} => {:?}", a, store_bytes);
+        let res = bincode::decode_from_slice(&store_bytes, bincode::config::standard());
+        println!("{:?}", res);
+        assert_eq!(a, res.unwrap());
+    }
+
+    {
+        let a = arr1::<f32>(&[2.72, 1., 2.]);
+        let store_bytes = bincode::encode_to_vec(a, bincode::config::standard()).unwrap();
+        println!("Bincode encode {:?} => {:?}", a, store_bytes);
+        let res = bincode::decode_from_slice(&store_bytes, bincode::config::standard());
+        println!("{:?}", res);
+        assert_eq!(a, res.unwrap());
+    }
+
+    {
+        let a = arr2(&[[3., 1., 2.2], [3.1, 4., 7.]]);
+        let store_bytes = bincode::encode_to_vec(a, bincode::config::standard()).unwrap();
+        println!("Bincode encode {:?} => {:?}", a, store_bytes);
+        let res = bincode::decode_from_slice(&store_bytes, bincode::config::standard());
+        println!("{:?}", res);
+        assert_eq!(a, res.unwrap());
+    }
+
+    {
+        // Test a sliced array.
+        let mut a = ArcArray::from_iter(0..32)
+            .into_shape_with_order((2, 2, 2, 4))
+            .unwrap();
+        a.slice_collapse(s![..;-1, .., .., ..2]);
+        let store_bytes = bincode::encode_to_vec(a, bincode::config::standard()).unwrap();
+        println!("Bincode encode {:?} => {:?}", a, store_bytes);
+        let res = bincode::decode_from_slice(&store_bytes, bincode::config::standard());
+        println!("{:?}", res);
+        assert_eq!(a, res.unwrap());
+    }
+}
+
+#[test]
+fn serial_ixdyn_serde() {
+    {
+        let a = arr0::<f32>(2.72).into_dyn();
+        let store_bytes = bincode::encode_to_vec(a, bincode::config::standard()).unwrap();
+        println!("Bincode encode {:?} => {:?}", a, store_bytes);
+        let res = bincode::decode_from_slice(&store_bytes, bincode::config::standard());
+        println!("{:?}", res);
+        assert_eq!(a, res.unwrap());
+    }
+
+    {
+        let a = arr1::<f32>(&[2.72, 1., 2.]).into_dyn();
+        let store_bytes = bincode::encode_to_vec(a, bincode::config::standard()).unwrap();
+        println!("Bincode encode {:?} => {:?}", a, store_bytes);
+        let res = bincode::decode_from_slice(&store_bytes, bincode::config::standard());
+        println!("{:?}", res);
+        assert_eq!(a, res.unwrap());
+    }
+
+    {
+        let a = arr2(&[[3., 1., 2.2], [3.1, 4., 7.]])
+            .into_shape_with_order(IxDyn(&[3, 1, 1, 1, 2, 1]))
+            .unwrap();
+        let store_bytes = bincode::encode_to_vec(a, bincode::config::standard()).unwrap();
+        println!("Bincode encode {:?} => {:?}", a, store_bytes);
+        let res = bincode::decode_from_slice(&store_bytes, bincode::config::standard());
+        println!("{:?}", res);
+        assert_eq!(a, res.unwrap());
+    }
+}
diff --git a/src/array_bincode.rs b/src/array_bincode.rs
@@ -0,0 +1,140 @@
+// Copyright 2014-2025 MiyakoMeow and ndarray developers.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+use bincode::{
+    de::{BorrowDecoder, Decoder},
+    enc::Encoder,
+    error::{DecodeError, EncodeError},
+    BorrowDecode, Decode, Encode,
+};
+
+use alloc::format;
+#[cfg(not(feature = "std"))]
+use alloc::vec::Vec;
+
+use crate::{imp_prelude::*, IxDynImpl, ShapeError};
+
+use super::arraytraits::ARRAY_FORMAT_VERSION;
+
+/// Verifies that the version of the deserialized array matches the current
+/// `ARRAY_FORMAT_VERSION`.
+pub fn verify_version(v: u8) -> Result<(), DecodeError> {
+    if v != ARRAY_FORMAT_VERSION {
+        let err_msg = format!("unknown array version: {}", v);
+        Err(DecodeError::OtherString(err_msg))
+    } else {
+        Ok(())
+    }
+}
+
+/// **Requires crate feature `"bincode"`**
+impl<I> Encode for Dim<I>
+where
+    I: Encode,
+{
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
+        Encode::encode(&self.ix(), encoder)
+    }
+}
+
+/// **Requires crate feature `"bincode"`**
+impl<Context, I> Decode<Context> for Dim<I>
+where
+    I: Decode<Context>,
+{
+    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
+        Ok(Dim::new(Decode::decode(decoder)?))
+    }
+}
+
+/// **Requires crate feature `"bincode"`**
+impl<'de, Context, I> BorrowDecode<'de, Context> for Dim<I>
+where
+    I: BorrowDecode<'de, Context>,
+{
+    fn borrow_decode<D: BorrowDecoder<'de, Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
+        Ok(Dim::new(BorrowDecode::borrow_decode(decoder)?))
+    }
+}
+
+/// **Requires crate feature `"bincode"`**
+impl Encode for IxDyn {
+    fn encode<E: bincode::enc::Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
+        let ix: &IxDynImpl = self.ix();
+        Encode::encode(&ix.len(), encoder)?;
+        for ix in ix.into_iter() {
+            Encode::encode(ix, encoder)?;
+        }
+        Ok(())
+    }
+}
+
+/// **Requires crate feature `"bincode"`**
+impl<Context> Decode<Context> for IxDynImpl {
+    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
+        let len: usize = Decode::decode(decoder)?;
+        let vals = (0..len)
+            .map(|_| Decode::decode(decoder))
+            .collect::<Result<Vec<_>, DecodeError>>()?;
+        Ok(IxDynImpl::from(vals))
+    }
+}
+
+/// **Requires crate feature `"bincode"`**
+impl<'de, Context> bincode::BorrowDecode<'de, Context> for IxDynImpl {
+    fn borrow_decode<D: BorrowDecoder<'de, Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
+        let len: usize = BorrowDecode::borrow_decode(decoder)?;
+        let vals = (0..len)
+            .map(|_| BorrowDecode::borrow_decode(decoder))
+            .collect::<Result<Vec<_>, DecodeError>>()?;
+        Ok(IxDynImpl::from(vals))
+    }
+}
+
+/// **Requires crate feature `"serde"`**
+impl<A, D, S> Encode for ArrayBase<S, D>
+where
+    A: Encode,
+    D: Dimension + Encode,
+    S: Data<Elem = A>,
+{
+    fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
+        Encode::encode(&ARRAY_FORMAT_VERSION, encoder)?;
+        Encode::encode(&self.raw_dim(), encoder)?;
+        let iter = self.iter();
+        Encode::encode(&iter.len(), encoder)?;
+        for elt in iter.clone() {
+            Encode::encode(elt, encoder)?;
+        }
+        Ok(())
+    }
+}
+
+/// **Requires crate feature `"bincode"`**
+impl<A, D, S, Context> Decode<Context> for ArrayBase<S, D>
+where
+    A: Decode<Context>,
+    D: Dimension + Decode<Context>,
+    S: DataOwned<Elem = A>,
+{
+    fn decode<De: Decoder<Context = Context>>(decoder: &mut De) -> Result<Self, DecodeError> {
+        let data_version: u8 = Decode::decode(decoder)?;
+        (data_version == ARRAY_FORMAT_VERSION)
+            .then_some(())
+            .ok_or(DecodeError::Other("ARRAY_FORMAT_VERSION not match!"))?;
+        let dim: D = Decode::decode(decoder)?;
+        let data_len: usize = Decode::decode(decoder)?;
+        let data = (0..data_len)
+            .map(|_| Decode::decode(decoder))
+            .collect::<Result<Vec<_>, DecodeError>>()?;
+        let expected_size = dim.size();
+        ArrayBase::from_shape_vec(dim, data).map_err(|_err: ShapeError| DecodeError::ArrayLengthMismatch {
+            required: expected_size,
+            found: data_len,
+        })
+    }
+}
diff --git a/src/arraytraits.rs b/src/arraytraits.rs
@@ -432,8 +432,8 @@ where
 {
 }
 
-#[cfg(feature = "serde")]
-#[cfg_attr(docsrs, doc(cfg(feature = "serde")))]
+#[cfg(any(feature = "serde", feature = "bincode"))]
+#[cfg_attr(docsrs, doc(cfg(any(feature = "serde", feature = "bincode"))))]
 // Use version number so we can add a packed format later.
 pub const ARRAY_FORMAT_VERSION: u8 = 1u8;
 

diff --git a/src/lib.rs b/src/lib.rs
@@ -175,6 +175,8 @@ mod itertools;
 mod argument_traits;
 #[cfg(feature = "serde")]
 mod array_serde;
+#[cfg(feature = "bincode")]
+mod array_bincode;
 mod arrayformat;
 mod arraytraits;
 pub use crate::argument_traits::AssignElem;