Struct NDArray

pub struct NDArray<T> { /* private fields */ }

Structure representing an owned n-dimensional array. The underlying storage is in row-major order.

Implementations

impl<T: Clone> NDArray<T>

pub fn new(shape: &[usize], v: T) -> NDArray<T>

Allocate a new array of the specified shape with all elements initialized with the value v.

pub fn copy<R: NDData<T>>(data: &R) -> NDArray<T>

Allocate a new array which is a copy of data.

pub fn from_slice(shape: &[usize], data: &[T]) -> NDArray<T>

Allocate a new array from a row-major order contiguous array and a shape. The size of the shape (product of all its elements) must be equal to the array length.

pub fn cast<U>(data: &dyn NDData<U>) -> NDArray<T>

where T: Copy, U: Cast<T> + Copy,

Allocate a new array where each element has been casted from data.

pub fn reshape(&mut self, new_shape: &[usize])

Reshape this NDArray. The size of the new shape (product of all its elements) must be equal to the size of the current shape.

pub fn insert(&mut self, dim: usize, pos: usize, other: &dyn NDData<T>)

Insert another NDData of the same dimensionality in this NDArray. The insertion is made at the position pos in the dimension dim. The shape of NDData need to be the same as this NDArray in every dimension except for the insertion dimension.

pub fn extract(&self, start: &[usize], end: &[usize]) -> NDArray<T>

Extract a sub part of this NDArray as a new NDArray. start and end are two index of the same dimensionality ad this NDArray.

pub fn remove(&mut self, dim: usize, start: usize, end: usize)

Remove a part of this NDArray. The removal is made in dimension dim from the position start until end (not included). This can be seen as the opposite operation of insert.

pub fn split(&mut self, dim: usize, pos: usize) -> NDArray<T>

Split this NDArray at position pos of dimension dim. The lower indices are kept in dim while the upper indices are returned. This is in fact an extract operation followed by a remove operation.

Trait Implementations

impl<'a, 'b, T: Clone + Display + From<f32>, R: NDData<T> + Sized> Add<&'a R> for &'b NDArray<T>

where NDArray<T>: Blas<T>,

type Output = NDArray<T>

The resulting type after applying the + operator.

fn add(self, rhs: &'a R) -> NDArray<T>

Performs the + operation.

impl<'a, T: Clone + Display + From<f32>, R: NDData<T> + Sized> AddAssign<&'a R> for NDArray<T>

where NDArray<T>: Blas<T>,

fn add_assign(&mut self, rhs: &'a R)

Performs the += operation.

impl<'b, T> Index<&'b [usize]> for NDArray<T>

type Output = T

The returned type after indexing.

fn index<'c>(&'c self, idx: &'b [usize]) -> &'c T

Performs the indexing (container[index]) operation.

impl<'b, T> Index<&'b [usize; 1]> for NDArray<T>

type Output = T

The returned type after indexing.

fn index<'c>(&'c self, idx: &'b [usize; 1]) -> &'c T

Performs the indexing (container[index]) operation.

impl<'b, T> Index<&'b [usize; 2]> for NDArray<T>

type Output = T

The returned type after indexing.

fn index<'c>(&'c self, idx: &'b [usize; 2]) -> &'c T

Performs the indexing (container[index]) operation.

impl<'b, T> Index<&'b [usize; 3]> for NDArray<T>

type Output = T

The returned type after indexing.

fn index<'c>(&'c self, idx: &'b [usize; 3]) -> &'c T

Performs the indexing (container[index]) operation.

impl<'b, T: Clone + Display> IndexMut<&'b [usize]> for NDArray<T>

fn index_mut<'c>(&'c mut self, idx: &[usize]) -> &'c mut T

Performs the mutable indexing (container[index]) operation.

impl<'b, T: Clone + Display> IndexMut<&'b [usize; 1]> for NDArray<T>

fn index_mut<'c>(&'c mut self, idx: &[usize; 1]) -> &'c mut T

Performs the mutable indexing (container[index]) operation.

impl<'b, T: Clone + Display> IndexMut<&'b [usize; 2]> for NDArray<T>

fn index_mut<'c>(&'c mut self, idx: &[usize; 2]) -> &'c mut T

Performs the mutable indexing (container[index]) operation.

impl<'b, T: Clone + Display> IndexMut<&'b [usize; 3]> for NDArray<T>

fn index_mut<'c>(&'c mut self, idx: &[usize; 3]) -> &'c mut T

Performs the mutable indexing (container[index]) operation.

impl<'a, 'b, T: Clone + Display + From<f32>, R: NDData<T> + Sized> Mul<&'a R> for &'b NDArray<T>

where NDArray<T>: Blas<T>,

type Output = NDArray<T>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a R) -> NDArray<T>

Performs the * operation.

impl<'a, T: Clone + Display + From<f32>, I: NDData<T> + Sized> MulAssign<&'a I> for NDArray<T>

where NDArray<T>: Blas<T> + NDData<T>,

fn mul_assign(&mut self, rhs: &'a I)

Performs the *= operation.

impl<T> NDData<T> for NDArray<T>

fn shape(&self) -> &[usize]

Return a slice of length N where each element is the length of the dimension. For a 2 dimensional matrix, the first dimension is the number of rows and the second dimension is the number of columns.

fn strides(&self) -> &[usize]

Return a slice of length N where each element is the stride of the dimension.

fn get_data(&self) -> &[T]

Return the underlying storage array as a slice.

fn dim(&self) -> usize

Return N, the number of dimensions.

fn size(&self) -> usize

Return the total number of element of the N-dimensional array.

fn idx<'a>(&'a self, idx: &[usize]) -> &'a T

Take a slice of length N representing an N-dimensional index in the array and return a reference to the element at this position.

impl<T: Clone + Display> NDDataMut<T> for NDArray<T>

fn transpose(&mut self)

The transpose function of a NDArray allow to transpose any shape.

fn get_data_mut(&mut self) -> &mut [T]

Return the underlying storage array as a mutable slice.

fn idx_mut<'a>(&'a mut self, idx: &[usize]) -> &'a mut T

Take a slice of length N representing an -index in the array and return a mutable reference to the element at this position.

fn assign(&mut self, other: &dyn NDData<T>)

Assign another NDData to the NDDataMut. The shapes need to be identical.

impl<'a, T: 'a> NDSliceable<'a, T> for NDArray<T>

fn slice(&'a self, idx: &[usize]) -> NDSlice<'a, T>

Take a slice of length < N representing the sub slice index and return immutable borrow of the sub slice as an NDSlice. Because the storage is in row-major order and the slice need to be contiguous in the underlying storage array it means, for example, only the rows of a matrix can be borrowed.

impl<'a, T: 'a> NDSliceableMut<'a, T> for NDArray<T>

fn slice_mut(&'a mut self, idx: &[usize]) -> NDSliceMut<'a, T>

Take a slice of length < N representing the sub slice index and return immutable borrow of the sub slice as an NDSlice. Because the storage is in row-major order and the slice need to be contiguous in the underlying storage array it means, for example, only the rows of a matrix can be borrowed.

impl<T: PartialEq, O: NDData<T> + Sized> PartialEq<O> for NDArray<T>

fn eq(&self, other: &O) -> 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> SizedBuffer for NDArray<T>

unsafe fn get_raw_ptr(&self) -> *const c_void

fn get_raw_size(&self) -> usize

impl<T: Clone + Display> SizedBufferMut for NDArray<T>

where NDArray<T>: SizedBuffer,

unsafe fn get_raw_ptr_mut(&mut self) -> *mut c_void

impl<'a, 'b, T: Clone + Display + From<f32>, R: NDData<T> + Sized> Sub<&'a R> for &'b NDArray<T>

where NDArray<T>: Blas<T>,

type Output = NDArray<T>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a R) -> NDArray<T>

Performs the - operation.

impl<'a, T: Clone + Display + From<f32>, R: NDData<T> + Sized> SubAssign<&'a R> for NDArray<T>

where NDArray<T>: Blas<T>,

fn sub_assign(&mut self, rhs: &'a R)

Performs the -= operation.

impl<T: Eq> Eq for NDArray<T>