Ver 0.40.0

- Move from `arrow2` -> `arrow` & `parquet`
- Change CompressionOptions (please refer to RELEASES.md)

Author: Axect

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "peroxide"
-version = "0.39.11"
+version = "0.40.0"
 authors = ["axect <axect@outlook.kr>"]
 edition = "2018"
 description = "Rust comprehensive scientific computation library contains linear algebra, numerical analysis, statistics and machine learning tools with farmiliar syntax"
@@ -48,10 +48,9 @@ lapack = { version = "0.19", optional = true }
 serde = { version = "1.0", features = ["derive"], optional = true }
 rkyv = { version = "0.8", optional = true }
 json = { version = "0.12", optional = true }
-arrow2 = { version = "0.18", features = [
-  "io_parquet",
-  "io_parquet_compression",
-], optional = true }
+parquet = { version = "55", features = ["arrow", "snap"], optional = true }
+arrow = { version = "55", optional = true }
+indexmap = { version = "1", optional = true }
 num-complex = { version = "0.4", optional = true }
 rayon = { version = "1.10", optional = true }
 
@@ -63,6 +62,6 @@ default = []
 O3 = ["blas", "lapack"]
 plot = ["pyo3"]
 nc = ["netcdf"]
-parquet = ["arrow2"]
+parquet = ["dep:parquet", "arrow", "indexmap"]
 complex = ["num-complex", "matrixmultiply/cgemm"]
 parallel = ["rayon"]

RELEASES.md

@@ -1,3 +1,14 @@
+# Release 0.40.0 (2025-07-24)
+
+## Move from `arrow2` to `arrow` & `parquet`
+
+- Remove `arrow2` dependency
+- Add `arrow` and `parquet` dependencies
+- Update `WithParquet` implementation
+- On user side, there are almost no changes in `DataFrame` API, but there is one change for `fuga` user:
+  - `CompressionOptions` -> `UNCOMPRESSED`, `SNAPPY`, `GZIP(level)`, `LZ4`, `ZSTD(level)`, `BROTLI(level)`, `LZO`, `LZ4_RAW`
+  - For `prelude user`, there are completely no changes. Default compression is `SNAPPY`.
+
 # Release 0.39.11 (2025-07-22)
 
 - Implement `derivative` and `integral` of B-Spline

examples/area_under_spline.rs

@@ -1,5 +1,5 @@
-use peroxide::fuga::*;
 use anyhow::Result;
+use peroxide::fuga::*;
 
 fn main() -> Result<()> {
     // 1. Define the B-spline
@@ -30,14 +30,18 @@ fn main() -> Result<()> {
     // 3. Perform numerical integration using self-contained Gauss-Legendre quadrature
     let t_start = 0f64;
     let t_end = 4f64;
-    
+
     //let area = gauss_legendre_integrate(
     //    |t| integrand(t, &spline, &deriv_spline),
     //    t_start,
     //    t_end,
     //    64,
     //);
-    let area = integrate(|t| integrand(t, &spline, &deriv_spline), (t_start, t_end), G7K15R(1e-4, 20));
+    let area = integrate(
+        |t| integrand(t, &spline, &deriv_spline),
+        (t_start, t_end),
+        G7K15R(1e-4, 20),
+    );
 
     // 4. Print the result
     println!("The area under the B-spline curve (∫y dx) is: {}", area);
@@ -47,21 +51,24 @@ fn main() -> Result<()> {
     {
         let t = linspace(t_start, t_end, 200);
         let (x, y): (Vec<f64>, Vec<f64>) = spline.eval_vec(&t).into_iter().unzip();
-        
+
         let mut plt = Plot2D::new();
         plt.set_title(&format!("Original B-Spline (Area approx. {:.4})", area))
             .set_xlabel("x")
             .set_ylabel("y")
             .insert_pair((x.clone(), y.clone()))
-            .insert_pair((control_points.iter().map(|p| p[0]).collect(), control_points.iter().map(|p| p[1]).collect()))
+            .insert_pair((
+                control_points.iter().map(|p| p[0]).collect(),
+                control_points.iter().map(|p| p[1]).collect(),
+            ))
             .set_plot_type(vec![(0, PlotType::Line), (1, PlotType::Scatter)])
             .set_color(vec![(0, "blue"), (1, "red")])
             .set_legend(vec!["Spline", "Control Points"])
             .set_style(PlotStyle::Nature)
             .set_path("example_data/bspline_with_area.png")
             .set_dpi(600)
             .savefig()?;
-        
+
         println!("Generated plot: example_data/bspline_with_area.png");
     }
 

examples/bspline_calculus.rs

@@ -1,5 +1,5 @@
-use peroxide::fuga::*;
 use anyhow::Result;
+use peroxide::fuga::*;
 
 fn main() -> Result<()> {
     // 1. Define the B-spline
@@ -53,7 +53,8 @@ fn main() -> Result<()> {
         let deriv_control_y: Vec<f64> = deriv_spline.control_points.iter().map(|p| p[1]).collect();
 
         let mut plt_deriv = Plot2D::new();
-        plt_deriv.set_title("B-Spline Derivative (Hodograph)")
+        plt_deriv
+            .set_title("B-Spline Derivative (Hodograph)")
             .set_xlabel("dx/dt")
             .set_ylabel("dy/dt")
             .insert_pair((dx, dy))
@@ -71,7 +72,8 @@ fn main() -> Result<()> {
         let integ_control_y: Vec<f64> = integ_spline.control_points.iter().map(|p| p[1]).collect();
 
         let mut plt_integ = Plot2D::new();
-        plt_integ.set_title("B-Spline Integral")
+        plt_integ
+            .set_title("B-Spline Integral")
             .set_xlabel("Integral of x")
             .set_ylabel("Integral of y")
             .insert_pair((ix, iy))

examples/df_parquet.rs

@@ -0,0 +1,33 @@
+use peroxide::fuga::*;
+
+fn main() -> Result<(), Box<dyn Error>> {
+    #[cfg(feature = "parquet")]
+    {
+        let a = Series::new(vec![1, 2, 3, 4]);
+        let b = Series::new(vec![0.1, 0.2, 0.3, 0.4]);
+        let c = Series::new(vec![true, false, false, true]);
+        let d = Series::new(
+            vec!["a", "b", "c", "d"]
+                .into_iter()
+                .map(|x| x.to_string())
+                .collect(),
+        );
+
+        let mut df = DataFrame::new(vec![a, b, c, d]);
+        df.set_header(vec!["a", "b", "c", "d"]);
+        println!("Write:");
+        df.print();
+
+        df.write_parquet("example_data/df_parquet.parquet", UNCOMPRESSED)?;
+
+        println!("\nRead:");
+        let mut dg = DataFrame::read_parquet("example_data/df_parquet.parquet")?;
+        dg.print();
+
+        println!("\nConvert:");
+        dg[2].as_type(Bool);
+        dg.print();
+    }
+
+    Ok(())
+}

src/fuga/mod.rs

@@ -121,7 +121,7 @@
 //!     df.print();
 //!
 //!     # #[cfg(feature="parquet")] {
-//!     df.write_parquet("example_data/test.parquet", CompressionOptions::Uncompressed).unwrap();
+//!     df.write_parquet("example_data/test.parquet", SNAPPY).unwrap();
 //!     # }
 //! }
 //! ```
@@ -228,4 +228,4 @@ pub use crate::traits::matrix::{
 };
 
 #[cfg(feature = "parquet")]
-pub use arrow2::io::parquet::write::CompressionOptions;
+pub use parquet::basic::Compression::*;

src/numerical/ode.rs

@@ -1291,9 +1291,7 @@ impl ODEIntegrator for GL4 {
                     let delta = (&J_inv * &F_vec).mul_scalar(-1.0);
 
                     // U <- U + delta
-                    U.iter_mut()
-                        .zip(delta.iter())
-                        .for_each(|(u, d)| *u += *d);
+                    U.iter_mut().zip(delta.iter()).for_each(|(u, d)| *u += *d);
 
                     let mut F_new = vec![0.0; m];
                     compute_F(problem, t, y, dt, &U, &mut F_new)?;
@@ -1394,7 +1392,7 @@ fn compute_F<P: ODEProblem>(
         y1[i] = y[i] + dt * (A11 * k1_slice[i] + A12 * k2_slice[i]);
         y2[i] = y[i] + dt * (A21 * k1_slice[i] + A22 * k2_slice[i]);
     }
-    
+
     // F is an output parameter, its parts f1 and f2 are stored temporarily
     let (f1, f2) = F.split_at_mut(n);
     problem.rhs(t + C1 * dt, &y1, f1)?;

src/numerical/optimize.rs

@@ -110,6 +110,7 @@
 
 pub use self::OptMethod::{GaussNewton, GradientDescent, LevenbergMarquardt};
 use self::OptOption::{InitParam, MaxIter};
+use crate::fuga::ConvToMat;
 use crate::numerical::utils::jacobian;
 use crate::structure::ad::{ADVec, AD};
 use crate::structure::matrix::Matrix;
@@ -247,7 +248,7 @@ where
 
         // Take various form of initial data
         let p_init_vec = p_init.to_f64_vec();
-        let y = y_vec.into();
+        let y = y_vec.to_col();
 
         // Declare mutable values
         let mut p: Matrix = p_init_vec.clone().into();

src/prelude/mod.rs

@@ -117,7 +117,7 @@
 //!     df.print();
 //!
 //!     # #[cfg(feature="parquet")] {
-//!     df.write_parquet("example_data/test.parquet", CompressionOptions::Uncompressed).unwrap();
+//!     df.write_parquet("example_data/test.parquet", SNAPPY).unwrap();
 //!     # }
 //! }
 //! ```

src/prelude/simpler.rs

@@ -14,7 +14,7 @@ use crate::traits::math::{Norm, Normed};
 #[allow(unused_imports)]
 use crate::traits::matrix::{Form, LinearAlgebra, MatrixTrait, SolveKind, PQLU, QR, UPLO, WAZD};
 #[cfg(feature = "parquet")]
-use arrow2::io::parquet::write::CompressionOptions;
+use parquet::basic::Compression;
 #[cfg(feature = "parquet")]
 use std::error::Error;
 
@@ -198,7 +198,7 @@ pub trait SimpleParquet: Sized {
 #[cfg(feature = "parquet")]
 impl SimpleParquet for DataFrame {
     fn write_parquet(&self, path: &str) -> Result<(), Box<dyn Error>> {
-        WithParquet::write_parquet(self, path, CompressionOptions::Uncompressed)
+        WithParquet::write_parquet(self, path, Compression::SNAPPY)
     }
 
     fn read_parquet(path: &str) -> Result<Self, Box<dyn Error>> {