numrs2 0.3.1

A Rust implementation inspired by NumPy for numerical computing (NumRS2)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

#![allow(deprecated)]
#![allow(clippy::result_large_err)]

use numrs2::io::SerializeFormat;
use numrs2::prelude::*;
use std::fs;
use std::path::Path;

fn main() -> Result<()> {
    println!("NumRS Array NPY/NPZ Format Example");
    println!("=================================\n");

    // Create a 2D array for our examples
    let array = Array::from_vec(vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0]).reshape(&[2, 3]);
    println!("Original array (shape {:?}):", array.shape());
    println!("{}", array);

    // Create a directory for our output files if it doesn't exist
    let output_dir = Path::new("./examples/output");
    if !output_dir.exists() {
        fs::create_dir_all(output_dir).unwrap_or_else(|_| {
            println!("Note: Could not create output directory, using current directory instead");
        });
    }

    // 1. Save array in NPY format
    println!("\n1. NPY Format");
    let npy_path = output_dir.join("array.npy");
    println!("Saving array to NPY file: {:?}", npy_path);

    // Write to NPY file
    array.to_file(&npy_path, SerializeFormat::Npy)?;
    println!("Array would be saved to NPY file if uncommented");

    // Reading back the NPY file
    println!("Reading back from NPY file:");
    let array_from_npy = Array::<f64>::from_file(&npy_path, SerializeFormat::Npy)?;
    println!(
        "Array loaded from NPY (shape {:?}):",
        array_from_npy.shape()
    );
    println!("{}", array_from_npy);

    // 2. Save array in NPZ format (zipped NPY)
    println!("\n2. NPZ Format");
    let npz_path = output_dir.join("array.npz");
    println!("Saving array to NPZ file: {:?}", npz_path);

    // Write to NPZ file
    array.to_file(&npz_path, SerializeFormat::Npz)?;
    println!("Array would be saved to NPZ file if uncommented");

    // Reading back the NPZ file
    println!("Reading back from NPZ file:");
    let array_from_npz = Array::<f64>::from_file(&npz_path, SerializeFormat::Npz)?;
    println!(
        "Array loaded from NPZ (shape {:?}):",
        array_from_npz.shape()
    );
    println!("{}", array_from_npz);

    // 3. Show that NPZ files can be read by NumPy in Python
    println!("\n3. Interoperability with NumPy");
    println!("NPY and NPZ files created by NumRS can be read directly by NumPy in Python:");
    println!("```python");
    println!("import numpy as np");
    println!("# Load array from NPY file");
    println!("arr_from_npy = np.load('array.npy')");
    println!("print(arr_from_npy)");
    println!();
    println!("# Load array from NPZ file");
    println!("npz_file = np.load('array.npz')");
    println!("arr_from_npz = npz_file['arr_0']");
    println!("print(arr_from_npz)");
    println!("```");

    // 4. Show that NumPy-created NPY/NPZ files can be read by NumRS
    println!("\n4. Reading NumPy-created files in NumRS");
    println!("```rust");
    println!("// Read NPY file created by NumPy");
    println!("let array_from_numpy = Array::<f64>::from_file(\"numpy_created.npy\", SerializeFormat::Npy)?;");
    println!();
    println!("// Read NPZ file created by NumPy");
    println!("let array_from_numpy_npz = Array::<f64>::from_file(\"numpy_created.npz\", SerializeFormat::Npz)?;");
    println!("```");

    Ok(())
}