Trait arr_rs::base::base_array::ArrayBase

source · 
pub trait ArrayBase<N: Numeric>where
    Self: Sized + Clone + Display + FromIterator<N> + IntoIterator<Item = N>,{

Show 27 methods    // Required methods
    fn new(elements: Vec<N>, shape: Vec<usize>) -> Self;
    fn flat(elements: Vec<N>) -> Self;
    fn rand(shape: Vec<usize>) -> Self;
    fn empty() -> Self;
    fn zeros(shape: Vec<usize>) -> Self;
    fn ones(shape: Vec<usize>) -> Self;
    fn reshape(&self, shape: Vec<usize>) -> Self;
    fn product(&self) -> N;
    fn sum(&self) -> N;
    fn ndim(&self) -> usize;
    fn len(&self) -> usize;
    fn is_empty(&self) -> bool;
    fn get_elements(&self) -> Vec<N>;
    fn get_shape(&self) -> Vec<usize>;
    fn index(&self, coords: &[usize]) -> usize;
    fn at(&self, coords: &[usize]) -> N;
    fn slice(&self, range: Range<usize>) -> Self;
    fn ravel(&self) -> Self;
    fn for_each<F: FnMut(&N)>(&self, f: F);
    fn for_each_e<F: FnMut(usize, &N)>(&self, f: F);
    fn map<F: FnMut(&N) -> N>(&self, f: F) -> Self;
    fn map_e<F: FnMut(usize, &N) -> N>(&self, f: F) -> Self;
    fn filter<F: FnMut(&N) -> bool>(&self, f: F) -> Self;
    fn filter_e<F: FnMut(usize, &N) -> bool>(&self, f: F) -> Self;
    fn filter_map<F: FnMut(&N) -> Option<N>>(&self, f: F) -> Self;
    fn filter_map_e<F: FnMut(usize, &N) -> Option<N>>(&self, f: F) -> Self;
    fn fold<F: FnMut(&N, &N) -> N>(&self, init: N, f: F) -> N;

}
Expand description

Base Array structure

Required Methods§

source

fn new(elements: Vec<N>, shape: Vec<usize>) -> Self

Creates new array

Arguments
  • elements - vector representing array elements
  • shape - vector representing array elements
Examples
use arr_rs::prelude::*;

let arr = Array::new(vec![1, 2, 3, 4], vec![4]);
assert_eq!("[1, 2, 3, 4]", format!("{arr}"));

let arr = Array::new(vec![1, 2, 3, 4], vec![2, 2]);
assert_eq!("[[1, 2], [3, 4]]", format!("{arr}"));
assert_eq!("[[1, 2], \n [3, 4]]", format!("{arr:#}"));
source

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

Creates new flat array

Arguments
  • elements - vector representing array elements
Examples
use arr_rs::prelude::*;

let arr = Array::flat(vec![1, 2, 3, 4]);
assert_eq!("[1, 2, 3, 4]", format!("{arr}"));
source

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

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

Arguments
  • shape - vector representing array elements
Examples
use arr_rs::prelude::*;

let arr = Array::<f64>::rand(vec![4]);
assert_eq!(4, arr.len());

let arr = Array::<f64>::rand(vec![4, 4, 4]);
assert_eq!(64, arr.len());
source

fn empty() -> Self

Creates new empty array

Examples
use arr_rs::prelude::*;

let arr: Array<f64> = Array::empty();
assert_eq!("[]", format!("{arr}"));
source

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

Creates new array of zeros

Arguments
  • shape - vector representing array elements
Examples
use arr_rs::prelude::*;

let arr: Array<f64> = Array::zeros(vec![4]);
assert_eq!("[0, 0, 0, 0]", format!("{arr}"));
source

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

Creates new array of ones

Arguments
  • shape - vector representing array shape
Examples
use arr_rs::prelude::*;

let arr: Array<f64> = Array::ones(vec![4]);
assert_eq!("[1, 1, 1, 1]", format!("{arr}"));
source

fn reshape(&self, shape: Vec<usize>) -> Self

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]);
assert_eq!("[1, 2, 3, 4]", format!("{arr}"));
let arr = arr.reshape(vec![2, 2]);
assert_eq!("[[1, 2], [3, 4]]", format!("{arr}"));
source

fn product(&self) -> N

Multiplication of array elements

Examples
use arr_rs::prelude::*;

let arr = Array::new(vec![1,2,3,4], vec![4]);
let multiplied = arr.product();
assert_eq!(24, multiplied);
source

fn sum(&self) -> N

Sum of array elements

Examples
use arr_rs::prelude::*;

let arr = Array::new(vec![1,2,3,4], vec![4]);
let sum = arr.sum();
assert_eq!(10, sum);
source

fn ndim(&self) -> usize

Count of array dimensions

Examples
use arr_rs::prelude::*;

let arr_1 = Array::new(vec![1,2,3,4], vec![4]);
let ndim_1 = arr_1.ndim();
assert_eq!(1, ndim_1);

let arr_2 = Array::new(vec![1,2,3,4], vec![2, 2]);
let ndim_2 = arr_2.ndim();
assert_eq!(2, ndim_2);
source

fn len(&self) -> usize

Count of array elements

Examples
use arr_rs::prelude::*;

let arr = Array::new(vec![1,2,3,4], vec![4]);
let len = arr.len();
assert_eq!(4, len);
source

fn is_empty(&self) -> bool

Check if array element count equals zero

Examples
use arr_rs::prelude::*;

let arr_1 = Array::new(vec![1,2,3,4], vec![4]);
let empty_1 = arr_1.is_empty();
assert_eq!(false, empty_1);

let arr_2: Array<f64> = Array::empty();
let empty_2 = arr_2.is_empty();
assert_eq!(true, empty_2);
source

fn get_elements(&self) -> Vec<N>

Obtain the vector containing array elements

Examples
use arr_rs::prelude::*;

let arr = Array::new(vec![1,2,3,4], vec![4]);
assert_eq!(vec![1, 2, 3, 4], arr.get_elements());
source

fn get_shape(&self) -> Vec<usize>

Obtain the vector containing array shape

Examples
use arr_rs::prelude::*;

let arr = Array::new(vec![1,2,3,4], vec![4]);
assert_eq!(vec![4], arr.get_shape());
source

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

Return an index of element at the given coordinates

Arguments
  • coords - vector representing the coordinates of the element in array
Examples
use arr_rs::prelude::*;

let arr = Array::new(vec![1,2,3,4,5,6,7,8], vec![2, 2, 2]);

let idx_1 = arr.index(&[0, 0, 0]);
assert_eq!(0, idx_1);

let idx_2 = arr.index(&[1, 0, 1]);
assert_eq!(5, idx_2);

let idx_3 = arr.index(&[1, 1, 1]);
assert_eq!(7, idx_3);
source

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

Return an index of element at the given coordinates

Arguments
  • coords - vector representing the coordinates of the element in array
Examples
use arr_rs::prelude::*;

let arr = Array::new(vec![1,2,3,4,5,6,7,8], vec![2, 2, 2]);

let at_1 = arr.at(&[0, 0, 0]);
assert_eq!(1, at_1);

let at_2 = arr.at(&[1, 0, 1]);
assert_eq!(6, at_2);

let at_3 = arr.at(&[1, 1, 1]);
assert_eq!(8, at_3);
source

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

Return a subarray of provided range

Arguments
  • range - starting and ending indices of elements to include in the subarray
Examples
use arr_rs::prelude::*;

let arr = Array::<i32>::new(vec![1,2,3,4,5,6,7,8], vec![8]);
let expected = Array::<i32>::new(vec![1,2,3,4], vec![4]);
let slice_1 = arr.slice(0..4);
assert_eq!(format!("{expected}"), format!("{slice_1}"));

let arr = Array::<i32>::new(vec![1,2,3,4,5,6,7,8], vec![2, 4]);
let expected = Array::<i32>::new(vec![1,2,3,4], vec![4]);
let slice_1 = arr.slice(0..1);
assert_eq!(format!("{expected}"), format!("{slice_1}"));
source

fn ravel(&self) -> Self

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]);
assert_eq!(expected, arr_1.ravel().get_shape());

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

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

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

Loop over array elements

Arguments
  • f - function to be called on each array element
Examples
use arr_rs::prelude::*;

let arr = Array::new(vec![1,2,3,4,5,6,7,8], vec![2, 4]);
arr.for_each(|item| println!("{item}"));
source

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

Loop over enumerated array elements

Arguments
  • f - function to be called on each array element
Examples
use arr_rs::prelude::*;

let arr = Array::new(vec![1,2,3,4,5,6,7,8], vec![2, 4]);
arr.for_each_e(|idx, item| println!("{idx}:{item}"));
source

fn map<F: FnMut(&N) -> N>(&self, f: F) -> Self

Map over array elements

Arguments
  • f - function to be called on each array element
Examples
use arr_rs::prelude::*;

let arr: Array<i32> = Array::new(vec![1,2,3,4,5,6,7,8], vec![2, 4]);
arr.map(|item| item * 2);
source

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

Map over enumerated array elements

Arguments
  • f - function to be called on each array element
Examples
use arr_rs::prelude::*;

let arr: Array<i32> = Array::new(vec![1,2,3,4,5,6,7,8], vec![2, 4]);
arr.map_e(|idx, item| item * idx as i32);
source

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

Filter over array elements Returns a flat filtered array

Arguments
  • f - function to be called on each array element
Examples
use arr_rs::prelude::*;

let arr: Array<i32> = Array::new(vec![1,2,3,4,5,6,7,8], vec![2, 4]);
arr.filter(|item| item % 2 == 0);
source

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

Filter over enumerated array elements Returns a flat filtered array

Arguments
  • f - function to be called on each array element
Examples
use arr_rs::prelude::*;

let arr: Array<i32> = Array::new(vec![1,2,3,4,5,6,7,8], vec![2, 4]);
arr.filter_e(|idx, item| item % (idx + 1) as i32 == 0);
source

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

Filter and map over array elements Returns a flat filtered array

Arguments
  • f - function to be called on each array element
Examples
use arr_rs::prelude::*;

let arr: Array<i32> = Array::new(vec![1,2,3,4,5,6,7,8], vec![2, 4]);
arr.filter_map(|item| if item % 2 == 0 { Some(*item) } else { None });
source

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

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

Arguments
  • f - function to be called on each array element
Examples
use arr_rs::prelude::*;

let arr: Array<i32> = Array::new(vec![1,2,3,4,5,6,7,8], vec![2, 4]);
arr.filter_map_e(|idx, item| if item % (idx + 1) as i32 == 0 { Some(*item) } else { None });
source

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

Fold elements of array elements

Arguments
  • f - function to be called on each array element
Examples
use arr_rs::prelude::*;

let arr: Array<i32> = Array::new(vec![1,2,3,4,5,6,7,8], vec![2, 4]);
arr.fold(0, |a, b| a + b);
arr.fold(1, |a, b| a * b);

Implementors§

source§

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