Trait ArrayManipulate

pub trait ArrayManipulate<T: ArrayElement>
where
    Array<T>: Sized + Clone,
{
    // Required methods
    fn insert(
        &self,
        indices: &[usize],
        values: &Array<T>,
        axis: Option<usize>,
    ) -> Result<Array<T>, ArrayError>;
    fn delete(
        &self,
        indices: &[usize],
        axis: Option<usize>,
    ) -> Result<Array<T>, ArrayError>;
    fn append(
        &self,
        values: &Array<T>,
        axis: Option<usize>,
    ) -> Result<Array<T>, ArrayError>;
    fn reshape(&self, shape: &[usize]) -> Result<Array<T>, ArrayError>;
    fn resize(&self, shape: &[usize]) -> Result<Array<T>, ArrayError>;
    fn unique(&self, axis: Option<isize>) -> Result<Array<T>, ArrayError>;
    fn ravel(&self) -> Result<Array<T>, ArrayError>;
    fn atleast(&self, n: usize) -> Result<Array<T>, ArrayError>;
    fn trim_zeros(&self) -> Result<Array<T>, ArrayError>;
    fn cycle_take(&self, n: usize) -> Result<Array<T>, ArrayError>;
}

ArrayTrait - Array Manipulate functions

Required Methods

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

Insert values along the given axis for the given indices

Arguments

• index - indices before which values is inserted
• values - vector representing values to insert into array
• axis - axis along which to insert values. if None, then array is flattened first

Examples

use arr_rs::prelude::*;

let arr = Array::new(vec![1., 2., 3., 4.], vec![4]).insert(&[1], &Array::single(1.).unwrap(), None);
assert_eq!(array!(f64, [1., 1., 2., 3., 4.]), arr);
let arr = Array::new(vec![1., 2., 3., 4.], vec![4]).insert(&[1, 3], &Array::single(1.).unwrap(), None);
assert_eq!(array!(f64, [1., 1., 2., 3., 1., 4.]), arr);

Errors

may returns ArrayError

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

Delete values along the given axis

Arguments

• indices - vector representing values to delete from array
• axis - axis along which to find unique values. if None, then array is flattened first

Examples

use arr_rs::prelude::*;

let arr = Array::new(vec![1., 2., 3., 4.], vec![4]).delete(&[1], None);
assert_eq!(array!(f64, [1., 3., 4.]), arr);
let arr = Array::new(vec![1., 2., 3., 4.], vec![4]).delete(&[2, 3], None);
assert_eq!(array!(f64, [1., 2.]), arr);

Errors

may returns ArrayError

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

Append values to the end of an array

Arguments

• values - vector representing values to append to array
• axis - axis along which to append values. if None, then array is flattened first

Examples

use arr_rs::prelude::*;

let arr = Array::new(vec![1., 2., 3., 4.], vec![4]).append(&Array::single(1.).unwrap(), None);
assert_eq!(array!(f64, [1., 2., 3., 4., 1.]), arr);
let arr = Array::new(vec![1., 2., 3., 4.], vec![4]).append(&Array::flat(vec![1., 3.]).unwrap(), None);
assert_eq!(array!(f64, [1., 2., 3., 4., 1., 3.]), arr);

Errors

may returns ArrayError

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

Reshapes an array

Arguments

• shape - vector representing new array shape

Examples

use arr_rs::prelude::*;

let arr: Array<f64> = Array::new(vec![1., 2., 3., 4.], vec![4]).unwrap();
assert_eq!(array!(f64, [1., 2., 3., 4.]).unwrap(), arr);
let arr = arr.reshape(&[2, 2]);
assert_eq!(array!(f64, [[1., 2.], [3., 4.]]), arr);

Errors

may returns ArrayError

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

Resizes an array,

Arguments

• shape - vector representing new array shape

Examples

use arr_rs::prelude::*;

let arr = Array::new(vec![1., 2., 3., 4.], vec![4]);
assert_eq!(array!(f64, [1, 2, 3, 4]), arr);
let array = arr.resize(&[2, 2]);
assert_eq!(array!(f64, [[1, 2], [3, 4]]), array);
let array = arr.resize(&[4]);
assert_eq!(array!(f64, [1, 2, 3, 4]), array);
let array = arr.resize(&[8]);
assert_eq!(array!(f64, [1, 2, 3, 4, 1, 2, 3, 4]), array);

Errors

may returns ArrayError

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

Find the unique elements of an array

Arguments

• axis - the axis along which to split. optional, if None, array will be flattened

Examples

use arr_rs::prelude::*;

let arr = Array::new(vec![1, 1, 2, 3, 3, 4], vec![6]).unwrap();
assert_eq!(array!(i32, [1, 2, 3, 4]), arr.unique(None));
let arr = Array::new(vec![1, 2, 3, 2, 1], vec![5]).unwrap();
assert_eq!(array!(i32, [1, 2, 3]), arr.unique(None));

Errors

may returns ArrayError

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

Return a contiguous flattened array

Examples

use arr_rs::prelude::*;

let expected = vec![8];

let arr_1 = Array::new(vec![1,2,3,4,5,6,7,8], vec![2, 4]).unwrap();
assert_eq!(expected, arr_1.ravel().get_shape().unwrap());

let arr_2 = Array::new(vec![1,2,3,4,5,6,7,8], vec![4, 2]).unwrap();
assert_eq!(expected, arr_2.ravel().get_shape().unwrap());

let arr_3 = Array::new(vec![1,2,3,4,5,6,7,8], vec![2, 2, 2]).unwrap();
assert_eq!(expected, arr_3.ravel().get_shape().unwrap());

Errors

may returns ArrayError

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

Convert array to at least n dimension

Arguments

• n - desired dimension

Examples

use arr_rs::prelude::*;

let arr = Array::new(vec![1], vec![1]).unwrap();
assert_eq!(array!(i32, [[1]]), arr.atleast(2));
assert_eq!(array!(i32, [[[1]]]), arr.atleast(3));

Errors

may returns ArrayError

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

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

Examples

use arr_rs::prelude::*;

let arr = Array::flat(vec![0, 0, 1, 2, 3, 4, 0, 0]);
assert_eq!(array!(i32, [1, 2, 3, 4]), arr.trim_zeros());

Errors

may returns ArrayError

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

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

Arguments

n: number of elements to take

Examples

use arr_rs::prelude::*;

let arr = Array::flat(vec![1, 2, 3, 4]);
assert_eq!(array!(i32, [1, 2]), arr.cycle_take(2));

Errors

may returns ArrayError

Implementations on Foreign Types

impl<T: ArrayElement> ArrayManipulate<T> for Result<Array<T>, ArrayError>

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

fn delete(&self, indices: &[usize], axis: Option<usize>) -> Self

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

fn reshape(&self, shape: &[usize]) -> Self

fn resize(&self, shape: &[usize]) -> Self

fn unique(&self, axis: Option<isize>) -> Self

fn ravel(&self) -> Self

fn atleast(&self, n: usize) -> Self

fn trim_zeros(&self) -> Self

fn cycle_take(&self, n: usize) -> Self

Implementors

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