Struct arr_rs::core::array::Array

pub struct Array<T: ArrayElement> { /* 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> ArrayArithmetic<N> for Array<N>

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

Add arguments element-wise

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

Computes reciprocal of array elements

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

Computes numerical positive of array elements Equivalent to self.clone()

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

Computes numerical negative of array elements

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

Multiply arguments element-wise

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

Divide arguments element-wise

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

Divide arguments element-wise alias on divide

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

Divide arguments element-wise, returning floor value

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

Computes integer power of array elements

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

Computes float power of array elements

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

Subtract arguments element-wise

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

Computes remainder of division element-wise alias on remainder

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

Computes remainder of division element-wise

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

Computes fractional and integral parts of an array, element-wise

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

Computes remainder of division element-wise

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

Computes integral and fractional parts of an array, element-wise

impl<T: ArrayElement> ArrayAxis<T> for Array<T>

fn apply_along_axis<S: ArrayElement, F>( &self, axis: usize, f: F ) -> Result<Array<S>, ArrayError>where F: FnMut(&Array<T>) -> Result<Array<S>, ArrayError>,

Applies given function along an axis

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> ArrayBinary<N> for Array<N>

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

Compute the bit-wise AND of two arrays element-wise

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

Compute the bit-wise OR of two arrays element-wise

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

Compute the bit-wise XOR of two arrays element-wise

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

Compute bit-wise inversion, or bit-wise NOT, element-wise

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

Compute bit-wise inversion, or bit-wise NOT, element-wise. Alias on bitwise_not

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

Shift the bits of an integer to the left

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

Shift the bits of an integer to the right

fn binary_repr(num: N) -> String

Return the binary representation of the input number as a string

impl ArrayBinaryBits for Array<u8>

fn unpack_bits( &self, axis: Option<isize>, count: Option<isize>, bit_order: Option<impl BitOrderType> ) -> Result<Array<u8>, ArrayError>

Unpacks elements of a uint8 array into a binary-valued output array

fn pack_bits( &self, axis: Option<isize>, bit_order: Option<impl BitOrderType> ) -> Result<Array<u8>, ArrayError>

Packs the elements of a binary-valued array into bits in a uint8 array

impl<T: ArrayElement> ArrayBroadcast<T> for Array<T>

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

Broadcast an array to a new shape

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

Broadcast an array to a new shape

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

Broadcast a list of arrays to a common shape

impl<T: ArrayElement> ArrayCount<T> for Array<T>

fn count_nonzero( &self, axis: Option<isize>, keepdims: Option<bool> ) -> Result<Array<usize>, ArrayError>

Sort an array

impl<T: ArrayElement> ArrayCreate<T> for Array<T>

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

Creates new array

fn create( elements: Vec<T>, shape: Vec<usize>, ndmin: Option<usize> ) -> Result<Array<T>, ArrayError>

Creates new array

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

Creates new array with single element

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

Creates new flat array

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

Creates new empty array

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> ArrayCreateNumeric<N> for Array<N>

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

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

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> ArrayExpLog<N> for Array<N>

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

Computes the exponential of array elements

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

Computes 2**element of array elements

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

Computes exp - 1 of array elements

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

Computes natural logarithm of array elements

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

Computes logarithm base 2 of array elements

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

Computes logarithm base 10 of array elements

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

Computes log(1 + x) of array elements

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

Computes logarithm base n of array elements

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

Computes log(exp(x1) + exp(x2)) of array elements

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

Computes log2(2x1 + 2x2) of array elements

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

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

Element-wise maximum of array elements

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

Return the maximum of an array or maximum along an axis

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

Return the maximum of an array or maximum along an axis alias on max

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

Element-wise maximum of array elements

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

Return the maximum of an array or maximum along an axis, ignoring NAN

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

Element-wise minimum of array elements

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

Return the minimum of an array or minimum along an axis

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

Return the minimum of an array or minimum along an axis alias on min

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

Element-wise maximum of array elements

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

Return the minimum of an array or minimum along an axis, ignoring NAN

impl<N: Floating> ArrayFloating<N> for Array<N>

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

Returns element-wise True where signbit is set (less than zero)

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

Change the sign of x1 to that of x2, element-wise

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

Decompose the elements of x into man and twos exp

fn ldexp(&self, other: &Array<i32>) -> Result<Array<N>, ArrayError>

Returns x1 * 2**x2, element-wise. Inverse of frexp

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

Return the next floating-point value after x1 towards x2, element-wise

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

Return the distance between x and the nearest adjacent number

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

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

Compute the hyperbolic sine of array elements

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

Compute the hyperbolic cosine of array elements

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

Compute the hyperbolic tangent of array elements

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

Compute the inverse hyperbolic sine of array elements

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

Compute the inverse hyperbolic cosine of array elements

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

Compute the inverse hyperbolic tangent of array elements

impl<T: ArrayElement> ArrayIndexing<T> for Array<T>

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<T, 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

fn indices_at(&self, indices: &[usize]) -> Result<Array<T>, ArrayError>

Return a subarray consisting on values on given indices.

impl<T: ArrayElement> ArrayIter<T> for Array<T>

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

Loop over array elements

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

Loop over enumerated array elements

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

Filter over array elements Returns a flat filtered array

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

Filter over enumerated array elements Returns a flat filtered array

impl<S: ArrayElement, T: ArrayElement> ArrayIterMut<S, T> for Array<T>

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

Map over array elements

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

Map over enumerated array elements

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

Filter and map over array elements Returns a flat filtered array

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

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

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

Fold elements of array elements

fn zip(&self, other: &Array<S>) -> Result<Array<Tuple2<T, S>>, ArrayError>

‘Zips up’ two iterators into a single iterator of pairs

impl<T: ArrayElement> ArrayJoining<T> for Array<T>

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<T: ArrayElement> ArrayManipulate<T> for Array<T>

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

Insert values along the given axis for the given indices

fn delete( &self, indices: &[usize], axis: Option<usize> ) -> Result<Array<T>, ArrayError>

Delete values along the given axis

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

Append values to the end of an array

fn reshape(&self, shape: &[usize]) -> Result<Array<T>, ArrayError>

Reshapes an array

fn resize(&self, shape: &[usize]) -> Result<Array<T>, ArrayError>

Resizes an array,

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

Find the unique elements of an array

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

Return a contiguous flattened array

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

Convert array to at least n dimension

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

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

fn cycle_take(&self, n: usize) -> Result<Array<T>, ArrayError>

Performs cycle().take(n), returning flattened array

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

fn convolve( &self, other: &Array<N>, mode: Option<impl ConvolveModeType> ) -> Result<Array<N>, ArrayError>

Returns the discrete, linear convolution of two one-dimensional sequences arrays are flattened for computation

fn clip( &self, a_min: Option<Array<N>>, a_max: Option<Array<N>> ) -> Result<Array<N>, ArrayError>

Clip (limit) the values in an array

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

Computes square root of array elements

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

Computes cube root of array elements

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

Return the element-wise square of the input

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

Computes absolute value of array elements

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

Computes absolute value of array elements alias on absolute

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

Computes absolute value of array elements alias on absolute

fn sign(&self) -> Result<Array<isize>, ArrayError>

Returns an element-wise indication of the sign of a number

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

Compute the Heaviside step function

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

Replace NaN with zero and infinity with large finite numbers

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

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

Modified Bessel function of the first kind, order 0

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

Return the normalized sinc function

impl<T: ArrayElement> ArrayMeta<T> for Array<T>

fn get_elements(&self) -> Result<Vec<T>, 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> ArrayRational<N> for Array<N>

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

Returns the lowest common multiple of |x1| and |x2|

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

Returns the greatest common divisor of |x1| and |x2|

impl<T: ArrayElement> ArrayReorder<T> for Array<T>

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

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

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

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

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

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

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

Roll array elements along a given axis

fn rot90(&self, k: usize, axes: Vec<isize>) -> Result<Array<T>, 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> ArrayRounding<N> for Array<N>

fn round(&self, decimals: &Array<isize>) -> Result<Array<N>, ArrayError>

Evenly round to the given number of decimals

fn around(&self, decimals: &Array<isize>) -> Result<Array<N>, ArrayError>

Evenly round to the given number of decimals. alias on round

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

Round elements of the array to the nearest integer

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

Round to nearest integer towards zero

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

Round to nearest integer towards zero

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

Return the floor of the input, element-wise

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

Return the ceil of the input, element-wise

impl<T: ArrayElement> ArraySearch<T> for Array<T>

fn argmax( &self, axis: Option<isize>, keepdims: Option<bool> ) -> Result<Array<usize>, ArrayError>

Returns the indices of the maximum values along an axis.

fn argmin( &self, axis: Option<isize>, keepdims: Option<bool> ) -> Result<Array<usize>, ArrayError>

Returns the indices of the minimum values along an axis.

impl<T: ArrayElement> ArraySort<T> for Array<T>

fn sort( &self, axis: Option<isize>, kind: Option<impl SortKindType> ) -> Result<Array<T>, ArrayError>

Sort an array

fn argsort( &self, axis: Option<isize>, kind: Option<impl SortKindType> ) -> Result<Array<usize>, ArrayError>

Returns the indices that would sort an array

impl<T: ArrayElement> ArraySplit<T> for Array<T>

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

Split an array into multiple sub-arrays

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

Split an array into multiple sub-arrays of equal size

fn split_axis(&self, axis: usize) -> Result<Vec<Array<T>>, ArrayError>

Split an array into multiple sub-arrays of equal size by axis

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

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

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

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

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

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

impl<N: Alphanumeric> ArrayStringCompare<N> for Array<N>

fn equal(&self, other: &Array<N>) -> Result<Array<bool>, ArrayError>

Return (self == other) element-wise

fn not_equal(&self, other: &Array<N>) -> Result<Array<bool>, ArrayError>

Return (self != other) element-wise

fn greater_equal(&self, other: &Array<N>) -> Result<Array<bool>, ArrayError>

Return (self >= other) element-wise

fn less_equal(&self, other: &Array<N>) -> Result<Array<bool>, ArrayError>

Return (self <= other) element-wise

fn greater(&self, other: &Array<N>) -> Result<Array<bool>, ArrayError>

Return (self > other) element-wise

fn less(&self, other: &Array<N>) -> Result<Array<bool>, ArrayError>

Return (self < other) element-wise

fn compare( &self, other: &Array<N>, cmp_op: impl CompareOpType ) -> Result<Array<bool>, ArrayError>

Performs element-wise comparison of two string arrays using the comparison operator specified by cmp_op

impl<N: Alphanumeric> ArrayStringIndexing<N> for Array<N>

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

Return string.len() element-wise

fn count(&self, sub: &Array<N>) -> Result<Array<usize>, ArrayError>

Returns an array with the number of non-overlapping occurrences of substring sub

fn starts_with(&self, prefix: &Array<N>) -> Result<Array<bool>, ArrayError>

Checks if string element starts with prefix

fn ends_with(&self, suffix: &Array<N>) -> Result<Array<bool>, ArrayError>

Checks if string element ends with suffix

fn find(&self, sub: &Array<N>) -> Result<Array<isize>, ArrayError>

For each element, return the lowest index in the string where substring sub is found

fn rfind(&self, sub: &Array<N>) -> Result<Array<isize>, ArrayError>

For each element, return the highest index in the string where substring sub is found

fn index(&self, sub: &Array<N>) -> Result<Array<isize>, ArrayError>

For each element, return the lowest index in the string where substring sub is found; alias on find

fn rindex(&self, sub: &Array<N>) -> Result<Array<isize>, ArrayError>

For each element, return the highest index in the string where substring sub is found; alias on rfind

impl<N: Alphanumeric> ArrayStringManipulate<N> for Array<N>

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

Return element-wise string concatenation for two arrays of String

fn multiply(&self, counts: &Array<usize>) -> Result<Array<N>, ArrayError>

Return (a * i), that is string multiple concatenation, element-wise

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

Capitalizes first character of each element

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

Turns characters to lower-case

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

Turns characters to upper-case

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

Swap characters case

fn center( &self, width: &Array<usize>, fill_char: Option<Array<char>> ) -> Result<Array<N>, ArrayError>

Centers elements in a string of length of width

fn join(&self, sep: &Array<N>) -> Result<Array<N>, ArrayError>

Concatenate the strings in the sequence

fn partition( &self, sep: &Array<N> ) -> Result<Array<Tuple3<N, N, N>>, ArrayError>

Partition each element around first occurrence of sep

fn rpartition( &self, sep: &Array<N> ) -> Result<Array<Tuple3<N, N, N>>, ArrayError>

Partition each element around last occurrence of sep

fn split( &self, sep: Option<Array<N>>, max_split: Option<Array<usize>> ) -> Result<Array<List<N>>, ArrayError>

Returns a list of the words in the string, using sep as the delimiter string.

fn rsplit( &self, sep: Option<Array<N>>, max_split: Option<Array<usize>> ) -> Result<Array<List<N>>, ArrayError>

Returns a list of the words in the string, using sep as the delimiter string.

fn splitlines( &self, keep_ends: Option<Array<bool>> ) -> Result<Array<List<N>>, ArrayError>

Returns a list of the words in the string, using line break character as the delimiter string.

fn replace( &self, old: &Array<N>, new: &Array<N>, count: Option<usize> ) -> Result<Array<N>, ArrayError>

Replaces all occurrences of with

fn strip(&self, chars: Option<Array<N>>) -> Result<Array<N>, ArrayError>

Trims leading and trailing characters

fn lstrip(&self, chars: Option<Array<N>>) -> Result<Array<N>, ArrayError>

Trims leading characters

fn rstrip(&self, chars: Option<Array<N>>) -> Result<Array<N>, ArrayError>

Trims trailing characters

fn ljust( &self, width: &Array<usize>, fill_char: Option<Array<char>> ) -> Result<Array<N>, ArrayError>

Left-justifies elements in a string of length of width

fn rjust( &self, width: &Array<usize>, fill_char: Option<Array<char>> ) -> Result<Array<N>, ArrayError>

Right-justifies elements in a string of length of width

impl<N: Alphanumeric> ArrayStringValidate<N> for Array<N>

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

Check if all characters in the string are alphabetic and there is at least one character

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

Check if all characters in the string are alphanumeric and there is at least one character

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

Check if all characters in the string are decimal and there is at least one character

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

Check if all characters in the string are numeric and there is at least one character

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

Check if all characters in the string are digits and there is at least one character

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

Check if all characters in the string are whitespace and there is at least one character

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

Check if all characters in the string are lowercase and there is at least one character

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

Check if all characters in the string are uppercase and there is at least one character

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

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

Multiplication of array elements

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

Sum of array elements

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

Sum of array elements treating NaN as one

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

Sum of array elements treating NaN as zero

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

Cumulative product of array elements

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

Cumulative sum of array elements

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

Cumulative product of array elements

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

Cumulative sum of array elements

fn diff( &self, n: usize, axis: Option<isize>, prepend: Option<Array<N>>, append: Option<Array<N>> ) -> Result<Array<N>, ArrayError>

The differences between consecutive elements of an array

fn ediff1d( &self, to_end: Option<Array<N>>, to_begin: Option<Array<N>> ) -> Result<Array<N>, ArrayError>

The differences between consecutive elements of an array

impl<T: ArrayElement> ArrayTiling<T> for Array<T>

fn repeat( &self, repeats: &[usize], axis: Option<usize> ) -> Result<Array<T>, ArrayError>

Repeat each element of an array after themselves

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

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

Compute the sine of array elements

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

Compute the cosine of array elements

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

Compute the tangent of array elements

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

Compute the inverse sine of array elements

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

Compute the inverse cosine of array elements

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

Compute the inverse tangent of array elements

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

Compute the inverse tangent of x1/x2 choosing the quadrant correctly

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

Given the “legs” of a right triangle, return its hypotenuse

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

Convert angles from radians to degrees

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

Convert angles from radians to degrees. alias on degrees

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

Convert angles from degrees to radians

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

Convert angles from degrees to radians. alias on radians

fn unwrap_phase( &self, discont: Option<Array<f64>>, axis: Option<isize>, period: Option<Array<f64>> ) -> Result<Array<N>, ArrayError>

Unwrap by taking the complement of large deltas with respect to the period

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<T: Clone + ArrayElement> Clone for Array<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug + ArrayElement> Debug for Array<T>

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

Formats the value using the given formatter.

impl<T: ArrayElement> Display for Array<T>

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: ArrayElement> FromIterator<N> for Array<N>

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

Creates a value from an iterator.

impl<T: ArrayElement> Index<&[usize]> for Array<T>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T: ArrayElement> Index<usize> for Array<T>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T: ArrayElement> IndexMut<usize> for Array<T>

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

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

impl<'a, N: ArrayElement> 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: ArrayElement> 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: SignedNumericOps> 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<T: ArrayElement> PartialEq<Array<T>> for Array<T>

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<T: ArrayElement> PartialOrd<Array<T>> for Array<T>

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.