Struct NDArray 

pub struct NDArray<T, const N: usize> { /* private fields */ }

A simple N-dimensional array type with shape, strides, and contiguous data storage.

Example

use timsrust_utils::ndarray::NDArray;
let arr = NDArray::new([2, 3], vec![1, 2, 3, 4, 5, 6]).unwrap();
assert_eq!(arr[[1, 2]], 6);

Implementations

impl<T, const N: usize> NDArray<T, N>

pub fn new(shape: [usize; N], data: Vec<T>) -> Result<Self, NDArrayError>

Creates a new NDArray with the given shape and data.

Arguments

• shape - The shape of the array as an array of dimension sizes.
• data - The data to fill the array, must match the product of shape dimensions.

Errors

Returns TimsUtilsError if the shape and data length are incompatible.

Example

use timsrust_utils::ndarray::NDArray;
let arr = NDArray::new([2, 2], vec![1, 2, 3, 4]).unwrap();
assert_eq!(arr.shape(), [2, 2]);
assert_eq!(arr[[1, 1]], 4);

pub fn shape(&self) -> [usize; N]

Returns the shape of the array.

Example

use timsrust_utils::ndarray::NDArray;
let arr = NDArray::new([2, 3], vec![1, 2, 3, 4, 5, 6]).unwrap();
assert_eq!(arr.shape(), [2, 3]);

pub fn index(&self, indices: [usize; N]) -> usize

Computes the flat index in the data vector for the given N-dimensional indices.

Arguments

• indices - The N-dimensional indices.

Example

use timsrust_utils::ndarray::NDArray;
let arr = NDArray::new([2, 2], vec![1, 2, 3, 4]).unwrap();
let idx = arr.index([1, 1]);
assert_eq!(idx, 3);

pub fn inverted_index(&self, idx: usize) -> [usize; N]

Converts a flat index into N-dimensional indices.

Arguments

• idx - The flat index.

Example

use timsrust_utils::ndarray::NDArray;
let arr = NDArray::new([2, 2], vec![1, 2, 3, 4]).unwrap();
let indices = arr.inverted_index(3);
assert_eq!(indices, [1, 1]);

impl<T: Default + Copy + AddAssign, const N: usize> NDArray<T, N>

pub fn project_axis(&self, axis: usize) -> Vec<T>

Projects the array along the specified axis, summing over all other axes.

Arguments

• axis - The axis to project onto.

Returns

A vector of values, one for each index along the specified axis.

Panics

Panics if the axis is out of bounds.

Example

use timsrust_utils::ndarray::NDArray;
let arr = NDArray::new([2, 2], vec![1, 2, 3, 4]).unwrap();
let proj = arr.project_axis(0);
assert_eq!(proj, vec![1+2, 3+4]);

impl<T: Default, const N: usize> NDArray<T, N>

pub fn empty(shape: [usize; N]) -> Self

Creates an empty NDArray with the given shape, filled with default values.

Arguments

• shape - The shape of the array.

Example

use timsrust_utils::ndarray::NDArray;
let arr: NDArray<i32, 2> = NDArray::empty([2, 2]);
assert_eq!(arr.shape(), [2, 2]);
assert_eq!(arr[[1,1]], 0);

Trait Implementations

impl<T: AddAssign + Copy, const N: usize> AddAssign for NDArray<T, N>

fn add_assign(&mut self, other: Self)

Adds another NDArray to this one, elementwise.

Panics

Panics if the shapes do not match.

Example

use timsrust_utils::ndarray::NDArray;
let mut a = NDArray::new([2, 2], vec![1, 2, 3, 4]).unwrap();
let b = NDArray::new([2, 2], vec![10, 20, 30, 40]).unwrap();
a += b;
assert_eq!(a[[0, 0]], 11);
assert_eq!(a[[1, 1]], 44);

impl<T: Clone, const N: usize> Clone for NDArray<T, N>

fn clone(&self) -> NDArray<T, N>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug, const N: usize> Debug for NDArray<T, N>

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

Formats the value using the given formatter.

impl<T: Eq, const N: usize> Eq for NDArray<T, N>

impl<T: Hash, const N: usize> Hash for NDArray<T, N>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T, const N: usize> Index<[usize; N]> for NDArray<T, N>

fn index(&self, indices: [usize; N]) -> &Self::Output

Indexes the array using N-dimensional indices.

Example

use timsrust_utils::ndarray::NDArray;
let arr = NDArray::new([2, 2], vec![1, 2, 3, 4]).unwrap();
assert_eq!(arr[[1, 1]], 4);

type Output = T

The returned type after indexing.

impl<T, const N: usize> IndexMut<[usize; N]> for NDArray<T, N>

fn index_mut(&mut self, indices: [usize; N]) -> &mut Self::Output

Mutable indexing using N-dimensional indices.

Example

use timsrust_utils::ndarray::NDArray;
let mut arr = NDArray::new([2, 2], vec![1, 2, 3, 4]).unwrap();
arr[[0, 0]] = 10;
assert_eq!(arr[[0, 0]], 10);

impl<T: PartialEq, const N: usize> PartialEq for NDArray<T, N>

fn eq(&self, other: &NDArray<T, N>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T, const N: usize> StructuralPartialEq for NDArray<T, N>