Crate multidimension

A pure-Rust library providing high-level manipulation of multi-dimensional arrays.

Array<I, T> represents an array of T indexed by I. The T values are internally stored in a [Box<[T]>], which is a dense 1-dimensional representation. The purpose of the Array wrapper is to look like a multi-dimensional collection. To achieve this, the index type I can be any type that implements Index. This includes scalar types such as usize and bool, but also tuples of other types that implement Index. You are encouraged to write your own index types.

Trait View is the main way to access and manipulate Arrays. Unlike Array, a View doesn’t store anything, but instead computes values on demand. In this respect it is a bit like std::iter::Iterator, and indeed View offers some of the same methods as Iterator, including View::map(), View::zip() and View::collect(). However, unlike Iterator, Views are immutable; getting values using View::at() does not mutate the View. You are encouraged to use Views compositionally, like Iterators, and to collect() the results into an Array only at the end of a chain of operations.

All types in this crate which implement View (including Array) define all of Rust’s arithmetic operators (+, * etc.) to mean pointwise arithmetic on the elements. When applied to Views with different Index types, elements are replicated as necessary using a Broadcast rule, similarly to NumPy.

Indexes are often tuples or nested tuples. Trait Isomorphic defines conversions between different tuple structures. For example, ((A,), B, C) implements Isomorphic<(A, (B, C))>. Methods of View exploit tuple isomorphism to ergonomically express which groups of Indexes to apply operations to. The main thing you can’t do with tuple isomorphism is to reorder the Indexes; for this you need to use View::transpose(). Either way, the code to manipulate the array indices is all automatically generated at compile-time, and should mostly be optimized away by the compiler.

Re-exports

• pub use view::Push;
• pub use view::NewView;
• pub use view::View;
• pub use view::ViewRef;
• pub use view::ViewMut;
• pub use view::Scalar;
• pub use view::fn_view;

Modules

• int
  A variety of Indexes and Views based on usize.
• ops
  Generic programming over binary arithmetic operators.
• view

Macros

• impl_memoryview
  A helper macro for implementing ViewRef and ViewMut.
• impl_op_for_view
  Implement one of the std::ops traits for a type that implements View.
• impl_ops_for_memoryview
  A helper macro for implementing std::ops::Index and std::ops::IndexMut in terms of [View] and [ViewMut].
• impl_ops_for_view
  Implement all of the std::ops traits for a type that implements View. The implementations call View::binary().

Structs

• All
  The return type of Index::all().
• Array
  A dense array of Ts indexed by I.
• Coated
  Coated<I> behaves like I in most respects, but implements NonTuple.

Traits

• Broadcast
  Self implements Broadcast<Other> to say what happens when you zip a View indexed by Self with one indexed by Other.
• Coat
  Implemented by types that differ from T by adding or removing at most one level of Coated.
• Index
  Implemented by types that can be used as an index for an Array.
• Isomorphic
  Relates two types if they have the same canonical form.
• NonTuple
  Implemented by types that have no tuple-like structure.
• Size
  The run-time size of an array axis. An array axis with a compile-time constant size can simply use (), which implements this trait.
• StaticIndex
  Implemented by types that can be used as an index for an Array and where the size of the Array is a compile-time constant.