Trait arr_rs::core::operations::manipulate::ArrayManipulate

source · 
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>;
}
Expand description

ArrayTrait - Array Manipulate functions

Required Methods§

source

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);
source

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);
source

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);
source

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);
source

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);
source

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));
source

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());
source

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));
source

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());
source

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));

Implementations on Foreign Types§

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

Implementors§