Struct arr_rs::arrays::Array

pub struct Array<N: Numeric> { /* private fields */ }

Array structure definition

Trait Implementations

impl<N: NumericOps> Add<Array<N>> for Array<N>

type Output = Array<N>

The resulting type after applying the + operator.

fn add(self, other: Self) -> Self::Output

Performs the + operation.

impl<N: NumericOps> Add<N> for Array<N>

type Output = Result<Array<N>, ArrayError>

The resulting type after applying the + operator.

fn add(self, other: N) -> Self::Output

Performs the + operation.

impl<N: NumericOps> AddAssign<Array<N>> for Array<N>

fn add_assign(&mut self, other: Self)

Performs the += operation.

impl<N: NumericOps> AddAssign<N> for Array<N>

fn add_assign(&mut self, other: N)

Performs the += operation.

impl<N: Numeric> ArrayAxis<N> for Array<N>

fn transpose(&self, axes: Option<Vec<isize>>) -> Result<Self, ArrayError>

Returns an array with axes transposed

fn moveaxis( &self, source: Vec<isize>, destination: Vec<isize> ) -> Result<Self, ArrayError>

Move axes of an array to new positions

fn rollaxis( &self, axis: isize, start: Option<isize> ) -> Result<Self, ArrayError>

Roll the specified axis backwards, until it lies in a given position

fn swapaxes(&self, axis_1: isize, axis_2: isize) -> Result<Self, ArrayError>

Interchange two axes of an array

fn expand_dims(&self, axes: Vec<isize>) -> Result<Self, ArrayError>

Expand the shape of an array

fn squeeze(&self, axes: Option<Vec<isize>>) -> Result<Self, ArrayError>

Remove axes of length one from array

impl<N: Numeric> ArrayBroadcast<N> for Array<N>

fn broadcast(&self, other: &Array<N>) -> Result<Array<Tuple2<N>>, ArrayError>

Broadcast an array to a new shape

fn broadcast_to(&self, shape: Vec<usize>) -> Result<Array<N>, ArrayError>

Broadcast an array to a new shape

fn broadcast_arrays(arrays: Vec<Array<N>>) -> Result<Vec<Array<N>>, ArrayError>

Broadcast a list of arrays to a common shape

impl<N: Numeric> ArrayCreate<N> for Array<N>

fn new(elements: Vec<N>, shape: Vec<usize>) -> Result<Array<N>, ArrayError>

Creates new array

fn single(element: N) -> Result<Self, ArrayError>

Creates new array with single element

fn flat(elements: Vec<N>) -> Result<Self, ArrayError>

Creates new flat array

fn rand(shape: Vec<usize>) -> Result<Self, ArrayError>

Creates new array with random elements from (0 ..= 1) range

fn empty() -> Result<Self, ArrayError>

Creates new empty array

fn eye(n: usize, m: Option<usize>, k: Option<usize>) -> Result<Self, ArrayError>

Creates new 2d array with ones on the diagonal and zeros elsewhere

fn identity(n: usize) -> Result<Self, ArrayError>

Creates new identity 2d array

fn zeros(shape: Vec<usize>) -> Result<Self, ArrayError>

Creates new array of zeros

fn zeros_like(other: &Self) -> Result<Self, ArrayError>

Creates new array of zeros like other array

fn ones(shape: Vec<usize>) -> Result<Self, ArrayError>

Creates new array of ones

fn ones_like(other: &Self) -> Result<Self, ArrayError>

Creates new array of ones like other array

fn full(shape: Vec<usize>, fill_value: N) -> Result<Self, ArrayError>

Creates new array of fill_value

fn full_like(other: &Self, fill_value: N) -> Result<Self, ArrayError>

Creates new array of fill_value like other array

fn arange(start: N, stop: N, step: Option<N>) -> Result<Self, ArrayError>

Creates new array from range

fn linspace( start: N, stop: N, num: Option<usize>, endpoint: Option<bool> ) -> Result<Self, ArrayError>

Creates new array of numbers evenly spaced over a specified interval

fn linspace_a( start: &Self, stop: &Self, num: Option<usize>, endpoint: Option<bool> ) -> Result<Array<N>, ArrayError>

Creates new array of numbers evenly spaced over a specified interval

fn logspace( start: N, stop: N, num: Option<usize>, endpoint: Option<bool>, base: Option<usize> ) -> Result<Self, ArrayError>

Creates new array of numbers evenly spaced on a log scale over a specified interval

fn logspace_a( start: &Self, stop: &Self, num: Option<usize>, endpoint: Option<bool>, base: Option<&Array<usize>> ) -> Result<Array<N>, ArrayError>

Creates new array of numbers evenly spaced on a log scale over a specified interval

fn geomspace( start: N, stop: N, num: Option<usize>, endpoint: Option<bool> ) -> Result<Array<N>, ArrayError>

Creates new array of numbers evenly spaced on a log scale (a geometric progression) over a specified interval

fn geomspace_a( start: &Self, stop: &Self, num: Option<usize>, endpoint: Option<bool> ) -> Result<Array<N>, ArrayError>

Creates new array of numbers evenly spaced on a log scale (a geometric progression) over a specified interval

fn tri( n: usize, m: Option<usize>, k: Option<isize> ) -> Result<Array<N>, ArrayError>

Construct an array with ones at and below the given diagonal and zeros elsewhere

impl<N: Numeric> ArrayCreateFrom<N> for Array<N>

fn diag(&self, k: Option<isize>) -> Result<Array<N>, ArrayError>

Extract a diagonal or construct a diagonal array

fn diagflat(&self, k: Option<isize>) -> Result<Array<N>, ArrayError>

Construct a diagonal array for flattened input

fn tril(&self, k: Option<isize>) -> Result<Array<N>, ArrayError>

Return a copy of an array with elements above the k-th diagonal zeroed. For arrays with ndim exceeding 2, tril will apply to the final two axes.

fn triu(&self, k: Option<isize>) -> Result<Array<N>, ArrayError>

Return a copy of an array with elements below the k-th diagonal zeroed. For arrays with ndim exceeding 2, triu will apply to the final two axes.

fn vander( &self, n: Option<usize>, increasing: Option<bool> ) -> Result<Array<N>, ArrayError>

Generate a Vandermonde matrix

impl<N: Numeric> ArrayIndexing<N> for Array<N>

fn index_at(&self, coords: &[usize]) -> Result<usize, ArrayError>

Return an index of element at the given coordinates

fn index_to_coord(&self, idx: usize) -> Result<Vec<usize>, ArrayError>

Return coordinates at the given index of element

fn at(&self, coords: &[usize]) -> Result<N, ArrayError>

Return an index of element at the given coordinates

fn slice(&self, range: Range<usize>) -> Result<Self, ArrayError>

Return a subarray of provided range

impl<N: Numeric> ArrayIter<N> for Array<N>

fn for_each<F: FnMut(&N)>(&self, f: F) -> Result<(), ArrayError>

Loop over array elements

fn for_each_e<F: FnMut(usize, &N)>(&self, f: F) -> Result<(), ArrayError>

Loop over enumerated array elements

fn map<F: FnMut(&N) -> N>(&self, f: F) -> Result<Array<N>, ArrayError>

Map over array elements

fn map_e<F: FnMut(usize, &N) -> N>(&self, f: F) -> Result<Array<N>, ArrayError>

Map over enumerated array elements

fn filter<F: FnMut(&N) -> bool>(&self, f: F) -> Result<Array<N>, ArrayError>

Filter over array elements Returns a flat filtered array

fn filter_e<F: FnMut(usize, &N) -> bool>( &self, f: F ) -> Result<Array<N>, ArrayError>

Filter over enumerated array elements Returns a flat filtered array

fn filter_map<F: FnMut(&N) -> Option<N>>( &self, f: F ) -> Result<Array<N>, ArrayError>

Filter and map over array elements Returns a flat filtered array

fn filter_map_e<F: FnMut(usize, &N) -> Option<N>>( &self, f: F ) -> Result<Array<N>, ArrayError>

Filter and map over enumerated array elements Returns a flat filtered array

fn fold<F: FnMut(&N, &N) -> N>(&self, init: N, f: F) -> Result<N, ArrayError>

Fold elements of array elements

impl<N: Numeric> ArrayManipulate<N> for Array<N>

fn insert( &self, indices: Vec<usize>, values: &Self, axis: Option<usize> ) -> Result<Array<N>, ArrayError>

Insert values along the given axis for the given indices

fn delete( &self, indices: Vec<usize>, axis: Option<usize> ) -> Result<Array<N>, ArrayError>

Delete values along the given axis

fn append( &self, values: &Self, axis: Option<usize> ) -> Result<Array<N>, ArrayError>

Append values to the end of an array

fn reshape(&self, shape: Vec<usize>) -> Result<Array<N>, ArrayError>

Reshapes an array

fn resize(&self, shape: Vec<usize>) -> Result<Array<N>, ArrayError>

Resizes an array,

fn unique(&self, axis: Option<usize>) -> Result<Array<N>, ArrayError>

Find the unique elements of an array,

fn ravel(&self) -> Result<Array<N>, ArrayError>

Return a contiguous flattened array

fn atleast(&self, n: usize) -> Result<Array<N>, ArrayError>

Convert array to at least n dimension

fn trim_zeros(&self) -> Result<Array<N>, ArrayError>

Trim the leading and/or trailing zeros from a 1D array

impl<N: Numeric> ArrayMath<N> for Array<N>

fn power(&self, value: N) -> Result<Array<N>, ArrayError>

Computes power of array elements

fn product(&self) -> Result<N, ArrayError>

Multiplication of array elements

fn sum(&self) -> Result<N, ArrayError>

Sum of array elements

fn cumsum(&self) -> Result<Array<N>, ArrayError>

Cumulative sum of array elements

impl<N: Numeric> ArrayMeta<N> for Array<N>

fn get_elements(&self) -> Result<Vec<N>, ArrayError>

Obtain the vector containing array elements

fn get_shape(&self) -> Result<Vec<usize>, ArrayError>

Obtain the vector containing array shape

fn ndim(&self) -> Result<usize, ArrayError>

Count of array dimensions

fn len(&self) -> Result<usize, ArrayError>

Count of array elements

fn is_empty(&self) -> Result<bool, ArrayError>

Check if array element count equals zero

impl<N: Numeric> ArrayReorder<N> for Array<N>

fn flip(&self, axes: Option<Vec<isize>>) -> Result<Array<N>, ArrayError>

Reverse the order of elements in an array along the given axis

fn flipud(&self) -> Result<Array<N>, ArrayError>

Reverse the order of elements along axis 0 (up/down)

fn fliplr(&self) -> Result<Array<N>, ArrayError>

Reverse the order of elements along axis 1 (left/right)

fn roll( &self, shift: Vec<isize>, axes: Option<Vec<isize>> ) -> Result<Array<N>, ArrayError>

Roll array elements along a given axis

fn rot90(&self, k: usize, axes: Vec<isize>) -> Result<Array<N>, ArrayError>

Rotate an array by 90 degrees in the plane specified by axes. Rotation direction is from the first towards the second axis.

impl<N: Numeric> ArraySplit<N> for Array<N>

fn array_split( &self, parts: usize, axis: Option<usize> ) -> Result<Vec<Array<N>>, ArrayError>

Split an array into multiple sub-arrays

fn split( &self, parts: usize, axis: Option<usize> ) -> Result<Vec<Array<N>>, ArrayError>

Split an array into multiple sub-arrays of equal size

fn hsplit(&self, parts: usize) -> Result<Vec<Array<N>>, ArrayError>

Split an array into multiple sub-arrays horizontally (column-wise)

fn vsplit(&self, parts: usize) -> Result<Vec<Array<N>>, ArrayError>

Split an array into multiple sub-arrays vertically (row-wise)

fn dsplit(&self, parts: usize) -> Result<Vec<Array<N>>, ArrayError>

Split an array into multiple sub-arrays along the 3rd axis (depth)

impl<N: Numeric> ArrayStack<N> for Array<N>

fn concatenate(arrs: Vec<Self>, axis: Option<usize>) -> Result<Self, ArrayError>

Join a sequence of arrays along an existing axis

fn stack(arrs: Vec<Self>, axis: Option<usize>) -> Result<Self, ArrayError>

Join a sequence of arrays along a new axis

fn vstack(arrs: Vec<Self>) -> Result<Self, ArrayError>

Stack arrays in sequence vertically (row wise)

fn hstack(arrs: Vec<Self>) -> Result<Self, ArrayError>

Stack arrays in sequence horizontally (column wise)

fn dstack(arrs: Vec<Self>) -> Result<Self, ArrayError>

Stack arrays in sequence depth wise (along third axis)

fn column_stack(arrs: Vec<Self>) -> Result<Self, ArrayError>

Stack 1d or 2d arrays as columns into a 2d array row_stack is an alias for vstack

fn row_stack(arrs: Vec<Self>) -> Result<Self, ArrayError>

Stack arrays in sequence vertically (row wise)

impl<N: Numeric + BitAnd<Output = N>> BitAnd<Array<N>> for Array<N>

type Output = Array<N>

The resulting type after applying the & operator.

fn bitand(self, other: Array<N>) -> Self::Output

Performs the & operation.

impl<N: Numeric + BitAnd<Output = N>> BitAnd<N> for Array<N>

type Output = Array<N>

The resulting type after applying the & operator.

fn bitand(self, other: N) -> Self::Output

Performs the & operation.

impl<N: Numeric + BitAnd<Output = N>> BitAndAssign<Array<N>> for Array<N>

fn bitand_assign(&mut self, other: Array<N>)

Performs the &= operation.

impl<N: Numeric + BitAnd<Output = N>> BitAndAssign<N> for Array<N>

fn bitand_assign(&mut self, other: N)

Performs the &= operation.

impl<N: Numeric + BitOr<Output = N>> BitOr<Array<N>> for Array<N>

type Output = Array<N>

The resulting type after applying the | operator.

fn bitor(self, other: Array<N>) -> Self::Output

Performs the | operation.

impl<N: Numeric + BitOr<Output = N>> BitOr<N> for Array<N>

type Output = Array<N>

The resulting type after applying the | operator.

fn bitor(self, other: N) -> Self::Output

Performs the | operation.

impl<N: Numeric + BitOr<Output = N>> BitOrAssign<Array<N>> for Array<N>

fn bitor_assign(&mut self, other: Array<N>)

Performs the |= operation.

impl<N: Numeric + BitOr<Output = N>> BitOrAssign<N> for Array<N>

fn bitor_assign(&mut self, other: N)

Performs the |= operation.

impl<N: Numeric + BitXor<Output = N>> BitXor<Array<N>> for Array<N>

type Output = Array<N>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Array<N>) -> Self::Output

Performs the ^ operation.

impl<N: Numeric + BitXor<Output = N>> BitXor<N> for Array<N>

type Output = Array<N>

The resulting type after applying the ^ operator.

fn bitxor(self, other: N) -> Self::Output

Performs the ^ operation.

impl<N: Numeric + BitXor<Output = N>> BitXorAssign<Array<N>> for Array<N>

fn bitxor_assign(&mut self, other: Array<N>)

Performs the ^= operation.

impl<N: Numeric + BitXor<Output = N>> BitXorAssign<N> for Array<N>

fn bitxor_assign(&mut self, other: N)

Performs the ^= operation.

impl<N: Clone + Numeric> Clone for Array<N>

fn clone(&self) -> Array<N>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<N: Debug + Numeric> Debug for Array<N>

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

Formats the value using the given formatter.

impl<N: Numeric> Display for Array<N>

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

Formats the value using the given formatter.

impl<N: NumericOps> Div<Array<N>> for Array<N>

type Output = Array<N>

The resulting type after applying the / operator.

fn div(self, other: Self) -> Self::Output

Performs the / operation.

impl<N: NumericOps> Div<N> for Array<N>

type Output = Result<Array<N>, ArrayError>

The resulting type after applying the / operator.

fn div(self, other: N) -> Self::Output

Performs the / operation.

impl<N: NumericOps> DivAssign<Array<N>> for Array<N>

fn div_assign(&mut self, other: Self)

Performs the /= operation.

impl<N: NumericOps> DivAssign<N> for Array<N>

fn div_assign(&mut self, other: N)

Performs the /= operation.

impl<N: Numeric> FromIterator<N> for Array<N>

fn from_iter<T: IntoIterator<Item = N>>(iter: T) -> Self

Creates a value from an iterator.

impl<N: Numeric> Index<&[usize]> for Array<N>

type Output = N

The returned type after indexing.

fn index(&self, coords: &[usize]) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<N: Numeric> Index<usize> for Array<N>

type Output = N

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<N: Numeric> IndexMut<&[usize]> for Array<N>

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

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

impl<N: Numeric> IndexMut<usize> for Array<N>

fn index_mut(&mut self, index: usize) -> &mut Self::Output

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

impl<'a, N: Numeric> IntoIterator for &'a Array<N>

type Item = &'a N

The type of the elements being iterated over.

type IntoIter = Iter<'a, N>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<N: Numeric> IntoIterator for Array<N>

type Item = N

The type of the elements being iterated over.

type IntoIter = IntoIter<N, Global>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<N: NumericOps> Mul<Array<N>> for Array<N>

type Output = Array<N>

The resulting type after applying the * operator.

fn mul(self, other: Self) -> Self::Output

Performs the * operation.

impl<N: NumericOps> Mul<N> for Array<N>

type Output = Result<Array<N>, ArrayError>

The resulting type after applying the * operator.

fn mul(self, other: N) -> Self::Output

Performs the * operation.

impl<N: NumericOps> MulAssign<Array<N>> for Array<N>

fn mul_assign(&mut self, other: Self)

Performs the *= operation.

impl<N: NumericOps> MulAssign<N> for Array<N>

fn mul_assign(&mut self, other: N)

Performs the *= operation.

impl<N: SignedNumeric> Neg for Array<N>

type Output = Array<N>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<N: BoolNumeric + From<<N as Not>::Output>> Not for Array<N>

type Output = Array<N>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<N: Numeric> PartialEq<Array<N>> for Array<N>

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<N: Numeric> PartialOrd<Array<N>> for Array<N>

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Self) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Self) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Self) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Self) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<N: NumericOps> Rem<Array<N>> for Array<N>

type Output = Array<N>

The resulting type after applying the % operator.

fn rem(self, other: Self) -> Self::Output

Performs the % operation.

impl<N: NumericOps> Rem<N> for Array<N>

type Output = Result<Array<N>, ArrayError>

The resulting type after applying the % operator.

fn rem(self, other: N) -> Self::Output

Performs the % operation.

impl<N: NumericOps> RemAssign<Array<N>> for Array<N>

fn rem_assign(&mut self, other: Self)

Performs the %= operation.

impl<N: NumericOps> RemAssign<N> for Array<N>

fn rem_assign(&mut self, other: N)

Performs the %= operation.

impl<N: NumericOps> Sub<Array<N>> for Array<N>

type Output = Array<N>

The resulting type after applying the - operator.

fn sub(self, other: Self) -> Self::Output

Performs the - operation.

impl<N: NumericOps> Sub<N> for Array<N>

type Output = Result<Array<N>, ArrayError>

The resulting type after applying the - operator.

fn sub(self, other: N) -> Self::Output

Performs the - operation.

impl<N: NumericOps> SubAssign<Array<N>> for Array<N>

fn sub_assign(&mut self, other: Self)

Performs the -= operation.

impl<N: NumericOps> SubAssign<N> for Array<N>

fn sub_assign(&mut self, other: N)

Performs the -= operation.