Struct Array 

pub struct Array<I: Index, T> { /* private fields */ }

A dense array of Ts indexed by I.

Implementations

impl<I: Index, T> Array<I, T>

pub fn new(size: impl Isomorphic<I::Size>, items: impl Into<Box<[T]>>) -> Self

Constructs an Array of size size given its elements.

use multidimension::{Index, Array};
let a: Array<(usize, bool), f32> = Array::new(3, [0.0, 1.0, -1.0, 2.0, 3.0, -2.0]);
assert_eq!(a[(0, false)], 0.0);
assert_eq!(a[(0, true)], 1.0);
assert_eq!(a[(1, false)], -1.0);
assert_eq!(a[(1, true)], 2.0);
assert_eq!(a[(2, false)], 3.0);
assert_eq!(a[(2, true)], -2.0);

pub fn from_fn(size: impl Isomorphic<I::Size>, f: impl FnMut(I) -> T) -> Self

Construct an Array of size size from a function.

Consider also fn_view().

use multidimension::{Index, Array};
let a: Array<usize, _> = Array::from_fn(10, |x| x % 3 == 0);
assert_eq!(a.as_ref(), [true, false, false, true, false, false, true, false, false, true]);

pub fn to_raw(self) -> Box<[T]>

Returns the raw array elements.

pub fn iso<J>(self) -> Array<J, T>

where J: Isomorphic<I> + Index, J::Size: Isomorphic<<I as Index>::Size>,

Change the index type of this array without moving any of the items.

Trait Implementations

impl<RHS: View, I: Index, T> Add<RHS> for Array<I, T>

where Self: View, <Self as View>::I: Broadcast<RHS::I>, <Self as View>::T: Add<RHS::T>,

type Output = Zip<Array<I, T>, RHS, Add>

The resulting type after applying the + operator.

fn add(self, other: RHS) -> Self::Output

Performs the + operation.

impl<I: Index, T> AsMut<[T]> for Array<I, T>

fn as_mut(&mut self) -> &mut [T]

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

impl<I: Index, T> AsRef<[T]> for Array<I, T>

fn as_ref(&self) -> &[T]

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

impl<RHS: View, I: Index, T> BitAnd<RHS> for Array<I, T>

where Self: View, <Self as View>::I: Broadcast<RHS::I>, <Self as View>::T: BitAnd<RHS::T>,

type Output = Zip<Array<I, T>, RHS, BitAnd>

The resulting type after applying the & operator.

fn bitand(self, other: RHS) -> Self::Output

Performs the & operation.

impl<RHS: View, I: Index, T> BitOr<RHS> for Array<I, T>

where Self: View, <Self as View>::I: Broadcast<RHS::I>, <Self as View>::T: BitOr<RHS::T>,

type Output = Zip<Array<I, T>, RHS, BitOr>

The resulting type after applying the | operator.

fn bitor(self, other: RHS) -> Self::Output

Performs the | operation.

impl<RHS: View, I: Index, T> BitXor<RHS> for Array<I, T>

where Self: View, <Self as View>::I: Broadcast<RHS::I>, <Self as View>::T: BitXor<RHS::T>,

type Output = Zip<Array<I, T>, RHS, BitXor>

The resulting type after applying the ^ operator.

fn bitxor(self, other: RHS) -> Self::Output

Performs the ^ operation.

impl<I: Clone + Index, T: Clone> Clone for Array<I, T>

where I::Size: Clone,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<I: Debug + Index, T: Debug> Debug for Array<I, T>

where I::Size: Debug,

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

Formats the value using the given formatter.

impl<RHS: View, I: Index, T> Div<RHS> for Array<I, T>

where Self: View, <Self as View>::I: Broadcast<RHS::I>, <Self as View>::T: Div<RHS::T>,

type Output = Zip<Array<I, T>, RHS, Div>

The resulting type after applying the / operator.

fn div(self, other: RHS) -> Self::Output

Performs the / operation.

impl<I: Index, T> Index<<Array<I, T> as View>::I> for Array<I, T>

where Self: ViewRef,

type Output = <Array<I, T> as View>::T

The returned type after indexing.

fn index(&self, index: <Self as View>::I) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<I: Index, T> IndexMut<<Array<I, T> as View>::I> for Array<I, T>

where Self: ViewMut,

fn index_mut(&mut self, index: <Self as View>::I) -> &mut Self::Output

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

impl<RHS: View, I: Index, T> Mul<RHS> for Array<I, T>

where Self: View, <Self as View>::I: Broadcast<RHS::I>, <Self as View>::T: Mul<RHS::T>,

type Output = Zip<Array<I, T>, RHS, Mul>

The resulting type after applying the * operator.

fn mul(self, other: RHS) -> Self::Output

Performs the * operation.

impl<I: Index, T: Clone> NewView for Array<I, T>

type Buffer = Vec<T>

The type of a partially constructed Self.

fn new_view(size: I::Size, callback: impl FnOnce(&mut Self::Buffer)) -> Self

Construct a Self of size size.

impl<RHS: View, I: Index, T> Rem<RHS> for Array<I, T>

where Self: View, <Self as View>::I: Broadcast<RHS::I>, <Self as View>::T: Rem<RHS::T>,

type Output = Zip<Array<I, T>, RHS, Rem>

The resulting type after applying the % operator.

fn rem(self, other: RHS) -> Self::Output

Performs the % operation.

impl<RHS: View, I: Index, T> Shl<RHS> for Array<I, T>

where Self: View, <Self as View>::I: Broadcast<RHS::I>, <Self as View>::T: Shl<RHS::T>,

type Output = Zip<Array<I, T>, RHS, Shl>

The resulting type after applying the << operator.

fn shl(self, other: RHS) -> Self::Output

Performs the << operation.

impl<RHS: View, I: Index, T> Shr<RHS> for Array<I, T>

where Self: View, <Self as View>::I: Broadcast<RHS::I>, <Self as View>::T: Shr<RHS::T>,

type Output = Zip<Array<I, T>, RHS, Shr>

The resulting type after applying the >> operator.

fn shr(self, other: RHS) -> Self::Output

Performs the >> operation.

impl<RHS: View, I: Index, T> Sub<RHS> for Array<I, T>

where Self: View, <Self as View>::I: Broadcast<RHS::I>, <Self as View>::T: Sub<RHS::T>,

type Output = Zip<Array<I, T>, RHS, Sub>

The resulting type after applying the - operator.

fn sub(self, other: RHS) -> Self::Output

Performs the - operation.

impl<I: Index, T: Clone> View for Array<I, T>

type I = I

The index type.

type T = T

The element type.

fn size(&self) -> I::Size

The size of the array.

fn len(&self) -> usize

The number of elements in Self.

fn at(&self, index: I) -> T

Compute the element at index.

fn collect<A>(&self) -> A

where A: NewView<I = Self::I, T = Self::T>,

Materialises this View into a collection of type A, e.g. an Array.

fn nested(self) -> Nested<Self>

where Self: ViewRef, Self::T: View, <<Self::T as View>::I as Index>::Size: Isomorphic<()>,

Creates a View that represents this nested View.

fn nested_collect<A>(self, size: <<Self::T as View>::I as Index>::Size) -> A

where Self::T: View, A: NewView<I = (Self::I, <Self::T as View>::I), T = <Self::T as View>::T>,

Materialises this nested View into a collection of type A, e.g. an Array.

fn each(self, f: impl FnMut(Self::T))

Apply f to every element of this View in turn.

fn enumerate(self) -> Enumerate<Self>

Creates a View with the same Index type as self such that at(i) returns (i, self.at(i)).

fn diagonal(self, zero: Self::T) -> Diagonal<Self>

Returns a View that maps (i, i) to t when Self maps i to t. It maps (i, j) to zero if i != j.

fn map<U: Clone, F>(self, f: F) -> Map<Self, F>

where F: Fn(Self::T) -> U,

Creates a View that applies f to the elements of Self.

fn compose<V: View<I = Self::T>>(self, other: V) -> Compose<Self, V>

Creates a View that uses self to select elements of other.

fn concat<V: View<T = Self::T>, I: Index, J: Index>( self, other: V, ) -> Concat<Self, V, I, J>

where Self::I: Isomorphic<(I, usize, J)>, <Self::I as Index>::Size: Isomorphic<(I::Size, usize, J::Size)>, V::I: Isomorphic<(I, usize, J)>, <V::I as Index>::Size: Isomorphic<(I::Size, usize, J::Size)>,

Concatenates self with other along an axis of type usize.

fn from_usize<I: Index, X: Index, J: Index>( self, from_length: impl FnOnce(usize) -> X::Size, ) -> FromUsize<Self, I, X, J>

where Self::I: Isomorphic<(I, usize, J)>, <Self::I as Index>::Size: Isomorphic<<(I, usize, J) as Index>::Size>,

Replace an axis Indexed by usize with one indexed by X.

fn to_usize<I: Index, X: Index, J: Index>(self) -> ToUsize<Self, I, X, J>

where Self::I: Isomorphic<(I, X, J)>, <Self::I as Index>::Size: Isomorphic<<(I, X, J) as Index>::Size>,

Replace an axis Indexed by X with one indexed by usize.

fn insert_one<I: Index, J: Index, K: Index>( self, size: J::Size, ) -> InsertOne<Self, I, J, K>

where Self::I: Isomorphic<(I, K)>, <Self::I as Index>::Size: Isomorphic<(I::Size, K::Size)>,

Insert an axis of type J and length 1.

fn remove_one<I: Index, J: Index, K: Index>(self) -> RemoveOne<Self, I, J, K>

where Self::I: Isomorphic<(I, J, K)>, <Self::I as Index>::Size: Isomorphic<(I::Size, J::Size, K::Size)>,

Remove an axis of type J and length 1.

fn map_axis<I: Index, V: View, J: Index>( self, other: V, ) -> MapAxis<Self, I, V, J>

where V::T: Index, Self::I: Isomorphic<(I, V::T, J)>, <Self::I as Index>::Size: Isomorphic<(I::Size, <V::T as Index>::Size, J::Size)>,

Creates a view such that at((i, x, j)) gives self.at((i, other.at(x), j)).

fn zip<V: View>(self, other: V) -> Zip<Self, V, Pair>

where Self::I: Broadcast<V::I>,

Creates a View that pairs of an element of self and an element of other.

fn binary<V: View, B>(self, other: V) -> Zip<Self, V, B>

where Self::I: Broadcast<V::I>, B: Binary<Self::T, V::T>,

Creates a View that pairs of an element of self and an element of other, then applies binary operator B.

fn coat<I>(self) -> Coat<Self, I>

where I: Coat<Self::I> + Index, Self::I: Coat<I>, I::Size: Coat<<Self::I as Index>::Size>, <Self::I as Index>::Size: Coat<I::Size>,

Wrap some of the Indexes of this View in Coated.

fn iso<J>(self) -> Iso<Self, J>

where J: Isomorphic<Self::I> + Index, J::Size: Isomorphic<<Self::I as Index>::Size>,

Change the index type of this View to an Isomorphic type.

fn transpose<I: Index, X: Index, Y: Index, J: Index>( self, ) -> Transpose<Self, I, X, Y, J>

where (I, (Y, X), J): Isomorphic<Self::I>, (I::Size, (Y::Size, X::Size), J::Size): Isomorphic<<Self::I as Index>::Size>,

Reorder the indices of this View up to Isomorphic.

fn row<I: Index, J: Index>(self, i: I) -> Row<Self, I, J>

where (I, J): Isomorphic<Self::I>, (I::Size, J::Size): Isomorphic<<Self::I as Index>::Size>,

Returns a View whose at(j) returns self.at(i, j).

fn rows<I: Index, J: Index>(&self) -> Rows<&Self, I, J>

where (I, J): Isomorphic<Self::I>, (I::Size, J::Size): Isomorphic<<Self::I as Index>::Size>,

Returns a View whose at(i) returns self.row(i).

fn column<I: Index, J: Index>(self, j: J) -> Column<Self, I, J>

where (I, J): Isomorphic<Self::I>, (I::Size, J::Size): Isomorphic<<Self::I as Index>::Size>,

Returns a View whose at(i) returns self.at(i, j).

fn columns<I: Index, J: Index>(&self) -> Columns<&Self, I, J>

where (I, J): Isomorphic<Self::I>, (I::Size, J::Size): Isomorphic<<Self::I as Index>::Size>,

Returns a View whose at(j) returns self.column(j).

impl<I: Index, T: Clone> ViewMut for Array<I, T>

fn at_mut(&mut self, index: Self::I) -> &mut Self::T

Mutably borrow the element at index.

impl<I: Index, T: Clone> ViewRef for Array<I, T>

fn at_ref(&self, index: Self::I) -> &Self::T

Borrow the element at index.