Struct NdArray 

pub struct NdArray<D>(/* private fields */);

Implementations

impl<T: WithDType> NdArray<T>

pub fn dims0(&self) -> Result<()>

impl<T: WithDType> NdArray<T>

pub fn dims1(&self) -> Result<usize>

impl<T: WithDType> NdArray<T>

pub fn dims2(&self) -> Result<(usize, usize)>

impl<T: WithDType> NdArray<T>

pub fn dims3(&self) -> Result<(usize, usize, usize)>

impl<T: WithDType> NdArray<T>

pub fn dims4(&self) -> Result<(usize, usize, usize, usize)>

impl<T: WithDType> NdArray<T>

pub fn dims5(&self) -> Result<(usize, usize, usize, usize, usize)>

impl<T: WithDType> NdArray<T>

pub fn new<A: ToNdArray<T>>(array: A) -> Result<Self>

Creates a new NdArray from any supported Rust array or slice.

use numrst::NdArray;

let a = NdArray::new(&[1, 2, 3]).unwrap();
println!("{}", a.shape());

Examples found in repository

examples/nrst.rs (line 9)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let tmpfile = NamedTempFile::new().unwrap();

    let scalar = NdArray::new(1).unwrap();
    let vector_f32 = NdArray::new(&[1.0f32, 2., 3.]).unwrap();
    let matrix_f32 = NdArray::new(&[[1, 2, 3], [3, 4, 5]]).unwrap();
    let ones_f32 = NdArray::<f32>::ones((2, 9)).unwrap();
    let randn_f64 = NdArray::randn(0.0f64, 1., (1, 2, 3)).unwrap();
    let fill_f64 = NdArray::full((2, 3, 4), 1.2).unwrap();
    let arange_f64 = NdArray::arange(0., 10.).unwrap();
    let trues = NdArray::trues((3, 4)).unwrap();
    let booleans = NdArray::new(&[[true, false], [false, true]]).unwrap();


    let mut ndarrays = HashMap::new();
    ndarrays.insert("scalar".to_string(), DynamicNdArray::I32(scalar));
    ndarrays.insert("vector_f32".to_string(), DynamicNdArray::F32(vector_f32));
    ndarrays.insert("matrix_f32".to_string(), DynamicNdArray::I32(matrix_f32));
    ndarrays.insert("ones_f32".to_string(), DynamicNdArray::F32(ones_f32));
    ndarrays.insert("randn_f64".to_string(), DynamicNdArray::F64(randn_f64));
    ndarrays.insert("fill_f64".to_string(), DynamicNdArray::F64(fill_f64));
    ndarrays.insert("arange_f64".to_string(), DynamicNdArray::F64(arange_f64));
    ndarrays.insert("trues".to_string(), DynamicNdArray::Bool(trues));
    ndarrays.insert("booleans".to_string(), DynamicNdArray::Bool(booleans));

    numrst::io::save_zfile(&ndarrays, tmpfile.path()).unwrap();

    let ndarrays = numrst::io::load_zfile(tmpfile.path()).unwrap();
    for (name, _) in ndarrays {
        println!("{}", name);
    }
    Ok(())
}

examples/npy.rs (line 9)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let tmpfile = NamedTempFile::new().unwrap();

    let scalar = NdArray::new(1).unwrap();
    let vector_f32 = NdArray::new(&[1.0f32, 2., 3.]).unwrap();
    let matrix_f32 = NdArray::new(&[[1, 2, 3], [3, 4, 5]]).unwrap();
    let ones_f32 = NdArray::<f32>::ones((2, 9)).unwrap();
    let randn_f64 = NdArray::randn(0.0f64, 1., (1, 2, 3)).unwrap();
    let fill_f64 = NdArray::full((2, 3, 4), 1.2).unwrap();
    let arange_f64 = NdArray::arange(0., 10.).unwrap();
    let trues = NdArray::trues((3, 4)).unwrap();
    let booleans = NdArray::new(&[[true, false], [false, true]]).unwrap();

    let mut ndarrays = HashMap::new();
    ndarrays.insert("scalar".to_string(), DynamicNdArray::I32(scalar));
    ndarrays.insert("vector_f32".to_string(), DynamicNdArray::F32(vector_f32));
    ndarrays.insert("matrix_f32".to_string(), DynamicNdArray::I32(matrix_f32));
    ndarrays.insert("ones_f32".to_string(), DynamicNdArray::F32(ones_f32));
    ndarrays.insert("randn_f64".to_string(), DynamicNdArray::F64(randn_f64));
    ndarrays.insert("fill_f64".to_string(), DynamicNdArray::F64(fill_f64));
    ndarrays.insert("arange_f64".to_string(), DynamicNdArray::F64(arange_f64));
    ndarrays.insert("trues".to_string(), DynamicNdArray::Bool(trues));
    ndarrays.insert("booleans".to_string(), DynamicNdArray::Bool(booleans));

    numrst::io::save_npz_file(&ndarrays, tmpfile.path()).unwrap();

    let ndarrays = numrst::io::load_npz_file(tmpfile.path()).unwrap();
    for (name, _) in ndarrays {
        println!("{}", name);
    }

    Ok(())
}

pub fn full<S: Into<Shape>>(shape: S, value: T) -> Result<Self>

Creates an array full with a constant value.

use numrst::NdArray;

let a = NdArray::full((2, 2), 7).unwrap();
println!("{}", a);

Examples found in repository

examples/arithmetic.rs (line 5)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let a = NdArray::<f32>::ones((2, 2))?;
    let b = NdArray::<f32>::full((2, 2), 2.0)?;

    let c = a.add(&b)?;
    let d = b.sub(&a)?;
    let e = b.mul(&c)?;
    let f = e.div(&d)?;

    println!("a:\n{:?}", a);
    println!("b:\n{}", b);
    println!("a + b:\n{}", c);
    println!("b - a:\n{:?}", d);
    println!("b * (a + b):\n{}", e);
    println!("e / d:\n{}", f);

    Ok(())
}

examples/logic.rs (line 6)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // --- Comparison ops ---
    let a = NdArray::<i32>::arange(0, 9)?.reshape((3, 3))?;
    let b = NdArray::<i32>::full((3, 3), 4)?;

    let eq = a.eq(&b)?;
    let ne = a.ne(&b)?;
    let lt = a.lt(&b)?;
    let ge = a.ge(&b)?;

    println!("a:\n{}", a);
    println!("b:\n{}", b);
    println!("a == b:\n{}", eq);
    println!("a != b:\n{}", ne);
    println!("a < b:\n{}", lt);
    println!("a >= b:\n{}", ge);

    // --- Boolean logic ops ---
    let x = NdArray::<bool>::trues((2, 2))?;
    let y = NdArray::<bool>::falses((2, 2))?;

    let and = x.and(&y)?;
    let or = x.or(&y)?;
    let xor = x.xor(&y)?;

    println!("\nx:\n{}", x);
    println!("y:\n{}", y);
    println!("x AND y:\n{}", and);
    println!("x OR y:\n{}", or);
    println!("x XOR y:\n{}", xor);

    // --- Using select (if-else like) ---
    let cond = a.lt(&b)?;
    let chosen = NdArray::<i32>::select(&cond, &a, &b)?;

    println!("\nCondition (a < b):\n{}", cond);
    println!("Select result (if a<b then a else b):\n{}", chosen);

    Ok(())
}

examples/nrst.rs (line 14)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let tmpfile = NamedTempFile::new().unwrap();

    let scalar = NdArray::new(1).unwrap();
    let vector_f32 = NdArray::new(&[1.0f32, 2., 3.]).unwrap();
    let matrix_f32 = NdArray::new(&[[1, 2, 3], [3, 4, 5]]).unwrap();
    let ones_f32 = NdArray::<f32>::ones((2, 9)).unwrap();
    let randn_f64 = NdArray::randn(0.0f64, 1., (1, 2, 3)).unwrap();
    let fill_f64 = NdArray::full((2, 3, 4), 1.2).unwrap();
    let arange_f64 = NdArray::arange(0., 10.).unwrap();
    let trues = NdArray::trues((3, 4)).unwrap();
    let booleans = NdArray::new(&[[true, false], [false, true]]).unwrap();


    let mut ndarrays = HashMap::new();
    ndarrays.insert("scalar".to_string(), DynamicNdArray::I32(scalar));
    ndarrays.insert("vector_f32".to_string(), DynamicNdArray::F32(vector_f32));
    ndarrays.insert("matrix_f32".to_string(), DynamicNdArray::I32(matrix_f32));
    ndarrays.insert("ones_f32".to_string(), DynamicNdArray::F32(ones_f32));
    ndarrays.insert("randn_f64".to_string(), DynamicNdArray::F64(randn_f64));
    ndarrays.insert("fill_f64".to_string(), DynamicNdArray::F64(fill_f64));
    ndarrays.insert("arange_f64".to_string(), DynamicNdArray::F64(arange_f64));
    ndarrays.insert("trues".to_string(), DynamicNdArray::Bool(trues));
    ndarrays.insert("booleans".to_string(), DynamicNdArray::Bool(booleans));

    numrst::io::save_zfile(&ndarrays, tmpfile.path()).unwrap();

    let ndarrays = numrst::io::load_zfile(tmpfile.path()).unwrap();
    for (name, _) in ndarrays {
        println!("{}", name);
    }
    Ok(())
}

examples/npy.rs (line 14)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let tmpfile = NamedTempFile::new().unwrap();

    let scalar = NdArray::new(1).unwrap();
    let vector_f32 = NdArray::new(&[1.0f32, 2., 3.]).unwrap();
    let matrix_f32 = NdArray::new(&[[1, 2, 3], [3, 4, 5]]).unwrap();
    let ones_f32 = NdArray::<f32>::ones((2, 9)).unwrap();
    let randn_f64 = NdArray::randn(0.0f64, 1., (1, 2, 3)).unwrap();
    let fill_f64 = NdArray::full((2, 3, 4), 1.2).unwrap();
    let arange_f64 = NdArray::arange(0., 10.).unwrap();
    let trues = NdArray::trues((3, 4)).unwrap();
    let booleans = NdArray::new(&[[true, false], [false, true]]).unwrap();

    let mut ndarrays = HashMap::new();
    ndarrays.insert("scalar".to_string(), DynamicNdArray::I32(scalar));
    ndarrays.insert("vector_f32".to_string(), DynamicNdArray::F32(vector_f32));
    ndarrays.insert("matrix_f32".to_string(), DynamicNdArray::I32(matrix_f32));
    ndarrays.insert("ones_f32".to_string(), DynamicNdArray::F32(ones_f32));
    ndarrays.insert("randn_f64".to_string(), DynamicNdArray::F64(randn_f64));
    ndarrays.insert("fill_f64".to_string(), DynamicNdArray::F64(fill_f64));
    ndarrays.insert("arange_f64".to_string(), DynamicNdArray::F64(arange_f64));
    ndarrays.insert("trues".to_string(), DynamicNdArray::Bool(trues));
    ndarrays.insert("booleans".to_string(), DynamicNdArray::Bool(booleans));

    numrst::io::save_npz_file(&ndarrays, tmpfile.path()).unwrap();

    let ndarrays = numrst::io::load_npz_file(tmpfile.path()).unwrap();
    for (name, _) in ndarrays {
        println!("{}", name);
    }

    Ok(())
}

examples/shape.rs (line 34)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // --- Reshape ---
    let a = NdArray::<i32>::arange(0, 12)?;
    let a2d = a.reshape((3, 4))?;
    let a3d = a.reshape((2, 2, 3))?;

    println!("Original a (1D):\n{}", a);
    println!("Reshaped a (3x4):\n{}", a2d);
    println!("Reshaped a (2x2x3):\n{}", a3d);

    // --- Transpose ---
    let t = a2d.transpose(0, 1)?;
    println!("Transpose a2d (swap dim 0 <-> 1):\n{}", t);

    // --- Unsqueeze & Squeeze ---
    let b = NdArray::<f32>::arange(0.0, 6.0)?.reshape((2, 3))?;
    let b_unsq = b.unsqueeze(0)?; // add axis at front -> (1,2,3)
    let b_sq = b_unsq.squeeze(0)?; // remove axis -> (2,3)

    println!("b shape: {}", b.shape());
    println!("b_unsq shape: {}", b_unsq.shape());
    println!("b_sq shape: {}", b_sq.shape());

    // --- Narrow & Narrow Range ---
    let narrowed = b.narrow(1, 0, 2)?; // take first 2 cols along axis 1
    let narrowed_range = b.narrow_range(1, &rng!(0:2))?;

    println!("narrowed (axis=1, first 2 cols):\n{}", narrowed);
    println!("narrowed_range (axis=1, 0..2):\n{}", narrowed_range);

    // --- Concatenate ---
    let c1 = NdArray::<i32>::full((2, 2), 1)?;
    let c2 = NdArray::<i32>::full((2, 2), 2)?;
    let cat = NdArray::cat(&[&c1, &c2], 0)?; // concat along axis=0

    println!("Concatenate along axis=0:\n{}", cat);

    // --- Stack ---
    let s1 = NdArray::<i32>::full((2, 2), 3)?;
    let s2 = NdArray::<i32>::full((2, 2), 4)?;
    let stacked = NdArray::stack(&[&s1, &s2], 0)?; // stack new axis

    println!("Stacked along new axis=0:\n{}", stacked);

    Ok(())
}

impl<T: NumDType> NdArray<T>

pub fn zeros<S: Into<Shape>>(shape: S) -> Result<Self>

Creates an array of zeros with the given shape.

use numrst::NdArray;

let a = NdArray::<f32>::zeros((2, 3)).unwrap();
println!("{}", a);

Examples found in repository

examples/view.rs (line 4)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let total = NdArray::<f32>::zeros((5, 5)).unwrap();

    {
        let mut sub = total.index((1..3, 2..4)).unwrap();
        let source = sub.randn_like(0.0, 1.0).unwrap();
        let mut sub_view = sub.matrix_view_mut().unwrap();

        sub_view.copy_from(&source).unwrap();
    }
    
    println!("{}", total);

    Ok(())
}

examples/construct.rs (line 5)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create arrays with different constructors
    let zeros = NdArray::<f32>::zeros((2, 3))?;
    let ones = NdArray::<f32>::ones((2, 3))?;
    let arange = NdArray::<i32>::arange(0, 10)?;
    let rand = NdArray::<f32>::rand(0.0, 1.0, (2, 5, 3, 4))?;
    let randn = NdArray::<f32>::randn(0.0, 1.0, (2, 2))?;

    println!("zeros:\n{}", zeros);
    println!("ones:\n{}", ones);
    println!("arange:\n{}", arange);
    println!("rand:\n{}", rand);
    println!("randn:\n{}", randn);

    Ok(())
}

pub fn zero_like(&self) -> Result<Self>

Creates a zero-filled array with the same shape as self.

use numrst::NdArray;

let a = NdArray::<i32>::ones((2, 2)).unwrap();
let b = a.zero_like().unwrap();
println!("{}", b);

pub fn ones<S: Into<Shape>>(shape: S) -> Result<Self>

Creates an array of ones with the given shape.

use numrst::NdArray;

let a = NdArray::<f64>::ones((3, 3)).unwrap();
println!("{}", a);

Examples found in repository

examples/broadcasting.rs (line 4)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let a = NdArray::<f32>::ones((3, 3))?;
    let b = NdArray::<f32>::arange(0.0, 3.0)?.reshape((3, 1))?;

    let c = a.broadcast_add(&b)?; // broadcasting
    println!("a:\n{}", a);
    println!("b:\n{}", b);
    println!("a + b (broadcast):\n{}", c);

    Ok(())
}

examples/arithmetic.rs (line 4)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let a = NdArray::<f32>::ones((2, 2))?;
    let b = NdArray::<f32>::full((2, 2), 2.0)?;

    let c = a.add(&b)?;
    let d = b.sub(&a)?;
    let e = b.mul(&c)?;
    let f = e.div(&d)?;

    println!("a:\n{:?}", a);
    println!("b:\n{}", b);
    println!("a + b:\n{}", c);
    println!("b - a:\n{:?}", d);
    println!("b * (a + b):\n{}", e);
    println!("e / d:\n{}", f);

    Ok(())
}

examples/construct.rs (line 6)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create arrays with different constructors
    let zeros = NdArray::<f32>::zeros((2, 3))?;
    let ones = NdArray::<f32>::ones((2, 3))?;
    let arange = NdArray::<i32>::arange(0, 10)?;
    let rand = NdArray::<f32>::rand(0.0, 1.0, (2, 5, 3, 4))?;
    let randn = NdArray::<f32>::randn(0.0, 1.0, (2, 2))?;

    println!("zeros:\n{}", zeros);
    println!("ones:\n{}", ones);
    println!("arange:\n{}", arange);
    println!("rand:\n{}", rand);
    println!("randn:\n{}", randn);

    Ok(())
}

examples/nrst.rs (line 12)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let tmpfile = NamedTempFile::new().unwrap();

    let scalar = NdArray::new(1).unwrap();
    let vector_f32 = NdArray::new(&[1.0f32, 2., 3.]).unwrap();
    let matrix_f32 = NdArray::new(&[[1, 2, 3], [3, 4, 5]]).unwrap();
    let ones_f32 = NdArray::<f32>::ones((2, 9)).unwrap();
    let randn_f64 = NdArray::randn(0.0f64, 1., (1, 2, 3)).unwrap();
    let fill_f64 = NdArray::full((2, 3, 4), 1.2).unwrap();
    let arange_f64 = NdArray::arange(0., 10.).unwrap();
    let trues = NdArray::trues((3, 4)).unwrap();
    let booleans = NdArray::new(&[[true, false], [false, true]]).unwrap();


    let mut ndarrays = HashMap::new();
    ndarrays.insert("scalar".to_string(), DynamicNdArray::I32(scalar));
    ndarrays.insert("vector_f32".to_string(), DynamicNdArray::F32(vector_f32));
    ndarrays.insert("matrix_f32".to_string(), DynamicNdArray::I32(matrix_f32));
    ndarrays.insert("ones_f32".to_string(), DynamicNdArray::F32(ones_f32));
    ndarrays.insert("randn_f64".to_string(), DynamicNdArray::F64(randn_f64));
    ndarrays.insert("fill_f64".to_string(), DynamicNdArray::F64(fill_f64));
    ndarrays.insert("arange_f64".to_string(), DynamicNdArray::F64(arange_f64));
    ndarrays.insert("trues".to_string(), DynamicNdArray::Bool(trues));
    ndarrays.insert("booleans".to_string(), DynamicNdArray::Bool(booleans));

    numrst::io::save_zfile(&ndarrays, tmpfile.path()).unwrap();

    let ndarrays = numrst::io::load_zfile(tmpfile.path()).unwrap();
    for (name, _) in ndarrays {
        println!("{}", name);
    }
    Ok(())
}

examples/npy.rs (line 12)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let tmpfile = NamedTempFile::new().unwrap();

    let scalar = NdArray::new(1).unwrap();
    let vector_f32 = NdArray::new(&[1.0f32, 2., 3.]).unwrap();
    let matrix_f32 = NdArray::new(&[[1, 2, 3], [3, 4, 5]]).unwrap();
    let ones_f32 = NdArray::<f32>::ones((2, 9)).unwrap();
    let randn_f64 = NdArray::randn(0.0f64, 1., (1, 2, 3)).unwrap();
    let fill_f64 = NdArray::full((2, 3, 4), 1.2).unwrap();
    let arange_f64 = NdArray::arange(0., 10.).unwrap();
    let trues = NdArray::trues((3, 4)).unwrap();
    let booleans = NdArray::new(&[[true, false], [false, true]]).unwrap();

    let mut ndarrays = HashMap::new();
    ndarrays.insert("scalar".to_string(), DynamicNdArray::I32(scalar));
    ndarrays.insert("vector_f32".to_string(), DynamicNdArray::F32(vector_f32));
    ndarrays.insert("matrix_f32".to_string(), DynamicNdArray::I32(matrix_f32));
    ndarrays.insert("ones_f32".to_string(), DynamicNdArray::F32(ones_f32));
    ndarrays.insert("randn_f64".to_string(), DynamicNdArray::F64(randn_f64));
    ndarrays.insert("fill_f64".to_string(), DynamicNdArray::F64(fill_f64));
    ndarrays.insert("arange_f64".to_string(), DynamicNdArray::F64(arange_f64));
    ndarrays.insert("trues".to_string(), DynamicNdArray::Bool(trues));
    ndarrays.insert("booleans".to_string(), DynamicNdArray::Bool(booleans));

    numrst::io::save_npz_file(&ndarrays, tmpfile.path()).unwrap();

    let ndarrays = numrst::io::load_npz_file(tmpfile.path()).unwrap();
    for (name, _) in ndarrays {
        println!("{}", name);
    }

    Ok(())
}

pub fn ones_like(&self) -> Result<Self>

Creates a one-filled array with the same shape as self.

pub fn arange(start: T, end: T) -> Result<Self>

Creates a 1-D array with values from start up to (but not including) end.

use numrst::NdArray;

let a = NdArray::arange(0., 5.).unwrap();
println!("{}", a);

Examples found in repository

examples/broadcasting.rs (line 5)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let a = NdArray::<f32>::ones((3, 3))?;
    let b = NdArray::<f32>::arange(0.0, 3.0)?.reshape((3, 1))?;

    let c = a.broadcast_add(&b)?; // broadcasting
    println!("a:\n{}", a);
    println!("b:\n{}", b);
    println!("a + b (broadcast):\n{}", c);

    Ok(())
}

examples/indexing.rs (line 4)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let arr = NdArray::<u32>::arange(0, 27)?.reshape((3, 3, 3))?;

    let single = arr.index(1)?; // single element along first axis
    let slice = arr.index(rng!(1:3))?; // range
    let mixed = arr.index((rng!(0:2), .., 1..2))?; // mixed slicing

    println!("arr:\n{}", arr);
    println!("index(1):\n{}", single);
    println!("index(rng!(1:3)):\n{}", slice);
    println!("index((rng!(0:2), .., 1..2)):\n{}", mixed);

    Ok(())
}

examples/construct.rs (line 7)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create arrays with different constructors
    let zeros = NdArray::<f32>::zeros((2, 3))?;
    let ones = NdArray::<f32>::ones((2, 3))?;
    let arange = NdArray::<i32>::arange(0, 10)?;
    let rand = NdArray::<f32>::rand(0.0, 1.0, (2, 5, 3, 4))?;
    let randn = NdArray::<f32>::randn(0.0, 1.0, (2, 2))?;

    println!("zeros:\n{}", zeros);
    println!("ones:\n{}", ones);
    println!("arange:\n{}", arange);
    println!("rand:\n{}", rand);
    println!("randn:\n{}", randn);

    Ok(())
}

examples/reductions.rs (line 4)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let arr = NdArray::<f32>::arange(1.0, 10.0)?.reshape((3, 3))?;

    let sum = arr.sum();
    let prod = arr.product();
    let min = arr.min();
    let max = arr.max();
    let mean = arr.mean();
    let var = arr.var();
    let std = arr.std();

    println!("arr:\n{}", arr);
    println!("sum = {}", sum);
    println!("product = {}", prod);
    println!("min = {}", min);
    println!("max = {}", max);
    println!("mean = {:?}", mean);
    println!("var = {:?}", var);
    println!("std = {:?}", std);

    Ok(())
}

examples/logic.rs (line 5)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // --- Comparison ops ---
    let a = NdArray::<i32>::arange(0, 9)?.reshape((3, 3))?;
    let b = NdArray::<i32>::full((3, 3), 4)?;

    let eq = a.eq(&b)?;
    let ne = a.ne(&b)?;
    let lt = a.lt(&b)?;
    let ge = a.ge(&b)?;

    println!("a:\n{}", a);
    println!("b:\n{}", b);
    println!("a == b:\n{}", eq);
    println!("a != b:\n{}", ne);
    println!("a < b:\n{}", lt);
    println!("a >= b:\n{}", ge);

    // --- Boolean logic ops ---
    let x = NdArray::<bool>::trues((2, 2))?;
    let y = NdArray::<bool>::falses((2, 2))?;

    let and = x.and(&y)?;
    let or = x.or(&y)?;
    let xor = x.xor(&y)?;

    println!("\nx:\n{}", x);
    println!("y:\n{}", y);
    println!("x AND y:\n{}", and);
    println!("x OR y:\n{}", or);
    println!("x XOR y:\n{}", xor);

    // --- Using select (if-else like) ---
    let cond = a.lt(&b)?;
    let chosen = NdArray::<i32>::select(&cond, &a, &b)?;

    println!("\nCondition (a < b):\n{}", cond);
    println!("Select result (if a<b then a else b):\n{}", chosen);

    Ok(())
}

examples/nrst.rs (line 15)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let tmpfile = NamedTempFile::new().unwrap();

    let scalar = NdArray::new(1).unwrap();
    let vector_f32 = NdArray::new(&[1.0f32, 2., 3.]).unwrap();
    let matrix_f32 = NdArray::new(&[[1, 2, 3], [3, 4, 5]]).unwrap();
    let ones_f32 = NdArray::<f32>::ones((2, 9)).unwrap();
    let randn_f64 = NdArray::randn(0.0f64, 1., (1, 2, 3)).unwrap();
    let fill_f64 = NdArray::full((2, 3, 4), 1.2).unwrap();
    let arange_f64 = NdArray::arange(0., 10.).unwrap();
    let trues = NdArray::trues((3, 4)).unwrap();
    let booleans = NdArray::new(&[[true, false], [false, true]]).unwrap();


    let mut ndarrays = HashMap::new();
    ndarrays.insert("scalar".to_string(), DynamicNdArray::I32(scalar));
    ndarrays.insert("vector_f32".to_string(), DynamicNdArray::F32(vector_f32));
    ndarrays.insert("matrix_f32".to_string(), DynamicNdArray::I32(matrix_f32));
    ndarrays.insert("ones_f32".to_string(), DynamicNdArray::F32(ones_f32));
    ndarrays.insert("randn_f64".to_string(), DynamicNdArray::F64(randn_f64));
    ndarrays.insert("fill_f64".to_string(), DynamicNdArray::F64(fill_f64));
    ndarrays.insert("arange_f64".to_string(), DynamicNdArray::F64(arange_f64));
    ndarrays.insert("trues".to_string(), DynamicNdArray::Bool(trues));
    ndarrays.insert("booleans".to_string(), DynamicNdArray::Bool(booleans));

    numrst::io::save_zfile(&ndarrays, tmpfile.path()).unwrap();

    let ndarrays = numrst::io::load_zfile(tmpfile.path()).unwrap();
    for (name, _) in ndarrays {
        println!("{}", name);
    }
    Ok(())
}

Additional examples can be found in:

• examples/npy.rs
• examples/shape.rs

pub fn from_vec<V: Into<Vec<T>>, S: Into<Shape>>( vec: V, shape: S, ) -> Result<Self>

Creates an array from a flat Vec<T> and explicit shape.

use numrst::NdArray;

let a = NdArray::from_vec(vec![1, 2, 3, 4], (2, 2)).unwrap();
println!("{}", a);

pub fn eye(size: usize) -> Result<Self>

pub fn diag(diag: &[T]) -> Result<Self>

impl<T: WithDType + SampleUniform> NdArray<T>

where StandardUniform: Distribution<T>,

pub fn rand<S: Into<Shape>>(min: T, max: T, shape: S) -> Result<Self>

Creates an array with uniformly distributed random values in [min, max).

use numrst::NdArray;

let a = NdArray::<f32>::rand(0., 1., (2, 3)).unwrap();
println!("{}", a);

Examples found in repository

examples/matmul.rs (line 4)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let m1 = NdArray::<f32>::rand(0.0, 1.0, (2, 3))?;
    let m2 = NdArray::<f32>::rand(0.0, 1.0, (3, 4))?;
    let m3 = m1.matmul(&m2)?;

    println!("m1:\n{}", m1);
    println!("m2:\n{}", m2);
    println!("m1 @ m2:\n{}", m3);

    Ok(())
}

examples/construct.rs (line 8)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create arrays with different constructors
    let zeros = NdArray::<f32>::zeros((2, 3))?;
    let ones = NdArray::<f32>::ones((2, 3))?;
    let arange = NdArray::<i32>::arange(0, 10)?;
    let rand = NdArray::<f32>::rand(0.0, 1.0, (2, 5, 3, 4))?;
    let randn = NdArray::<f32>::randn(0.0, 1.0, (2, 2))?;

    println!("zeros:\n{}", zeros);
    println!("ones:\n{}", ones);
    println!("arange:\n{}", arange);
    println!("rand:\n{}", rand);
    println!("randn:\n{}", randn);

    Ok(())
}

pub fn rand_like(&self, min: T, max: T) -> Result<Self>

Creates a random array with the same shape as self.

impl<F: FloatDType> NdArray<F>

pub fn linspace(start: F, stop: F, num: usize) -> Result<Self>

Generate a 1-D NdArray of num evenly spaced values over the interval [start, stop).

Example

let arr = NdArray::linspace(0.0, 1.0, 5).unwrap();
assert_eq!(arr.to_vec(), [0.0, 0.2, 0.4, 0.6000000000000001, 0.8]);

impl<F: FloatDType> NdArray<F>

where StandardNormal: Distribution<F>,

pub fn randn<S: Into<Shape>>(mean: F, std: F, shape: S) -> Result<Self>

Creates an array with normally distributed random values with given mean and std.

use numrst::NdArray;

let a = NdArray::<f64>::randn(0.0, 1.0, (2, 2)).unwrap();
println!("{}", a);

Examples found in repository

examples/construct.rs (line 9)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create arrays with different constructors
    let zeros = NdArray::<f32>::zeros((2, 3))?;
    let ones = NdArray::<f32>::ones((2, 3))?;
    let arange = NdArray::<i32>::arange(0, 10)?;
    let rand = NdArray::<f32>::rand(0.0, 1.0, (2, 5, 3, 4))?;
    let randn = NdArray::<f32>::randn(0.0, 1.0, (2, 2))?;

    println!("zeros:\n{}", zeros);
    println!("ones:\n{}", ones);
    println!("arange:\n{}", arange);
    println!("rand:\n{}", rand);
    println!("randn:\n{}", randn);

    Ok(())
}

examples/nrst.rs (line 13)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let tmpfile = NamedTempFile::new().unwrap();

    let scalar = NdArray::new(1).unwrap();
    let vector_f32 = NdArray::new(&[1.0f32, 2., 3.]).unwrap();
    let matrix_f32 = NdArray::new(&[[1, 2, 3], [3, 4, 5]]).unwrap();
    let ones_f32 = NdArray::<f32>::ones((2, 9)).unwrap();
    let randn_f64 = NdArray::randn(0.0f64, 1., (1, 2, 3)).unwrap();
    let fill_f64 = NdArray::full((2, 3, 4), 1.2).unwrap();
    let arange_f64 = NdArray::arange(0., 10.).unwrap();
    let trues = NdArray::trues((3, 4)).unwrap();
    let booleans = NdArray::new(&[[true, false], [false, true]]).unwrap();


    let mut ndarrays = HashMap::new();
    ndarrays.insert("scalar".to_string(), DynamicNdArray::I32(scalar));
    ndarrays.insert("vector_f32".to_string(), DynamicNdArray::F32(vector_f32));
    ndarrays.insert("matrix_f32".to_string(), DynamicNdArray::I32(matrix_f32));
    ndarrays.insert("ones_f32".to_string(), DynamicNdArray::F32(ones_f32));
    ndarrays.insert("randn_f64".to_string(), DynamicNdArray::F64(randn_f64));
    ndarrays.insert("fill_f64".to_string(), DynamicNdArray::F64(fill_f64));
    ndarrays.insert("arange_f64".to_string(), DynamicNdArray::F64(arange_f64));
    ndarrays.insert("trues".to_string(), DynamicNdArray::Bool(trues));
    ndarrays.insert("booleans".to_string(), DynamicNdArray::Bool(booleans));

    numrst::io::save_zfile(&ndarrays, tmpfile.path()).unwrap();

    let ndarrays = numrst::io::load_zfile(tmpfile.path()).unwrap();
    for (name, _) in ndarrays {
        println!("{}", name);
    }
    Ok(())
}

examples/npy.rs (line 13)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let tmpfile = NamedTempFile::new().unwrap();

    let scalar = NdArray::new(1).unwrap();
    let vector_f32 = NdArray::new(&[1.0f32, 2., 3.]).unwrap();
    let matrix_f32 = NdArray::new(&[[1, 2, 3], [3, 4, 5]]).unwrap();
    let ones_f32 = NdArray::<f32>::ones((2, 9)).unwrap();
    let randn_f64 = NdArray::randn(0.0f64, 1., (1, 2, 3)).unwrap();
    let fill_f64 = NdArray::full((2, 3, 4), 1.2).unwrap();
    let arange_f64 = NdArray::arange(0., 10.).unwrap();
    let trues = NdArray::trues((3, 4)).unwrap();
    let booleans = NdArray::new(&[[true, false], [false, true]]).unwrap();

    let mut ndarrays = HashMap::new();
    ndarrays.insert("scalar".to_string(), DynamicNdArray::I32(scalar));
    ndarrays.insert("vector_f32".to_string(), DynamicNdArray::F32(vector_f32));
    ndarrays.insert("matrix_f32".to_string(), DynamicNdArray::I32(matrix_f32));
    ndarrays.insert("ones_f32".to_string(), DynamicNdArray::F32(ones_f32));
    ndarrays.insert("randn_f64".to_string(), DynamicNdArray::F64(randn_f64));
    ndarrays.insert("fill_f64".to_string(), DynamicNdArray::F64(fill_f64));
    ndarrays.insert("arange_f64".to_string(), DynamicNdArray::F64(arange_f64));
    ndarrays.insert("trues".to_string(), DynamicNdArray::Bool(trues));
    ndarrays.insert("booleans".to_string(), DynamicNdArray::Bool(booleans));

    numrst::io::save_npz_file(&ndarrays, tmpfile.path()).unwrap();

    let ndarrays = numrst::io::load_npz_file(tmpfile.path()).unwrap();
    for (name, _) in ndarrays {
        println!("{}", name);
    }

    Ok(())
}

pub fn randn_like(&self, mean: F, std: F) -> Result<Self>

Creates a normal-distributed random array with the same shape as self.

Examples found in repository

examples/view.rs (line 8)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let total = NdArray::<f32>::zeros((5, 5)).unwrap();

    {
        let mut sub = total.index((1..3, 2..4)).unwrap();
        let source = sub.randn_like(0.0, 1.0).unwrap();
        let mut sub_view = sub.matrix_view_mut().unwrap();

        sub_view.copy_from(&source).unwrap();
    }
    
    println!("{}", total);

    Ok(())
}

impl NdArray<bool>

pub fn trues<S: Into<Shape>>(shape: S) -> Result<Self>

Creates a boolean array filled with true.

use numrst::NdArray;

let a = NdArray::trues((2, 2)).unwrap();
println!("{}", a);

Examples found in repository

examples/logic.rs (line 21)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // --- Comparison ops ---
    let a = NdArray::<i32>::arange(0, 9)?.reshape((3, 3))?;
    let b = NdArray::<i32>::full((3, 3), 4)?;

    let eq = a.eq(&b)?;
    let ne = a.ne(&b)?;
    let lt = a.lt(&b)?;
    let ge = a.ge(&b)?;

    println!("a:\n{}", a);
    println!("b:\n{}", b);
    println!("a == b:\n{}", eq);
    println!("a != b:\n{}", ne);
    println!("a < b:\n{}", lt);
    println!("a >= b:\n{}", ge);

    // --- Boolean logic ops ---
    let x = NdArray::<bool>::trues((2, 2))?;
    let y = NdArray::<bool>::falses((2, 2))?;

    let and = x.and(&y)?;
    let or = x.or(&y)?;
    let xor = x.xor(&y)?;

    println!("\nx:\n{}", x);
    println!("y:\n{}", y);
    println!("x AND y:\n{}", and);
    println!("x OR y:\n{}", or);
    println!("x XOR y:\n{}", xor);

    // --- Using select (if-else like) ---
    let cond = a.lt(&b)?;
    let chosen = NdArray::<i32>::select(&cond, &a, &b)?;

    println!("\nCondition (a < b):\n{}", cond);
    println!("Select result (if a<b then a else b):\n{}", chosen);

    Ok(())
}

examples/nrst.rs (line 16)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let tmpfile = NamedTempFile::new().unwrap();

    let scalar = NdArray::new(1).unwrap();
    let vector_f32 = NdArray::new(&[1.0f32, 2., 3.]).unwrap();
    let matrix_f32 = NdArray::new(&[[1, 2, 3], [3, 4, 5]]).unwrap();
    let ones_f32 = NdArray::<f32>::ones((2, 9)).unwrap();
    let randn_f64 = NdArray::randn(0.0f64, 1., (1, 2, 3)).unwrap();
    let fill_f64 = NdArray::full((2, 3, 4), 1.2).unwrap();
    let arange_f64 = NdArray::arange(0., 10.).unwrap();
    let trues = NdArray::trues((3, 4)).unwrap();
    let booleans = NdArray::new(&[[true, false], [false, true]]).unwrap();


    let mut ndarrays = HashMap::new();
    ndarrays.insert("scalar".to_string(), DynamicNdArray::I32(scalar));
    ndarrays.insert("vector_f32".to_string(), DynamicNdArray::F32(vector_f32));
    ndarrays.insert("matrix_f32".to_string(), DynamicNdArray::I32(matrix_f32));
    ndarrays.insert("ones_f32".to_string(), DynamicNdArray::F32(ones_f32));
    ndarrays.insert("randn_f64".to_string(), DynamicNdArray::F64(randn_f64));
    ndarrays.insert("fill_f64".to_string(), DynamicNdArray::F64(fill_f64));
    ndarrays.insert("arange_f64".to_string(), DynamicNdArray::F64(arange_f64));
    ndarrays.insert("trues".to_string(), DynamicNdArray::Bool(trues));
    ndarrays.insert("booleans".to_string(), DynamicNdArray::Bool(booleans));

    numrst::io::save_zfile(&ndarrays, tmpfile.path()).unwrap();

    let ndarrays = numrst::io::load_zfile(tmpfile.path()).unwrap();
    for (name, _) in ndarrays {
        println!("{}", name);
    }
    Ok(())
}

examples/npy.rs (line 16)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let tmpfile = NamedTempFile::new().unwrap();

    let scalar = NdArray::new(1).unwrap();
    let vector_f32 = NdArray::new(&[1.0f32, 2., 3.]).unwrap();
    let matrix_f32 = NdArray::new(&[[1, 2, 3], [3, 4, 5]]).unwrap();
    let ones_f32 = NdArray::<f32>::ones((2, 9)).unwrap();
    let randn_f64 = NdArray::randn(0.0f64, 1., (1, 2, 3)).unwrap();
    let fill_f64 = NdArray::full((2, 3, 4), 1.2).unwrap();
    let arange_f64 = NdArray::arange(0., 10.).unwrap();
    let trues = NdArray::trues((3, 4)).unwrap();
    let booleans = NdArray::new(&[[true, false], [false, true]]).unwrap();

    let mut ndarrays = HashMap::new();
    ndarrays.insert("scalar".to_string(), DynamicNdArray::I32(scalar));
    ndarrays.insert("vector_f32".to_string(), DynamicNdArray::F32(vector_f32));
    ndarrays.insert("matrix_f32".to_string(), DynamicNdArray::I32(matrix_f32));
    ndarrays.insert("ones_f32".to_string(), DynamicNdArray::F32(ones_f32));
    ndarrays.insert("randn_f64".to_string(), DynamicNdArray::F64(randn_f64));
    ndarrays.insert("fill_f64".to_string(), DynamicNdArray::F64(fill_f64));
    ndarrays.insert("arange_f64".to_string(), DynamicNdArray::F64(arange_f64));
    ndarrays.insert("trues".to_string(), DynamicNdArray::Bool(trues));
    ndarrays.insert("booleans".to_string(), DynamicNdArray::Bool(booleans));

    numrst::io::save_npz_file(&ndarrays, tmpfile.path()).unwrap();

    let ndarrays = numrst::io::load_npz_file(tmpfile.path()).unwrap();
    for (name, _) in ndarrays {
        println!("{}", name);
    }

    Ok(())
}

pub fn falses<S: Into<Shape>>(shape: S) -> Result<Self>

Creates a boolean array filled with false.

Examples found in repository

examples/logic.rs (line 22)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // --- Comparison ops ---
    let a = NdArray::<i32>::arange(0, 9)?.reshape((3, 3))?;
    let b = NdArray::<i32>::full((3, 3), 4)?;

    let eq = a.eq(&b)?;
    let ne = a.ne(&b)?;
    let lt = a.lt(&b)?;
    let ge = a.ge(&b)?;

    println!("a:\n{}", a);
    println!("b:\n{}", b);
    println!("a == b:\n{}", eq);
    println!("a != b:\n{}", ne);
    println!("a < b:\n{}", lt);
    println!("a >= b:\n{}", ge);

    // --- Boolean logic ops ---
    let x = NdArray::<bool>::trues((2, 2))?;
    let y = NdArray::<bool>::falses((2, 2))?;

    let and = x.and(&y)?;
    let or = x.or(&y)?;
    let xor = x.xor(&y)?;

    println!("\nx:\n{}", x);
    println!("y:\n{}", y);
    println!("x AND y:\n{}", and);
    println!("x OR y:\n{}", or);
    println!("x XOR y:\n{}", xor);

    // --- Using select (if-else like) ---
    let cond = a.lt(&b)?;
    let chosen = NdArray::<i32>::select(&cond, &a, &b)?;

    println!("\nCondition (a < b):\n{}", cond);
    println!("Select result (if a<b then a else b):\n{}", chosen);

    Ok(())
}

impl<T: WithDType> NdArray<T>

pub fn take<I: UnsignedIntDType>( &self, indices: &NdArray<I>, ) -> Result<NdArray<T>>

impl<T: WithDType> NdArray<T>

pub fn matrix_get(&self, row: usize, col: usize) -> Result<T>

pub fn matrix_set(&self, row: usize, col: usize, val: T) -> Result<()>

pub fn vector_get(&self, n: usize) -> Result<T>

impl<T: WithDType> NdArray<T>

pub fn iter(&self) -> NdArrayIter<'_, T>

impl<T: WithDType> NdArray<T>

pub fn squeeze<D: Dim>(&self, dim: D) -> Result<Self>

Creates a new tensor with the specified dimension removed if its size was one.

use numrst::{NdArray, DType, D};
let a = NdArray::<f32>::zeros((2, 3, 1)).unwrap();

let c = a.squeeze(2).unwrap();
assert_eq!(c.shape().dims(), &[2, 3]);

Examples found in repository

examples/shape.rs (line 20)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // --- Reshape ---
    let a = NdArray::<i32>::arange(0, 12)?;
    let a2d = a.reshape((3, 4))?;
    let a3d = a.reshape((2, 2, 3))?;

    println!("Original a (1D):\n{}", a);
    println!("Reshaped a (3x4):\n{}", a2d);
    println!("Reshaped a (2x2x3):\n{}", a3d);

    // --- Transpose ---
    let t = a2d.transpose(0, 1)?;
    println!("Transpose a2d (swap dim 0 <-> 1):\n{}", t);

    // --- Unsqueeze & Squeeze ---
    let b = NdArray::<f32>::arange(0.0, 6.0)?.reshape((2, 3))?;
    let b_unsq = b.unsqueeze(0)?; // add axis at front -> (1,2,3)
    let b_sq = b_unsq.squeeze(0)?; // remove axis -> (2,3)

    println!("b shape: {}", b.shape());
    println!("b_unsq shape: {}", b_unsq.shape());
    println!("b_sq shape: {}", b_sq.shape());

    // --- Narrow & Narrow Range ---
    let narrowed = b.narrow(1, 0, 2)?; // take first 2 cols along axis 1
    let narrowed_range = b.narrow_range(1, &rng!(0:2))?;

    println!("narrowed (axis=1, first 2 cols):\n{}", narrowed);
    println!("narrowed_range (axis=1, 0..2):\n{}", narrowed_range);

    // --- Concatenate ---
    let c1 = NdArray::<i32>::full((2, 2), 1)?;
    let c2 = NdArray::<i32>::full((2, 2), 2)?;
    let cat = NdArray::cat(&[&c1, &c2], 0)?; // concat along axis=0

    println!("Concatenate along axis=0:\n{}", cat);

    // --- Stack ---
    let s1 = NdArray::<i32>::full((2, 2), 3)?;
    let s2 = NdArray::<i32>::full((2, 2), 4)?;
    let stacked = NdArray::stack(&[&s1, &s2], 0)?; // stack new axis

    println!("Stacked along new axis=0:\n{}", stacked);

    Ok(())
}

pub fn unsqueeze<D: Dim>(&self, dim: D) -> Result<Self>

Creates a new tensor with a dimension of size one inserted at the specified position.

use numrst::{NdArray, DType, D};
let a = NdArray::<f32>::zeros((2, 3)).unwrap();

let c = a.unsqueeze(0).unwrap();
assert_eq!(c.shape().dims(), &[1, 2, 3]);

let c = a.unsqueeze(D::Minus1).unwrap();
assert_eq!(c.shape().dims(), &[2, 3, 1]);

Examples found in repository

examples/shape.rs (line 19)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // --- Reshape ---
    let a = NdArray::<i32>::arange(0, 12)?;
    let a2d = a.reshape((3, 4))?;
    let a3d = a.reshape((2, 2, 3))?;

    println!("Original a (1D):\n{}", a);
    println!("Reshaped a (3x4):\n{}", a2d);
    println!("Reshaped a (2x2x3):\n{}", a3d);

    // --- Transpose ---
    let t = a2d.transpose(0, 1)?;
    println!("Transpose a2d (swap dim 0 <-> 1):\n{}", t);

    // --- Unsqueeze & Squeeze ---
    let b = NdArray::<f32>::arange(0.0, 6.0)?.reshape((2, 3))?;
    let b_unsq = b.unsqueeze(0)?; // add axis at front -> (1,2,3)
    let b_sq = b_unsq.squeeze(0)?; // remove axis -> (2,3)

    println!("b shape: {}", b.shape());
    println!("b_unsq shape: {}", b_unsq.shape());
    println!("b_sq shape: {}", b_sq.shape());

    // --- Narrow & Narrow Range ---
    let narrowed = b.narrow(1, 0, 2)?; // take first 2 cols along axis 1
    let narrowed_range = b.narrow_range(1, &rng!(0:2))?;

    println!("narrowed (axis=1, first 2 cols):\n{}", narrowed);
    println!("narrowed_range (axis=1, 0..2):\n{}", narrowed_range);

    // --- Concatenate ---
    let c1 = NdArray::<i32>::full((2, 2), 1)?;
    let c2 = NdArray::<i32>::full((2, 2), 2)?;
    let cat = NdArray::cat(&[&c1, &c2], 0)?; // concat along axis=0

    println!("Concatenate along axis=0:\n{}", cat);

    // --- Stack ---
    let s1 = NdArray::<i32>::full((2, 2), 3)?;
    let s2 = NdArray::<i32>::full((2, 2), 4)?;
    let stacked = NdArray::stack(&[&s1, &s2], 0)?; // stack new axis

    println!("Stacked along new axis=0:\n{}", stacked);

    Ok(())
}

pub fn narrow<D: Dim>(&self, dim: D, start: usize, len: usize) -> Result<Self>

Returns a new tensor that is a narrowed version of the input, the dimension dim ranges from start to start + len.

use numrst::NdArray;
let a = NdArray::new(&[
    [0f32, 1., 2.],
    [3.  , 4., 5.],
    [6.  , 7., 8.]
]).unwrap();

let b = a.narrow(0, 1, 2).unwrap();
assert_eq!(b.shape().dims(), &[2, 3]);

let c = a.narrow(1, 1, 1).unwrap();
assert_eq!(c.shape().dims(), &[3, 1]);

Examples found in repository

examples/shape.rs (line 27)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // --- Reshape ---
    let a = NdArray::<i32>::arange(0, 12)?;
    let a2d = a.reshape((3, 4))?;
    let a3d = a.reshape((2, 2, 3))?;

    println!("Original a (1D):\n{}", a);
    println!("Reshaped a (3x4):\n{}", a2d);
    println!("Reshaped a (2x2x3):\n{}", a3d);

    // --- Transpose ---
    let t = a2d.transpose(0, 1)?;
    println!("Transpose a2d (swap dim 0 <-> 1):\n{}", t);

    // --- Unsqueeze & Squeeze ---
    let b = NdArray::<f32>::arange(0.0, 6.0)?.reshape((2, 3))?;
    let b_unsq = b.unsqueeze(0)?; // add axis at front -> (1,2,3)
    let b_sq = b_unsq.squeeze(0)?; // remove axis -> (2,3)

    println!("b shape: {}", b.shape());
    println!("b_unsq shape: {}", b_unsq.shape());
    println!("b_sq shape: {}", b_sq.shape());

    // --- Narrow & Narrow Range ---
    let narrowed = b.narrow(1, 0, 2)?; // take first 2 cols along axis 1
    let narrowed_range = b.narrow_range(1, &rng!(0:2))?;

    println!("narrowed (axis=1, first 2 cols):\n{}", narrowed);
    println!("narrowed_range (axis=1, 0..2):\n{}", narrowed_range);

    // --- Concatenate ---
    let c1 = NdArray::<i32>::full((2, 2), 1)?;
    let c2 = NdArray::<i32>::full((2, 2), 2)?;
    let cat = NdArray::cat(&[&c1, &c2], 0)?; // concat along axis=0

    println!("Concatenate along axis=0:\n{}", cat);

    // --- Stack ---
    let s1 = NdArray::<i32>::full((2, 2), 3)?;
    let s2 = NdArray::<i32>::full((2, 2), 4)?;
    let stacked = NdArray::stack(&[&s1, &s2], 0)?; // stack new axis

    println!("Stacked along new axis=0:\n{}", stacked);

    Ok(())
}

pub fn narrow_range<D: Dim>(&self, dim: D, range: &Range) -> Result<Self>

Returns a new tensor that is a narrowed version of the input, the dimension dim ranges from start to start : end : step.

TODO: set range to a trait param

use numrst::{NdArray, DType, rng, Range};
let a = NdArray::<i32>::zeros((5, 5, 5)).unwrap();

let b = a.narrow(0, 1, 2).unwrap();
assert_eq!(b.shape().dims(), &[2, 5, 5]);

let c = a.narrow_range(1, &rng!(::2)).unwrap();
assert_eq!(c.shape().dims(), &[5, 3, 5]);

Examples found in repository

examples/shape.rs (line 28)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // --- Reshape ---
    let a = NdArray::<i32>::arange(0, 12)?;
    let a2d = a.reshape((3, 4))?;
    let a3d = a.reshape((2, 2, 3))?;

    println!("Original a (1D):\n{}", a);
    println!("Reshaped a (3x4):\n{}", a2d);
    println!("Reshaped a (2x2x3):\n{}", a3d);

    // --- Transpose ---
    let t = a2d.transpose(0, 1)?;
    println!("Transpose a2d (swap dim 0 <-> 1):\n{}", t);

    // --- Unsqueeze & Squeeze ---
    let b = NdArray::<f32>::arange(0.0, 6.0)?.reshape((2, 3))?;
    let b_unsq = b.unsqueeze(0)?; // add axis at front -> (1,2,3)
    let b_sq = b_unsq.squeeze(0)?; // remove axis -> (2,3)

    println!("b shape: {}", b.shape());
    println!("b_unsq shape: {}", b_unsq.shape());
    println!("b_sq shape: {}", b_sq.shape());

    // --- Narrow & Narrow Range ---
    let narrowed = b.narrow(1, 0, 2)?; // take first 2 cols along axis 1
    let narrowed_range = b.narrow_range(1, &rng!(0:2))?;

    println!("narrowed (axis=1, first 2 cols):\n{}", narrowed);
    println!("narrowed_range (axis=1, 0..2):\n{}", narrowed_range);

    // --- Concatenate ---
    let c1 = NdArray::<i32>::full((2, 2), 1)?;
    let c2 = NdArray::<i32>::full((2, 2), 2)?;
    let cat = NdArray::cat(&[&c1, &c2], 0)?; // concat along axis=0

    println!("Concatenate along axis=0:\n{}", cat);

    // --- Stack ---
    let s1 = NdArray::<i32>::full((2, 2), 3)?;
    let s2 = NdArray::<i32>::full((2, 2), 4)?;
    let stacked = NdArray::stack(&[&s1, &s2], 0)?; // stack new axis

    println!("Stacked along new axis=0:\n{}", stacked);

    Ok(())
}

pub fn reshape<S: Into<Shape>>(&self, shape: S) -> Result<Self>

Reshape returns a tensor with the target shape provided that the number of elements of the original tensor is the same. If the input tensor is contiguous, this is a view on the original data. Otherwise this uses a new storage and copies the data over, the returned tensor is always contiguous.

The shape can be specified using a tuple of usize and at most one () in which case the behavior is the same as when using -1 in PyTorch: this dimension size is adjusted so as to match the number of elements in the tensor.

use numrst::{NdArray, DType, D};
let a = NdArray::<f32>::zeros((2, 3)).unwrap();

let c = a.reshape((1, 6)).unwrap();
assert_eq!(c.shape().dims(), &[1, 6]);

Examples found in repository

examples/broadcasting.rs (line 5)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let a = NdArray::<f32>::ones((3, 3))?;
    let b = NdArray::<f32>::arange(0.0, 3.0)?.reshape((3, 1))?;

    let c = a.broadcast_add(&b)?; // broadcasting
    println!("a:\n{}", a);
    println!("b:\n{}", b);
    println!("a + b (broadcast):\n{}", c);

    Ok(())
}

examples/indexing.rs (line 4)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let arr = NdArray::<u32>::arange(0, 27)?.reshape((3, 3, 3))?;

    let single = arr.index(1)?; // single element along first axis
    let slice = arr.index(rng!(1:3))?; // range
    let mixed = arr.index((rng!(0:2), .., 1..2))?; // mixed slicing

    println!("arr:\n{}", arr);
    println!("index(1):\n{}", single);
    println!("index(rng!(1:3)):\n{}", slice);
    println!("index((rng!(0:2), .., 1..2)):\n{}", mixed);

    Ok(())
}

examples/reductions.rs (line 4)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let arr = NdArray::<f32>::arange(1.0, 10.0)?.reshape((3, 3))?;

    let sum = arr.sum();
    let prod = arr.product();
    let min = arr.min();
    let max = arr.max();
    let mean = arr.mean();
    let var = arr.var();
    let std = arr.std();

    println!("arr:\n{}", arr);
    println!("sum = {}", sum);
    println!("product = {}", prod);
    println!("min = {}", min);
    println!("max = {}", max);
    println!("mean = {:?}", mean);
    println!("var = {:?}", var);
    println!("std = {:?}", std);

    Ok(())
}

examples/logic.rs (line 5)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // --- Comparison ops ---
    let a = NdArray::<i32>::arange(0, 9)?.reshape((3, 3))?;
    let b = NdArray::<i32>::full((3, 3), 4)?;

    let eq = a.eq(&b)?;
    let ne = a.ne(&b)?;
    let lt = a.lt(&b)?;
    let ge = a.ge(&b)?;

    println!("a:\n{}", a);
    println!("b:\n{}", b);
    println!("a == b:\n{}", eq);
    println!("a != b:\n{}", ne);
    println!("a < b:\n{}", lt);
    println!("a >= b:\n{}", ge);

    // --- Boolean logic ops ---
    let x = NdArray::<bool>::trues((2, 2))?;
    let y = NdArray::<bool>::falses((2, 2))?;

    let and = x.and(&y)?;
    let or = x.or(&y)?;
    let xor = x.xor(&y)?;

    println!("\nx:\n{}", x);
    println!("y:\n{}", y);
    println!("x AND y:\n{}", and);
    println!("x OR y:\n{}", or);
    println!("x XOR y:\n{}", xor);

    // --- Using select (if-else like) ---
    let cond = a.lt(&b)?;
    let chosen = NdArray::<i32>::select(&cond, &a, &b)?;

    println!("\nCondition (a < b):\n{}", cond);
    println!("Select result (if a<b then a else b):\n{}", chosen);

    Ok(())
}

examples/shape.rs (line 6)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // --- Reshape ---
    let a = NdArray::<i32>::arange(0, 12)?;
    let a2d = a.reshape((3, 4))?;
    let a3d = a.reshape((2, 2, 3))?;

    println!("Original a (1D):\n{}", a);
    println!("Reshaped a (3x4):\n{}", a2d);
    println!("Reshaped a (2x2x3):\n{}", a3d);

    // --- Transpose ---
    let t = a2d.transpose(0, 1)?;
    println!("Transpose a2d (swap dim 0 <-> 1):\n{}", t);

    // --- Unsqueeze & Squeeze ---
    let b = NdArray::<f32>::arange(0.0, 6.0)?.reshape((2, 3))?;
    let b_unsq = b.unsqueeze(0)?; // add axis at front -> (1,2,3)
    let b_sq = b_unsq.squeeze(0)?; // remove axis -> (2,3)

    println!("b shape: {}", b.shape());
    println!("b_unsq shape: {}", b_unsq.shape());
    println!("b_sq shape: {}", b_sq.shape());

    // --- Narrow & Narrow Range ---
    let narrowed = b.narrow(1, 0, 2)?; // take first 2 cols along axis 1
    let narrowed_range = b.narrow_range(1, &rng!(0:2))?;

    println!("narrowed (axis=1, first 2 cols):\n{}", narrowed);
    println!("narrowed_range (axis=1, 0..2):\n{}", narrowed_range);

    // --- Concatenate ---
    let c1 = NdArray::<i32>::full((2, 2), 1)?;
    let c2 = NdArray::<i32>::full((2, 2), 2)?;
    let cat = NdArray::cat(&[&c1, &c2], 0)?; // concat along axis=0

    println!("Concatenate along axis=0:\n{}", cat);

    // --- Stack ---
    let s1 = NdArray::<i32>::full((2, 2), 3)?;
    let s2 = NdArray::<i32>::full((2, 2), 4)?;
    let stacked = NdArray::stack(&[&s1, &s2], 0)?; // stack new axis

    println!("Stacked along new axis=0:\n{}", stacked);

    Ok(())
}

pub fn transpose<D1: Dim, D2: Dim>(&self, dim1: D1, dim2: D2) -> Result<Self>

Returns a ndarray that is a transposed version of the input, the given dimensions are

Examples found in repository

examples/shape.rs (line 14)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // --- Reshape ---
    let a = NdArray::<i32>::arange(0, 12)?;
    let a2d = a.reshape((3, 4))?;
    let a3d = a.reshape((2, 2, 3))?;

    println!("Original a (1D):\n{}", a);
    println!("Reshaped a (3x4):\n{}", a2d);
    println!("Reshaped a (2x2x3):\n{}", a3d);

    // --- Transpose ---
    let t = a2d.transpose(0, 1)?;
    println!("Transpose a2d (swap dim 0 <-> 1):\n{}", t);

    // --- Unsqueeze & Squeeze ---
    let b = NdArray::<f32>::arange(0.0, 6.0)?.reshape((2, 3))?;
    let b_unsq = b.unsqueeze(0)?; // add axis at front -> (1,2,3)
    let b_sq = b_unsq.squeeze(0)?; // remove axis -> (2,3)

    println!("b shape: {}", b.shape());
    println!("b_unsq shape: {}", b_unsq.shape());
    println!("b_sq shape: {}", b_sq.shape());

    // --- Narrow & Narrow Range ---
    let narrowed = b.narrow(1, 0, 2)?; // take first 2 cols along axis 1
    let narrowed_range = b.narrow_range(1, &rng!(0:2))?;

    println!("narrowed (axis=1, first 2 cols):\n{}", narrowed);
    println!("narrowed_range (axis=1, 0..2):\n{}", narrowed_range);

    // --- Concatenate ---
    let c1 = NdArray::<i32>::full((2, 2), 1)?;
    let c2 = NdArray::<i32>::full((2, 2), 2)?;
    let cat = NdArray::cat(&[&c1, &c2], 0)?; // concat along axis=0

    println!("Concatenate along axis=0:\n{}", cat);

    // --- Stack ---
    let s1 = NdArray::<i32>::full((2, 2), 3)?;
    let s2 = NdArray::<i32>::full((2, 2), 4)?;
    let stacked = NdArray::stack(&[&s1, &s2], 0)?; // stack new axis

    println!("Stacked along new axis=0:\n{}", stacked);

    Ok(())
}

pub fn transpose_last(&self) -> Result<Self>

pub fn cat<A: AsRef<NdArray<T>>, D: Dim>(arrs: &[A], dim: D) -> Result<Self>

Concatenates two or more tensors along a particular dimension.

All tensors must of the same rank, and the output will have the same rank

use numrst::NdArray;
let a = NdArray::<f32>::zeros((2, 3)).unwrap();
let b = NdArray::<f32>::zeros((2, 3)).unwrap();

let c = NdArray::cat(&[&a, &b], 0).unwrap();
assert_eq!(c.dims(), &[4, 3]);

let c = NdArray::cat(&[&a, &b], 1).unwrap();
assert_eq!(c.dims(), &[2, 6]);

Examples found in repository

examples/shape.rs (line 36)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // --- Reshape ---
    let a = NdArray::<i32>::arange(0, 12)?;
    let a2d = a.reshape((3, 4))?;
    let a3d = a.reshape((2, 2, 3))?;

    println!("Original a (1D):\n{}", a);
    println!("Reshaped a (3x4):\n{}", a2d);
    println!("Reshaped a (2x2x3):\n{}", a3d);

    // --- Transpose ---
    let t = a2d.transpose(0, 1)?;
    println!("Transpose a2d (swap dim 0 <-> 1):\n{}", t);

    // --- Unsqueeze & Squeeze ---
    let b = NdArray::<f32>::arange(0.0, 6.0)?.reshape((2, 3))?;
    let b_unsq = b.unsqueeze(0)?; // add axis at front -> (1,2,3)
    let b_sq = b_unsq.squeeze(0)?; // remove axis -> (2,3)

    println!("b shape: {}", b.shape());
    println!("b_unsq shape: {}", b_unsq.shape());
    println!("b_sq shape: {}", b_sq.shape());

    // --- Narrow & Narrow Range ---
    let narrowed = b.narrow(1, 0, 2)?; // take first 2 cols along axis 1
    let narrowed_range = b.narrow_range(1, &rng!(0:2))?;

    println!("narrowed (axis=1, first 2 cols):\n{}", narrowed);
    println!("narrowed_range (axis=1, 0..2):\n{}", narrowed_range);

    // --- Concatenate ---
    let c1 = NdArray::<i32>::full((2, 2), 1)?;
    let c2 = NdArray::<i32>::full((2, 2), 2)?;
    let cat = NdArray::cat(&[&c1, &c2], 0)?; // concat along axis=0

    println!("Concatenate along axis=0:\n{}", cat);

    // --- Stack ---
    let s1 = NdArray::<i32>::full((2, 2), 3)?;
    let s2 = NdArray::<i32>::full((2, 2), 4)?;
    let stacked = NdArray::stack(&[&s1, &s2], 0)?; // stack new axis

    println!("Stacked along new axis=0:\n{}", stacked);

    Ok(())
}

pub fn stack<A: AsRef<NdArray<T>>, D: Dim>(args: &[A], dim: D) -> Result<Self>

Stacks two or more tensors along a particular dimension.

All tensors must have the same rank, and the output has one additional rank

use numrst::NdArray;
let a = NdArray::<f32>::zeros((2, 3)).unwrap();
let b = NdArray::<f32>::zeros((2, 3)).unwrap();

let c = NdArray::stack(&[&a, &b], 0).unwrap();
assert_eq!(c.dims(), &[2, 2, 3]);

let c = NdArray::stack(&[&a, &b], 2).unwrap();
assert_eq!(c.dims(), &[2, 3, 2]);

Examples found in repository

examples/shape.rs (line 43)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // --- Reshape ---
    let a = NdArray::<i32>::arange(0, 12)?;
    let a2d = a.reshape((3, 4))?;
    let a3d = a.reshape((2, 2, 3))?;

    println!("Original a (1D):\n{}", a);
    println!("Reshaped a (3x4):\n{}", a2d);
    println!("Reshaped a (2x2x3):\n{}", a3d);

    // --- Transpose ---
    let t = a2d.transpose(0, 1)?;
    println!("Transpose a2d (swap dim 0 <-> 1):\n{}", t);

    // --- Unsqueeze & Squeeze ---
    let b = NdArray::<f32>::arange(0.0, 6.0)?.reshape((2, 3))?;
    let b_unsq = b.unsqueeze(0)?; // add axis at front -> (1,2,3)
    let b_sq = b_unsq.squeeze(0)?; // remove axis -> (2,3)

    println!("b shape: {}", b.shape());
    println!("b_unsq shape: {}", b_unsq.shape());
    println!("b_sq shape: {}", b_sq.shape());

    // --- Narrow & Narrow Range ---
    let narrowed = b.narrow(1, 0, 2)?; // take first 2 cols along axis 1
    let narrowed_range = b.narrow_range(1, &rng!(0:2))?;

    println!("narrowed (axis=1, first 2 cols):\n{}", narrowed);
    println!("narrowed_range (axis=1, 0..2):\n{}", narrowed_range);

    // --- Concatenate ---
    let c1 = NdArray::<i32>::full((2, 2), 1)?;
    let c2 = NdArray::<i32>::full((2, 2), 2)?;
    let cat = NdArray::cat(&[&c1, &c2], 0)?; // concat along axis=0

    println!("Concatenate along axis=0:\n{}", cat);

    // --- Stack ---
    let s1 = NdArray::<i32>::full((2, 2), 3)?;
    let s2 = NdArray::<i32>::full((2, 2), 4)?;
    let stacked = NdArray::stack(&[&s1, &s2], 0)?; // stack new axis

    println!("Stacked along new axis=0:\n{}", stacked);

    Ok(())
}

pub fn split<D: Dim>(&self, dim: D) -> Result<Vec<Self>>

Splits a tensor along a specified dimension into multiple sub-tensors.

The tensor is split along the given dim into as many sub-tensors as the size of that dimension. Each sub-tensor has the same shape as the original tensor, except the size along dim becomes 1.

use numrst::NdArray;

let a = NdArray::new(&[[1, 2], [3, 4], [5, 6]]).unwrap();

// Split along axis 0 (rows)
let splits = a.split(0).unwrap();
assert_eq!(splits.len(), 3);
assert_eq!(splits[0].to_vec(), [1, 2]);
assert_eq!(splits[1].to_vec(), [3, 4]);
assert_eq!(splits[2].to_vec(), [5, 6]);

// Split along axis 1 (columns)
let splits = a.split(1).unwrap();
assert_eq!(splits.len(), 2);
assert_eq!(splits[0].to_vec(), [1, 3, 5]);
assert_eq!(splits[1].to_vec(), [2, 4, 6]);

// 1D array
let b = NdArray::new(&[10, 20, 30]).unwrap();
let splits = b.split(0).unwrap();
assert_eq!(splits.len(), 3);
assert_eq!(splits[0].to_vec(), [10]);
assert_eq!(splits[1].to_vec(), [20]);
assert_eq!(splits[2].to_vec(), [30]);

pub fn flatten<D1: Dim, D2: Dim>( &self, start_dim: D1, end_dim: D2, ) -> Result<Self>

Flattens the input tensor on the dimension indexes from start_dim to end_dim (both inclusive).

pub fn flatten_to<D: Dim>(&self, end_dim: D) -> Result<Self>

Flattens the input tensor on the dimension indexes from 0 to end_dim (inclusive).

pub fn flatten_from<D: Dim>(&self, start_dim: D) -> Result<Self>

Flattens the input tensor on the dimension indexes from start_dim (inclusive) to the last dimension.

pub fn flatten_all(&self) -> Result<Self>

Flattens the input tensor by reshaping it into a one dimension tensor.

use numrst::NdArray;
let arr = NdArray::new(&[[0f32, 1.], [2., 3.], [4., 5.]]).unwrap();
let arr = arr.flatten_all().unwrap();
assert_eq!(arr.to_vec(), [0., 1., 2., 3., 4., 5.]);

pub fn repeat<S: Into<Shape>>(&self, shape: S) -> Result<Self>

Repeat this tensor along the specified dimensions.

pub fn repeat_dim<D: Dim>(&self, dim: D, times: usize) -> Result<Self>

Repeat this tensor along the specified dimension with specified times

impl<T: NumDType> NdArray<T>

pub fn add(&self, rhs: impl NdArrayBinaryOpRhs<T>) -> Result<Self>

Examples found in repository

examples/arithmetic.rs (line 7)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let a = NdArray::<f32>::ones((2, 2))?;
    let b = NdArray::<f32>::full((2, 2), 2.0)?;

    let c = a.add(&b)?;
    let d = b.sub(&a)?;
    let e = b.mul(&c)?;
    let f = e.div(&d)?;

    println!("a:\n{:?}", a);
    println!("b:\n{}", b);
    println!("a + b:\n{}", c);
    println!("b - a:\n{:?}", d);
    println!("b * (a + b):\n{}", e);
    println!("e / d:\n{}", f);

    Ok(())
}

pub fn mul(&self, rhs: impl NdArrayBinaryOpRhs<T>) -> Result<Self>

Examples found in repository

examples/arithmetic.rs (line 9)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let a = NdArray::<f32>::ones((2, 2))?;
    let b = NdArray::<f32>::full((2, 2), 2.0)?;

    let c = a.add(&b)?;
    let d = b.sub(&a)?;
    let e = b.mul(&c)?;
    let f = e.div(&d)?;

    println!("a:\n{:?}", a);
    println!("b:\n{}", b);
    println!("a + b:\n{}", c);
    println!("b - a:\n{:?}", d);
    println!("b * (a + b):\n{}", e);
    println!("e / d:\n{}", f);

    Ok(())
}

pub fn sub(&self, rhs: impl NdArrayBinaryOpRhs<T>) -> Result<Self>

Examples found in repository

examples/arithmetic.rs (line 8)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let a = NdArray::<f32>::ones((2, 2))?;
    let b = NdArray::<f32>::full((2, 2), 2.0)?;

    let c = a.add(&b)?;
    let d = b.sub(&a)?;
    let e = b.mul(&c)?;
    let f = e.div(&d)?;

    println!("a:\n{:?}", a);
    println!("b:\n{}", b);
    println!("a + b:\n{}", c);
    println!("b - a:\n{:?}", d);
    println!("b * (a + b):\n{}", e);
    println!("e / d:\n{}", f);

    Ok(())
}

pub fn div(&self, rhs: impl NdArrayBinaryOpRhs<T>) -> Result<Self>

Examples found in repository

examples/arithmetic.rs (line 10)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let a = NdArray::<f32>::ones((2, 2))?;
    let b = NdArray::<f32>::full((2, 2), 2.0)?;

    let c = a.add(&b)?;
    let d = b.sub(&a)?;
    let e = b.mul(&c)?;
    let f = e.div(&d)?;

    println!("a:\n{:?}", a);
    println!("b:\n{}", b);
    println!("a + b:\n{}", c);
    println!("b - a:\n{:?}", d);
    println!("b * (a + b):\n{}", e);
    println!("e / d:\n{}", f);

    Ok(())
}

pub fn minimum(&self, rhs: impl NdArrayBinaryOpRhs<T>) -> Result<Self>

pub fn maximum(&self, rhs: impl NdArrayBinaryOpRhs<T>) -> Result<Self>

impl<T: NumDType> NdArray<T>

pub fn add_assign(&self, rhs: impl NdArrayBinaryOpRhs<T>) -> Result<()>

pub fn mul_assign(&self, rhs: impl NdArrayBinaryOpRhs<T>) -> Result<()>

pub fn sub_assign(&self, rhs: impl NdArrayBinaryOpRhs<T>) -> Result<()>

pub fn div_assign(&self, rhs: impl NdArrayBinaryOpRhs<T>) -> Result<()>

pub fn minimum_assign(&self, rhs: impl NdArrayBinaryOpRhs<T>) -> Result<()>

pub fn maximum_assign(&self, rhs: impl NdArrayBinaryOpRhs<T>) -> Result<()>

impl<T: NumDType> NdArray<T>

pub fn eq(&self, rhs: impl NdArrayBinaryOpRhs<T>) -> Result<NdArray<bool>>

Examples found in repository

examples/logic.rs (line 8)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // --- Comparison ops ---
    let a = NdArray::<i32>::arange(0, 9)?.reshape((3, 3))?;
    let b = NdArray::<i32>::full((3, 3), 4)?;

    let eq = a.eq(&b)?;
    let ne = a.ne(&b)?;
    let lt = a.lt(&b)?;
    let ge = a.ge(&b)?;

    println!("a:\n{}", a);
    println!("b:\n{}", b);
    println!("a == b:\n{}", eq);
    println!("a != b:\n{}", ne);
    println!("a < b:\n{}", lt);
    println!("a >= b:\n{}", ge);

    // --- Boolean logic ops ---
    let x = NdArray::<bool>::trues((2, 2))?;
    let y = NdArray::<bool>::falses((2, 2))?;

    let and = x.and(&y)?;
    let or = x.or(&y)?;
    let xor = x.xor(&y)?;

    println!("\nx:\n{}", x);
    println!("y:\n{}", y);
    println!("x AND y:\n{}", and);
    println!("x OR y:\n{}", or);
    println!("x XOR y:\n{}", xor);

    // --- Using select (if-else like) ---
    let cond = a.lt(&b)?;
    let chosen = NdArray::<i32>::select(&cond, &a, &b)?;

    println!("\nCondition (a < b):\n{}", cond);
    println!("Select result (if a<b then a else b):\n{}", chosen);

    Ok(())
}

pub fn ne(&self, rhs: impl NdArrayBinaryOpRhs<T>) -> Result<NdArray<bool>>

Examples found in repository

examples/logic.rs (line 9)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // --- Comparison ops ---
    let a = NdArray::<i32>::arange(0, 9)?.reshape((3, 3))?;
    let b = NdArray::<i32>::full((3, 3), 4)?;

    let eq = a.eq(&b)?;
    let ne = a.ne(&b)?;
    let lt = a.lt(&b)?;
    let ge = a.ge(&b)?;

    println!("a:\n{}", a);
    println!("b:\n{}", b);
    println!("a == b:\n{}", eq);
    println!("a != b:\n{}", ne);
    println!("a < b:\n{}", lt);
    println!("a >= b:\n{}", ge);

    // --- Boolean logic ops ---
    let x = NdArray::<bool>::trues((2, 2))?;
    let y = NdArray::<bool>::falses((2, 2))?;

    let and = x.and(&y)?;
    let or = x.or(&y)?;
    let xor = x.xor(&y)?;

    println!("\nx:\n{}", x);
    println!("y:\n{}", y);
    println!("x AND y:\n{}", and);
    println!("x OR y:\n{}", or);
    println!("x XOR y:\n{}", xor);

    // --- Using select (if-else like) ---
    let cond = a.lt(&b)?;
    let chosen = NdArray::<i32>::select(&cond, &a, &b)?;

    println!("\nCondition (a < b):\n{}", cond);
    println!("Select result (if a<b then a else b):\n{}", chosen);

    Ok(())
}

pub fn le(&self, rhs: impl NdArrayBinaryOpRhs<T>) -> Result<NdArray<bool>>

pub fn ge(&self, rhs: impl NdArrayBinaryOpRhs<T>) -> Result<NdArray<bool>>

Examples found in repository

examples/logic.rs (line 11)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // --- Comparison ops ---
    let a = NdArray::<i32>::arange(0, 9)?.reshape((3, 3))?;
    let b = NdArray::<i32>::full((3, 3), 4)?;

    let eq = a.eq(&b)?;
    let ne = a.ne(&b)?;
    let lt = a.lt(&b)?;
    let ge = a.ge(&b)?;

    println!("a:\n{}", a);
    println!("b:\n{}", b);
    println!("a == b:\n{}", eq);
    println!("a != b:\n{}", ne);
    println!("a < b:\n{}", lt);
    println!("a >= b:\n{}", ge);

    // --- Boolean logic ops ---
    let x = NdArray::<bool>::trues((2, 2))?;
    let y = NdArray::<bool>::falses((2, 2))?;

    let and = x.and(&y)?;
    let or = x.or(&y)?;
    let xor = x.xor(&y)?;

    println!("\nx:\n{}", x);
    println!("y:\n{}", y);
    println!("x AND y:\n{}", and);
    println!("x OR y:\n{}", or);
    println!("x XOR y:\n{}", xor);

    // --- Using select (if-else like) ---
    let cond = a.lt(&b)?;
    let chosen = NdArray::<i32>::select(&cond, &a, &b)?;

    println!("\nCondition (a < b):\n{}", cond);
    println!("Select result (if a<b then a else b):\n{}", chosen);

    Ok(())
}

pub fn lt(&self, rhs: impl NdArrayBinaryOpRhs<T>) -> Result<NdArray<bool>>

Examples found in repository

examples/logic.rs (line 10)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // --- Comparison ops ---
    let a = NdArray::<i32>::arange(0, 9)?.reshape((3, 3))?;
    let b = NdArray::<i32>::full((3, 3), 4)?;

    let eq = a.eq(&b)?;
    let ne = a.ne(&b)?;
    let lt = a.lt(&b)?;
    let ge = a.ge(&b)?;

    println!("a:\n{}", a);
    println!("b:\n{}", b);
    println!("a == b:\n{}", eq);
    println!("a != b:\n{}", ne);
    println!("a < b:\n{}", lt);
    println!("a >= b:\n{}", ge);

    // --- Boolean logic ops ---
    let x = NdArray::<bool>::trues((2, 2))?;
    let y = NdArray::<bool>::falses((2, 2))?;

    let and = x.and(&y)?;
    let or = x.or(&y)?;
    let xor = x.xor(&y)?;

    println!("\nx:\n{}", x);
    println!("y:\n{}", y);
    println!("x AND y:\n{}", and);
    println!("x OR y:\n{}", or);
    println!("x XOR y:\n{}", xor);

    // --- Using select (if-else like) ---
    let cond = a.lt(&b)?;
    let chosen = NdArray::<i32>::select(&cond, &a, &b)?;

    println!("\nCondition (a < b):\n{}", cond);
    println!("Select result (if a<b then a else b):\n{}", chosen);

    Ok(())
}

pub fn gt(&self, rhs: impl NdArrayBinaryOpRhs<T>) -> Result<NdArray<bool>>

pub fn cmp( &self, rhs: impl NdArrayBinaryOpRhs<T>, op: CmpOp, ) -> Result<NdArray<bool>>

impl NdArray<bool>

pub fn and(&self, rhs: impl NdArrayBinaryOpRhs<bool>) -> Result<NdArray<bool>>

Examples found in repository

examples/logic.rs (line 24)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // --- Comparison ops ---
    let a = NdArray::<i32>::arange(0, 9)?.reshape((3, 3))?;
    let b = NdArray::<i32>::full((3, 3), 4)?;

    let eq = a.eq(&b)?;
    let ne = a.ne(&b)?;
    let lt = a.lt(&b)?;
    let ge = a.ge(&b)?;

    println!("a:\n{}", a);
    println!("b:\n{}", b);
    println!("a == b:\n{}", eq);
    println!("a != b:\n{}", ne);
    println!("a < b:\n{}", lt);
    println!("a >= b:\n{}", ge);

    // --- Boolean logic ops ---
    let x = NdArray::<bool>::trues((2, 2))?;
    let y = NdArray::<bool>::falses((2, 2))?;

    let and = x.and(&y)?;
    let or = x.or(&y)?;
    let xor = x.xor(&y)?;

    println!("\nx:\n{}", x);
    println!("y:\n{}", y);
    println!("x AND y:\n{}", and);
    println!("x OR y:\n{}", or);
    println!("x XOR y:\n{}", xor);

    // --- Using select (if-else like) ---
    let cond = a.lt(&b)?;
    let chosen = NdArray::<i32>::select(&cond, &a, &b)?;

    println!("\nCondition (a < b):\n{}", cond);
    println!("Select result (if a<b then a else b):\n{}", chosen);

    Ok(())
}

pub fn or(&self, rhs: impl NdArrayBinaryOpRhs<bool>) -> Result<NdArray<bool>>

Examples found in repository

examples/logic.rs (line 25)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // --- Comparison ops ---
    let a = NdArray::<i32>::arange(0, 9)?.reshape((3, 3))?;
    let b = NdArray::<i32>::full((3, 3), 4)?;

    let eq = a.eq(&b)?;
    let ne = a.ne(&b)?;
    let lt = a.lt(&b)?;
    let ge = a.ge(&b)?;

    println!("a:\n{}", a);
    println!("b:\n{}", b);
    println!("a == b:\n{}", eq);
    println!("a != b:\n{}", ne);
    println!("a < b:\n{}", lt);
    println!("a >= b:\n{}", ge);

    // --- Boolean logic ops ---
    let x = NdArray::<bool>::trues((2, 2))?;
    let y = NdArray::<bool>::falses((2, 2))?;

    let and = x.and(&y)?;
    let or = x.or(&y)?;
    let xor = x.xor(&y)?;

    println!("\nx:\n{}", x);
    println!("y:\n{}", y);
    println!("x AND y:\n{}", and);
    println!("x OR y:\n{}", or);
    println!("x XOR y:\n{}", xor);

    // --- Using select (if-else like) ---
    let cond = a.lt(&b)?;
    let chosen = NdArray::<i32>::select(&cond, &a, &b)?;

    println!("\nCondition (a < b):\n{}", cond);
    println!("Select result (if a<b then a else b):\n{}", chosen);

    Ok(())
}

pub fn xor(&self, rhs: impl NdArrayBinaryOpRhs<bool>) -> Result<NdArray<bool>>

Examples found in repository

examples/logic.rs (line 26)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // --- Comparison ops ---
    let a = NdArray::<i32>::arange(0, 9)?.reshape((3, 3))?;
    let b = NdArray::<i32>::full((3, 3), 4)?;

    let eq = a.eq(&b)?;
    let ne = a.ne(&b)?;
    let lt = a.lt(&b)?;
    let ge = a.ge(&b)?;

    println!("a:\n{}", a);
    println!("b:\n{}", b);
    println!("a == b:\n{}", eq);
    println!("a != b:\n{}", ne);
    println!("a < b:\n{}", lt);
    println!("a >= b:\n{}", ge);

    // --- Boolean logic ops ---
    let x = NdArray::<bool>::trues((2, 2))?;
    let y = NdArray::<bool>::falses((2, 2))?;

    let and = x.and(&y)?;
    let or = x.or(&y)?;
    let xor = x.xor(&y)?;

    println!("\nx:\n{}", x);
    println!("y:\n{}", y);
    println!("x AND y:\n{}", and);
    println!("x OR y:\n{}", or);
    println!("x XOR y:\n{}", xor);

    // --- Using select (if-else like) ---
    let cond = a.lt(&b)?;
    let chosen = NdArray::<i32>::select(&cond, &a, &b)?;

    println!("\nCondition (a < b):\n{}", cond);
    println!("Select result (if a<b then a else b):\n{}", chosen);

    Ok(())
}

pub fn not(&self) -> NdArray<bool>

impl<T: NumDType> NdArray<T>

pub fn affine(&self, mul: T, add: T) -> Result<Self>

pub fn affine_assign(&self, mul: T, add: T) -> Result<()>

impl<F: FloatDType> NdArray<F>

pub fn exp(&self) -> Self

pub fn sin(&self) -> Self

pub fn cos(&self) -> Self

pub fn tanh(&self) -> Self

pub fn sqrt(&self) -> Self

pub fn floor(&self) -> Self

pub fn ceil(&self) -> Self

pub fn round(&self) -> Self

pub fn abs(&self) -> Self

pub fn neg(&self) -> Self

pub fn ln(&self) -> Self

pub fn recip(&self) -> Self

pub fn exp_assign(&self)

pub fn sin_assign(&self)

pub fn cos_assign(&self)

pub fn sqrt_assign(&self)

pub fn tanh_assign(&self)

pub fn floor_assign(&self)

pub fn ceil_assign(&self)

pub fn round_assign(&self)

pub fn abs_assign(&self)

pub fn neg_assign(&self)

pub fn ln_assign(&self)

pub fn recip_assign(&self)

impl<T: NumDType> NdArray<T>

pub fn matmul(&self, rhs: &Self) -> Result<Self>

Returns the matrix-multiplication of the input tensor with the other provided tensor.

Arguments

• self - A tensor with dimensions b1, b2, ..., bi, m, k.
• rhs - A tensor with dimensions b1, b2, ..., bi, k, n.

The resulting tensor has dimensions b1, b2, ..., bi, m, n.

Examples found in repository

examples/matmul.rs (line 6)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let m1 = NdArray::<f32>::rand(0.0, 1.0, (2, 3))?;
    let m2 = NdArray::<f32>::rand(0.0, 1.0, (3, 4))?;
    let m3 = m1.matmul(&m2)?;

    println!("m1:\n{}", m1);
    println!("m2:\n{}", m2);
    println!("m1 @ m2:\n{}", m3);

    Ok(())
}

impl<T: NumDType> NdArray<T>

pub fn sum_axis<'a, D: Dim>( &'a self, axis: D, ) -> Result<NdArray<<ReduceSum as ReduceOp<T, DimArrayIter<'a, T>>>::Output>>

pub fn product_axis<'a, D: Dim>( &'a self, axis: D, ) -> Result<NdArray<<ReduceProduct as ReduceOp<T, DimArrayIter<'a, T>>>::Output>>

pub fn min_axis<'a, D: Dim>( &'a self, axis: D, ) -> Result<NdArray<<ReduceMin as ReduceOp<T, DimArrayIter<'a, T>>>::Output>>

pub fn argmin_axis<'a, D: Dim>( &'a self, axis: D, ) -> Result<NdArray<<ReduceArgMin as ReduceOp<T, DimArrayIter<'a, T>>>::Output>>

pub fn max_axis<'a, D: Dim>( &'a self, axis: D, ) -> Result<NdArray<<ReduceMax as ReduceOp<T, DimArrayIter<'a, T>>>::Output>>

pub fn argmax_axis<'a, D: Dim>( &'a self, axis: D, ) -> Result<NdArray<<ReduceArgMax as ReduceOp<T, DimArrayIter<'a, T>>>::Output>>

pub fn mean_axis<'a, D: Dim>( &'a self, axis: D, ) -> Result<NdArray<<ReduceMean as ReduceOp<T, DimArrayIter<'a, T>>>::Output>>

where ReduceMean: ReduceOpByCategory<T, DimArrayIter<'a, T>>,

pub fn var_axis<'a, D: Dim>( &'a self, axis: D, ) -> Result<NdArray<<ReduceVar as ReduceOp<T, DimArrayIter<'a, T>>>::Output>>

where ReduceVar: ReduceOpByCategory<T, DimArrayIter<'a, T>>,

pub fn std_axis<'a, D: Dim>( &'a self, axis: D, ) -> Result<NdArray<<ReduceStd as ReduceOp<T, DimArrayIter<'a, T>>>::Output>>

where ReduceStd: ReduceOpByCategory<T, DimArrayIter<'a, T>>,

impl<T: NumDType> NdArray<T>

pub fn sum(&self) -> T

Examples found in repository

examples/reductions.rs (line 6)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let arr = NdArray::<f32>::arange(1.0, 10.0)?.reshape((3, 3))?;

    let sum = arr.sum();
    let prod = arr.product();
    let min = arr.min();
    let max = arr.max();
    let mean = arr.mean();
    let var = arr.var();
    let std = arr.std();

    println!("arr:\n{}", arr);
    println!("sum = {}", sum);
    println!("product = {}", prod);
    println!("min = {}", min);
    println!("max = {}", max);
    println!("mean = {:?}", mean);
    println!("var = {:?}", var);
    println!("std = {:?}", std);

    Ok(())
}

pub fn product(&self) -> T

Examples found in repository

examples/reductions.rs (line 7)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let arr = NdArray::<f32>::arange(1.0, 10.0)?.reshape((3, 3))?;

    let sum = arr.sum();
    let prod = arr.product();
    let min = arr.min();
    let max = arr.max();
    let mean = arr.mean();
    let var = arr.var();
    let std = arr.std();

    println!("arr:\n{}", arr);
    println!("sum = {}", sum);
    println!("product = {}", prod);
    println!("min = {}", min);
    println!("max = {}", max);
    println!("mean = {:?}", mean);
    println!("var = {:?}", var);
    println!("std = {:?}", std);

    Ok(())
}

pub fn min(&self) -> T

Examples found in repository

examples/reductions.rs (line 8)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let arr = NdArray::<f32>::arange(1.0, 10.0)?.reshape((3, 3))?;

    let sum = arr.sum();
    let prod = arr.product();
    let min = arr.min();
    let max = arr.max();
    let mean = arr.mean();
    let var = arr.var();
    let std = arr.std();

    println!("arr:\n{}", arr);
    println!("sum = {}", sum);
    println!("product = {}", prod);
    println!("min = {}", min);
    println!("max = {}", max);
    println!("mean = {:?}", mean);
    println!("var = {:?}", var);
    println!("std = {:?}", std);

    Ok(())
}

pub fn max(&self) -> T

Examples found in repository

examples/reductions.rs (line 9)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let arr = NdArray::<f32>::arange(1.0, 10.0)?.reshape((3, 3))?;

    let sum = arr.sum();
    let prod = arr.product();
    let min = arr.min();
    let max = arr.max();
    let mean = arr.mean();
    let var = arr.var();
    let std = arr.std();

    println!("arr:\n{}", arr);
    println!("sum = {}", sum);
    println!("product = {}", prod);
    println!("min = {}", min);
    println!("max = {}", max);
    println!("mean = {:?}", mean);
    println!("var = {:?}", var);
    println!("std = {:?}", std);

    Ok(())
}

pub fn mean<'a>( &'a self, ) -> <ReduceMean as ReduceOp<T, NdArrayIter<'a, T>>>::Output

where ReduceMean: ReduceOpByCategory<T, NdArrayIter<'a, T>>,

Examples found in repository

examples/reductions.rs (line 10)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let arr = NdArray::<f32>::arange(1.0, 10.0)?.reshape((3, 3))?;

    let sum = arr.sum();
    let prod = arr.product();
    let min = arr.min();
    let max = arr.max();
    let mean = arr.mean();
    let var = arr.var();
    let std = arr.std();

    println!("arr:\n{}", arr);
    println!("sum = {}", sum);
    println!("product = {}", prod);
    println!("min = {}", min);
    println!("max = {}", max);
    println!("mean = {:?}", mean);
    println!("var = {:?}", var);
    println!("std = {:?}", std);

    Ok(())
}

pub fn var<'a>( &'a self, ) -> <ReduceVar as ReduceOp<T, NdArrayIter<'a, T>>>::Output

where ReduceVar: ReduceOpByCategory<T, NdArrayIter<'a, T>>,

Examples found in repository

examples/reductions.rs (line 11)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let arr = NdArray::<f32>::arange(1.0, 10.0)?.reshape((3, 3))?;

    let sum = arr.sum();
    let prod = arr.product();
    let min = arr.min();
    let max = arr.max();
    let mean = arr.mean();
    let var = arr.var();
    let std = arr.std();

    println!("arr:\n{}", arr);
    println!("sum = {}", sum);
    println!("product = {}", prod);
    println!("min = {}", min);
    println!("max = {}", max);
    println!("mean = {:?}", mean);
    println!("var = {:?}", var);
    println!("std = {:?}", std);

    Ok(())
}

pub fn std<'a>( &'a self, ) -> <ReduceStd as ReduceOp<T, NdArrayIter<'a, T>>>::Output

where ReduceStd: ReduceOpByCategory<T, NdArrayIter<'a, T>>,

Examples found in repository

examples/reductions.rs (line 12)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let arr = NdArray::<f32>::arange(1.0, 10.0)?.reshape((3, 3))?;

    let sum = arr.sum();
    let prod = arr.product();
    let min = arr.min();
    let max = arr.max();
    let mean = arr.mean();
    let var = arr.var();
    let std = arr.std();

    println!("arr:\n{}", arr);
    println!("sum = {}", sum);
    println!("product = {}", prod);
    println!("min = {}", min);
    println!("max = {}", max);
    println!("mean = {:?}", mean);
    println!("var = {:?}", var);
    println!("std = {:?}", std);

    Ok(())
}

impl NdArray<bool>

pub fn all(&self) -> bool

pub fn any(&self) -> bool

pub fn all_axis<D: Dim>(&self, axis: D) -> Result<NdArray<bool>>

pub fn any_axis<D: Dim>(&self, axis: D) -> Result<NdArray<bool>>

impl<T: WithDType> NdArray<T>

pub fn broadcast_as<S: Into<Shape>>(&self, shape: S) -> Result<Self>

Broadcast the input tensor to the target shape. This returns an error if the input shape is not compatible with the target shape.

If the input shape is i_1, i_2, ... i_k, the target shape has to have k dimensions or more and shape j_1, ..., j_l, t_1, t_2, ..., t_k. The dimensions j_1 to j_l can have any value, the dimension t_a must be equal to i_a if i_a is different from 1. If i_a is equal to 1, any value can be used.

impl<T: NumDType> NdArray<T>

pub fn broadcast_add(&self, rhs: &Self) -> Result<Self>

Examples found in repository

examples/broadcasting.rs (line 7)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let a = NdArray::<f32>::ones((3, 3))?;
    let b = NdArray::<f32>::arange(0.0, 3.0)?.reshape((3, 1))?;

    let c = a.broadcast_add(&b)?; // broadcasting
    println!("a:\n{}", a);
    println!("b:\n{}", b);
    println!("a + b (broadcast):\n{}", c);

    Ok(())
}

pub fn broadcast_mul(&self, rhs: &Self) -> Result<Self>

pub fn broadcast_sub(&self, rhs: &Self) -> Result<Self>

pub fn broadcast_div(&self, rhs: &Self) -> Result<Self>

pub fn broadcast_maximum(&self, rhs: &Self) -> Result<Self>

pub fn broadcast_minimum(&self, rhs: &Self) -> Result<Self>

pub fn broadcast_eq(&self, rhs: &Self) -> Result<NdArray<bool>>

pub fn broadcast_ne(&self, rhs: &Self) -> Result<NdArray<bool>>

pub fn broadcast_lt(&self, rhs: &Self) -> Result<NdArray<bool>>

pub fn broadcast_le(&self, rhs: &Self) -> Result<NdArray<bool>>

pub fn broadcast_gt(&self, rhs: &Self) -> Result<NdArray<bool>>

pub fn broadcast_ge(&self, rhs: &Self) -> Result<NdArray<bool>>

impl<T: WithDType> NdArray<T>

pub fn copy(&self) -> Self

pub fn copy_from(&self, source: &Self) -> Result<()>

pub fn assign<A: AssignToNdArray<T>>(&self, source: A) -> Result<()>

impl<From: WithDType> NdArray<From>

pub fn to_dtype<To: WithDType>(&self) -> NdArray<To>

where From: DTypeConvert<To>,

impl<T: WithDType> NdArray<T>

pub fn filter(&self, conditions: &NdArray<bool>) -> Result<NdArray<T>>

pub fn select<TV, FV>( mask: &NdArray<bool>, true_val: TV, false_val: FV, ) -> Result<Self>

where TV: ConditionValue<T>, FV: ConditionValue<T>,

Examples found in repository

examples/logic.rs (line 36)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // --- Comparison ops ---
    let a = NdArray::<i32>::arange(0, 9)?.reshape((3, 3))?;
    let b = NdArray::<i32>::full((3, 3), 4)?;

    let eq = a.eq(&b)?;
    let ne = a.ne(&b)?;
    let lt = a.lt(&b)?;
    let ge = a.ge(&b)?;

    println!("a:\n{}", a);
    println!("b:\n{}", b);
    println!("a == b:\n{}", eq);
    println!("a != b:\n{}", ne);
    println!("a < b:\n{}", lt);
    println!("a >= b:\n{}", ge);

    // --- Boolean logic ops ---
    let x = NdArray::<bool>::trues((2, 2))?;
    let y = NdArray::<bool>::falses((2, 2))?;

    let and = x.and(&y)?;
    let or = x.or(&y)?;
    let xor = x.xor(&y)?;

    println!("\nx:\n{}", x);
    println!("y:\n{}", y);
    println!("x AND y:\n{}", and);
    println!("x OR y:\n{}", or);
    println!("x XOR y:\n{}", xor);

    // --- Using select (if-else like) ---
    let cond = a.lt(&b)?;
    let chosen = NdArray::<i32>::select(&cond, &a, &b)?;

    println!("\nCondition (a < b):\n{}", cond);
    println!("Select result (if a<b then a else b):\n{}", chosen);

    Ok(())
}

impl<T: WithDType> NdArray<T>

pub fn is_scalar(&self) -> bool

pub fn check_scalar(&self) -> Result<()>

pub fn to_scalar(&self) -> Result<T>

pub fn set_scalar(&self, val: T) -> Result<()>

pub fn storage_ref<'a>(&'a self, start_offset: usize) -> StorageRef<'a, T>

pub fn storage_mut<'a>(&'a self, start_offset: usize) -> StorageMut<'a, T>

pub fn storage_ptr(&self, start_offset: usize) -> *mut T

impl<T: WithDType> NdArray<T>

pub fn id(&self) -> usize

pub fn shape(&self) -> &Shape

Examples found in repository

examples/shape.rs (line 22)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // --- Reshape ---
    let a = NdArray::<i32>::arange(0, 12)?;
    let a2d = a.reshape((3, 4))?;
    let a3d = a.reshape((2, 2, 3))?;

    println!("Original a (1D):\n{}", a);
    println!("Reshaped a (3x4):\n{}", a2d);
    println!("Reshaped a (2x2x3):\n{}", a3d);

    // --- Transpose ---
    let t = a2d.transpose(0, 1)?;
    println!("Transpose a2d (swap dim 0 <-> 1):\n{}", t);

    // --- Unsqueeze & Squeeze ---
    let b = NdArray::<f32>::arange(0.0, 6.0)?.reshape((2, 3))?;
    let b_unsq = b.unsqueeze(0)?; // add axis at front -> (1,2,3)
    let b_sq = b_unsq.squeeze(0)?; // remove axis -> (2,3)

    println!("b shape: {}", b.shape());
    println!("b_unsq shape: {}", b_unsq.shape());
    println!("b_sq shape: {}", b_sq.shape());

    // --- Narrow & Narrow Range ---
    let narrowed = b.narrow(1, 0, 2)?; // take first 2 cols along axis 1
    let narrowed_range = b.narrow_range(1, &rng!(0:2))?;

    println!("narrowed (axis=1, first 2 cols):\n{}", narrowed);
    println!("narrowed_range (axis=1, 0..2):\n{}", narrowed_range);

    // --- Concatenate ---
    let c1 = NdArray::<i32>::full((2, 2), 1)?;
    let c2 = NdArray::<i32>::full((2, 2), 2)?;
    let cat = NdArray::cat(&[&c1, &c2], 0)?; // concat along axis=0

    println!("Concatenate along axis=0:\n{}", cat);

    // --- Stack ---
    let s1 = NdArray::<i32>::full((2, 2), 3)?;
    let s2 = NdArray::<i32>::full((2, 2), 4)?;
    let stacked = NdArray::stack(&[&s1, &s2], 0)?; // stack new axis

    println!("Stacked along new axis=0:\n{}", stacked);

    Ok(())
}

pub fn dtype(&self) -> DType

pub fn layout(&self) -> &Layout

pub fn dims(&self) -> &[usize]

pub fn dim<D: Dim>(&self, dim: D) -> Result<usize>

pub fn storage(&self) -> RwLockReadGuard<'_, Storage<T>>

pub fn element_count(&self) -> usize

pub fn is_contiguous(&self) -> bool

pub fn rank(&self) -> usize

pub fn to_vec(&self) -> Vec<T>

pub fn storage_indices(&self) -> StorageIndices<'_>

Returns an iterator over storage indices.

This iterator yields the linear (flat) indices as they are laid out in the underlying storage buffer. The order depends on the memory layout (e.g., row-major / column-major / with strides).

Example for shape = (2, 2) in row-major layout: yields: 0, 1, 2, 3

pub fn dim_coordinates(&self) -> DimCoordinates

Returns an iterator over dimension coordinates.

This iterator yields the multi-dimensional coordinates (e.g., [i, j, k, ...]) of each element in the array, independent of the physical storage layout.

Example for shape = (2, 2): yields: [0, 0], [0, 1], [1, 0], [1, 1]

pub fn dims_coordinates<const N: usize>(&self) -> Result<DimNCoordinates<N>>

pub fn dim2_coordinates(&self) -> Result<DimNCoordinates<2>>

pub fn dim3_coordinates(&self) -> Result<DimNCoordinates<3>>

pub fn dim4_coordinates(&self) -> Result<DimNCoordinates<4>>

pub fn dim5_coordinates(&self) -> Result<DimNCoordinates<5>>

impl<T: WithDType> NdArray<T>

pub fn matrix_view_unsafe(&self) -> Result<MatrixViewUsf<'_, T>>

pub fn vector_view_unsafe(&self) -> Result<VectorViewUsf<'_, T>>

pub fn matrix_view<'a>(&'a self) -> Result<MatrixView<'a, T>>

pub fn matrix_view_mut<'a>(&'a mut self) -> Result<MatrixViewMut<'a, T>>

Examples found in repository

examples/view.rs (line 9)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let total = NdArray::<f32>::zeros((5, 5)).unwrap();

    {
        let mut sub = total.index((1..3, 2..4)).unwrap();
        let source = sub.randn_like(0.0, 1.0).unwrap();
        let mut sub_view = sub.matrix_view_mut().unwrap();

        sub_view.copy_from(&source).unwrap();
    }
    
    println!("{}", total);

    Ok(())
}

pub fn vector_view<'a>(&'a self) -> Result<VectorView<'a, T>>

pub fn vector_view_mut<'a>(&'a mut self) -> Result<VectorViewMut<'a, T>>

impl<T: NumDType> NdArray<T>

pub fn allclose(&self, other: &Self, rtol: f64, atol: f64) -> bool

impl<D: WithDType + NoUninit> NdArray<D>

pub fn save_npy_writer<W: Write>(&self, writer: &mut W) -> Result<()>

pub fn save_npy_file<P: AsRef<Path>>(&self, path: P) -> Result<()>

impl<T: WithDType + NoUninit> NdArray<T>

pub fn save_file<P: AsRef<Path>>(&self, path: P) -> Result<()>

pub fn save_writer<W: Write>(&self, writer: &mut W) -> Result<()>

Trait Implementations

impl<T: NumDType, R: NdArrayBinaryOpRhs<T>> Add<R> for &NdArray<T>

type Output = Result<NdArray<T>, Error>

The resulting type after applying the + operator.

fn add(self, rhs: R) -> Self::Output

Performs the + operation.

impl<T: NumDType, R: NdArrayBinaryOpRhs<T>> Add<R> for NdArray<T>

type Output = Result<NdArray<T>, Error>

The resulting type after applying the + operator.

fn add(self, rhs: R) -> Self::Output

Performs the + operation.

impl<T: WithDType> AsRef<NdArray<T>> for NdArray<T>

fn as_ref(&self) -> &NdArray<T>

Converts this type into a shared reference of the (usually inferred) input type.

impl<D: Clone> Clone for NdArray<D>

fn clone(&self) -> NdArray<D>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: WithDType> Debug for NdArray<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: WithDType> Display for NdArray<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: NumDType, R: NdArrayBinaryOpRhs<T>> Div<R> for &NdArray<T>

type Output = Result<NdArray<T>, Error>

The resulting type after applying the / operator.

fn div(self, rhs: R) -> Self::Output

Performs the / operation.

impl<T: NumDType, R: NdArrayBinaryOpRhs<T>> Div<R> for NdArray<T>

type Output = Result<NdArray<T>, Error>

The resulting type after applying the / operator.

fn div(self, rhs: R) -> Self::Output

Performs the / operation.

impl<I: Into<Indexer>, D: WithDType> IndexOp<(I,), D> for NdArray<D>

fn index(&self, (index): (I,)) -> Result<NdArray<D>>

impl<I1, I2, D: WithDType> IndexOp<(I1, I2), D> for NdArray<D>

where I1: Into<Indexer>, I2: Into<Indexer>,

fn index(&self, (I1, I2): (I1, I2)) -> Result<NdArray<D>>

impl<I1, I2, I3, D: WithDType> IndexOp<(I1, I2, I3), D> for NdArray<D>

where I1: Into<Indexer>, I2: Into<Indexer>, I3: Into<Indexer>,

fn index(&self, (I1, I2, I3): (I1, I2, I3)) -> Result<NdArray<D>>

impl<I1, I2, I3, I4, D: WithDType> IndexOp<(I1, I2, I3, I4), D> for NdArray<D>

where I1: Into<Indexer>, I2: Into<Indexer>, I3: Into<Indexer>, I4: Into<Indexer>,

fn index(&self, (I1, I2, I3, I4): (I1, I2, I3, I4)) -> Result<NdArray<D>>

impl<I1, I2, I3, I4, I5, D: WithDType> IndexOp<(I1, I2, I3, I4, I5), D> for NdArray<D>

where I1: Into<Indexer>, I2: Into<Indexer>, I3: Into<Indexer>, I4: Into<Indexer>, I5: Into<Indexer>,

fn index( &self, (I1, I2, I3, I4, I5): (I1, I2, I3, I4, I5), ) -> Result<NdArray<D>>

impl<I: Into<Indexer>, D: WithDType> IndexOp<I, D> for NdArray<D>

fn index(&self, index: I) -> Result<NdArray<D>>

impl<T: NumDType, R: NdArrayBinaryOpRhs<T>> Mul<R> for &NdArray<T>

type Output = Result<NdArray<T>, Error>

The resulting type after applying the * operator.

fn mul(self, rhs: R) -> Self::Output

Performs the * operation.

impl<T: NumDType, R: NdArrayBinaryOpRhs<T>> Mul<R> for NdArray<T>

type Output = Result<NdArray<T>, Error>

The resulting type after applying the * operator.

fn mul(self, rhs: R) -> Self::Output

Performs the * operation.

impl<T: NumDType, R: NdArrayBinaryOpRhs<T>> Sub<R> for &NdArray<T>

type Output = Result<NdArray<T>, Error>

The resulting type after applying the - operator.

fn sub(self, rhs: R) -> Self::Output

Performs the - operation.

impl<T: NumDType, R: NdArrayBinaryOpRhs<T>> Sub<R> for NdArray<T>

type Output = Result<NdArray<T>, Error>

The resulting type after applying the - operator.

fn sub(self, rhs: R) -> Self::Output

Performs the - operation.