add(feature): bincode

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 }
@@ -60,6 +62,8 @@ blas = ["dep:cblas-sys", "dep:libc"]
 
 serde = ["dep:serde"]
 
+bincode = ["dep:bincode"]
+
 std = ["num-traits/std", "matrixmultiply/std"]
 rayon = ["dep:rayon", "std"]
 

README.rst

@@ -78,6 +78,10 @@ your `Cargo.toml`.
 
   - Enables serialization support for serde 1.x
 
+- ``bincode``
+
+  - Enables bincode store support for bincode 2.x
+
 - ``rayon``
 
   - Enables parallel iterators, parallelized methods and ``par_azip!``.

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" }

crates/bincode-store-tests/src/lib.rs

@@ -0,0 +1 @@
+

crates/bincode-store-tests/tests/store_and_extract.rs

@@ -0,0 +1,98 @@
+use ndarray::{arr0, arr1, arr2, s, ArcArray, ArrayBase, Dim, IxDyn, IxDynImpl, OwnedArcRepr, OwnedRepr};
+// No test: ArcArray2, ArrayD
+
+#[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::<ArrayBase<OwnedRepr<f32>, Dim<[usize; 0]>>, _>(
+            &store_bytes,
+            bincode::config::standard(),
+        );
+        println!("{:?}", res);
+        assert_eq!(a, res.unwrap().0);
+    }
+
+    {
+        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::<ndarray::ArrayBase<OwnedRepr<f32>, Dim<[usize; 1]>>, _>(
+            &store_bytes,
+            bincode::config::standard(),
+        );
+        println!("{:?}", res);
+        assert_eq!(a, res.unwrap().0);
+    }
+
+    {
+        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::<ndarray::ArrayBase<OwnedRepr<f32>, Dim<[usize; 2]>>, _>(
+            &store_bytes,
+            bincode::config::standard(),
+        );
+        println!("{:?}", res);
+        assert_eq!(a, res.unwrap().0);
+    }
+
+    {
+        // 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::<ndarray::ArrayBase<OwnedArcRepr<i32>, Dim<[usize; 4]>>, _>(
+            &store_bytes,
+            bincode::config::standard(),
+        );
+        println!("{:?}", res);
+        assert_eq!(a, res.unwrap().0);
+    }
+}
+
+#[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::<ArrayBase<OwnedRepr<f32>, Dim<IxDynImpl>>, _>(
+            &store_bytes,
+            bincode::config::standard(),
+        );
+        println!("{:?}", res);
+        assert_eq!(a, res.unwrap().0);
+    }
+
+    {
+        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::<ArrayBase<OwnedRepr<f32>, Dim<IxDynImpl>>, _>(
+            &store_bytes,
+            bincode::config::standard(),
+        );
+        println!("{:?}", res);
+        assert_eq!(a, res.unwrap().0);
+    }
+
+    {
+        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::<ArrayBase<OwnedRepr<f64>, Dim<IxDynImpl>>, _>(
+            &store_bytes,
+            bincode::config::standard(),
+        );
+        println!("{:?}", res);
+        assert_eq!(a, res.unwrap().0);
+    }
+}

src/array_bincode.rs

@@ -0,0 +1,124 @@
+// 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,
+};
+
+#[cfg(not(feature = "std"))]
+use alloc::vec::Vec;
+
+use crate::{imp_prelude::*, IxDynImpl, ShapeError};
+
+use super::arraytraits::ARRAY_FORMAT_VERSION;
+
+/// **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> {
+        Decode::decode(decoder).map(Dim::new)
+    }
+}
+
+/// **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> {
+        BorrowDecode::borrow_decode(decoder).map(Dim::new)
+    }
+}
+
+/// **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)?;
+        ix.into_iter()
+            .try_for_each(|ix| Encode::encode(ix, encoder))
+    }
+}
+
+/// **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)?;
+        (0..len)
+            .map(|_| Decode::decode(decoder))
+            .collect::<Result<Vec<_>, DecodeError>>()
+            .map(IxDynImpl::from)
+    }
+}
+
+/// **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)?;
+        (0..len)
+            .map(|_| BorrowDecode::borrow_decode(decoder))
+            .collect::<Result<Vec<_>, DecodeError>>()
+            .map(IxDynImpl::from)
+    }
+}
+
+/// **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)?;
+        iter.into_iter()
+            .try_for_each(|elt| Encode::encode(elt, encoder))
+    }
+}
+
+/// **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: Vec<_> = (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,
+        })
+    }
+}

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;
 

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;