Struct VecKind

pub struct VecKind {}

Arrays backed by a Vec<T>.

Trait Implementations

impl<T: Clone + PartialEq> Array<VecKind, T> for VecArray<T>

fn get_range<R: RangeBounds<usize>>(&self, rb: R) -> &[T]

Get a contiguous subrange of the array

use open_hypergraphs::array::{*, vec::*};
let v = VecArray(vec![0, 1, 2, 3, 4]);
assert_eq!(v.get_range(..), &[0, 1, 2, 3, 4]);
assert_eq!(v.get_range(..v.len()), &[0, 1, 2, 3, 4]);

fn scatter(&self, idx: &[usize], n: usize) -> VecArray<T>

Scatter values over the specified indices self[idx[i]] = v[i].

use open_hypergraphs::array::{*, vec::*};
let idx = VecArray(vec![2, 1, 0, 2]);
let v = VecArray(vec![0, 2, 1, 2]);

let expected = VecArray(vec![1, 2, 2]);

let actual = v.scatter(idx.get_range(..), 3);
assert_eq!(actual, expected);

fn empty() -> Self

The empty array

fn len(&self) -> usize

Length of an array

fn concatenate(&self, other: &Self) -> Self

Concatenate two arrays

fn fill(x: T, n: usize) -> Self

fill(x, n) returns the array length n containing repeated element x.

fn get(&self, i: usize) -> T

Retrieve a single element by its index.

fn set_range<R: RangeBounds<usize>>( &mut self, rb: R, v: &<VecKind as ArrayKind>::Type<T>, )

Write to a contiguous range of data in an array

fn gather(&self, idx: &[usize]) -> Self

Gather elements of this array according to the indices. https://en.wikipedia.org/wiki/Gather/scatter_(vector_addressing)#Gather

fn from_slice(slice: &[T]) -> Self

fn scatter_assign_constant(&mut self, ixs: &VecArray<usize>, arg: T)

Numpy self[ixs] = arg

fn scatter_assign(&mut self, ixs: &<VecKind as ArrayKind>::Index, values: Self)

fn is_empty(&self) -> bool

Test if an array is empty

fn to_range<R: RangeBounds<K::I>>(&self, r: R) -> Range<K::I>

Clamp any R: RangeBounds<K::I> into the range of valid indices for this array.

impl ArrayKind for VecKind

type Type<T> = VecArray<T>

The type of arrays containing elements type T

type I = usize

The type of index elements. For super::vec::VecKind, this is usize.

type Index = VecArray<usize>

Arrays of indices (isomorphic to Type<I>) must implement NaturalArray

type Slice<'a, T: 'a> = &'a [T]

a Slice is a read-only view into another array’s data. For VecKind this is &[T].

impl AsMut<<VecKind as ArrayKind>::Index> for VecArray<usize>

fn as_mut(&mut self) -> &mut <VecKind as ArrayKind>::Index

Converts this type into a mutable reference of the (usually inferred) input type.

impl AsRef<<VecKind as ArrayKind>::Index> for VecArray<usize>

fn as_ref(&self) -> &<VecKind as ArrayKind>::Index

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for VecKind

fn clone(&self) -> VecKind

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for VecKind

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

Formats the value using the given formatter.

impl NaturalArray<VecKind> for VecArray<usize>

fn quot_rem(&self, d: usize) -> (Self, Self)

let x = VecArray(vec![0, 1, 2, 3, 4, 5]);
let d = 3;
let expected_q = VecArray(vec![0, 0, 0, 1, 1, 1]);
let expected_r = VecArray(vec![0, 1, 2, 0, 1, 2]);
let (q, r) = x.quot_rem(d);
assert_eq!(expected_q, q);
assert_eq!(expected_r, r);

fn cumulative_sum(&self) -> Self

let input = VecArray(vec![1, 2, 3, 4]);
let expected = VecArray(vec![0, 1, 3, 6, 10]);

assert_eq!(input.cumulative_sum(), expected);

fn repeat(&self, x: &[usize]) -> VecArray<usize>

let repeats: VecArray<usize> = VecArray(vec![1, 2, 0, 3]);
let values: &[usize] = &[5, 6, 7, 8];
let actual = repeats.repeat(values);
let expected = VecArray::<usize>(vec![5, 6, 6, 8, 8, 8]);
assert_eq!(actual, expected);

fn max(&self) -> Option<usize>

fn mul_constant_add(&self, c: usize, x: &Self) -> Self

Compute self * c + x, where c is a constant (scalar) and x is an array.

fn arange(start: &usize, stop: &usize) -> Self

Indices from start to stop

fn connected_components( sources: &Self, targets: &Self, n: usize, ) -> (Self, <VecKind as ArrayKind>::I)

Compute the connected components of a graph with n nodes. Edges are stored as a pair of arrays of nodes (sources, targets) meaning that for each i there is an edge sources[i] → targets[i].

fn bincount(&self, size: usize) -> VecArray<usize>

Count occurrences of each value in the range [0, size)

fn zero(&self) -> VecArray<usize>

Return indices of elements which are zero

fn sparse_bincount(&self) -> (VecArray<usize>, VecArray<usize>)

Compute index of unique values and their counts

fn scatter_sub_assign(&mut self, ixs: &VecArray<usize>, rhs: &VecArray<usize>)

Compute self[ixs] -= rhs

fn sum(&self) -> K::I

fn segmented_sum(&self, x: &Self) -> Self

Segmented sum of input. For example, for self = [1 2 0], self.segmented_sum([1 | 2 3]) = [1 5 0].

fn segmented_arange(&self) -> Self

Given an array of sizes compute the concatenation of arange arrays of each size.

impl<T: Ord + Clone> OrdArray<VecKind, T> for VecArray<T>

fn argsort(&self) -> VecArray<usize>

let values: VecArray<usize> = VecArray(vec![1, 2, 0, 3]);
let actual: VecArray<usize> = values.argsort();
let expected = VecArray::<usize>(vec![2, 0, 1, 3]);
assert_eq!(actual, expected);

// Check monotonicity
let monotonic = values.gather(actual.as_slice());
for i in 0..(monotonic.len()-1) {
    assert!(monotonic[i] <= monotonic[i+1]);
}

fn sort_by(&self, key: &Self) -> Self

Sort this array by the given keys

impl PartialEq for VecKind

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl Eq for VecKind

impl StructuralPartialEq for VecKind