Crate ndarray

source ·
Expand description

The ndarray crate provides an n-dimensional container for general elements and for numerics.

In n-dimensional we include, for example, 1-dimensional rows or columns, 2-dimensional matrices, and higher dimensional arrays. If the array has n dimensions, then an element in the array is accessed by using that many indices. Each dimension is also called an axis.

  • ArrayBase: The n-dimensional array type itself.
    It is used to implement both the owned arrays and the views; see its docs for an overview of all array features.
  • The main specific array type is Array, which owns its elements.

§Highlights

  • Generic n-dimensional array
  • Slicing, also with arbitrary step size, and negative indices to mean elements from the end of the axis.
  • Views and subviews of arrays; iterators that yield subviews.
  • Higher order operations and arithmetic are performant
  • Array views can be used to slice and mutate any [T] data using ArrayView::from and ArrayViewMut::from.
  • Zip for lock step function application across two or more arrays or other item producers (NdProducer trait).

§Crate Status

  • Still iterating on and evolving the crate

    • The crate is continuously developing, and breaking changes are expected during evolution from version to version. We adopt the newest stable rust features if we need them.
    • Note that functions/methods/traits/etc. hidden from the docs are not considered part of the public API, so changes to them are not considered breaking changes.
  • Performance:

    • Prefer higher order methods and arithmetic operations on arrays first, then iteration, and as a last priority using indexed algorithms.
    • The higher order functions like .map(), .map_inplace(), .zip_mut_with(), Zip and azip!() are the most efficient ways to perform single traversal and lock step traversal respectively.
    • Performance of an operation depends on the memory layout of the array or array view. Especially if it’s a binary operation, which needs matching memory layout to be efficient (with some exceptions).
    • Efficient floating point matrix multiplication even for very large matrices; can optionally use BLAS to improve it further.
  • MSRV: Requires Rust 1.64 or later

§Crate Feature Flags

The following crate feature flags are available. They are configured in your Cargo.toml. See doc::crate_feature_flags for more information.

  • std: Rust standard library-using functionality (enabled by default)
  • serde: serialization support for serde 1.x
  • rayon: Parallel iterators, parallelized methods, the parallel module and par_azip!.
  • approx Implementations of traits from the approx crate.
  • blas: transparent BLAS support for matrix multiplication, needs configuration.
  • matrixmultiply-threading: Use threading from matrixmultiply.

§Documentation

  • The docs for ArrayBase provide an overview of the n-dimensional array type. Other good pages to look at are the documentation for the s![] and azip!() macros.

  • If you have experience with NumPy, you may also be interested in ndarray_for_numpy_users.

§The ndarray ecosystem

ndarray provides a lot of functionality, but it’s not a one-stop solution.

ndarray includes matrix multiplication and other binary/unary operations out of the box. More advanced linear algebra routines (e.g. SVD decomposition or eigenvalue computation) can be found in ndarray-linalg.

The same holds for statistics: ndarray provides some basic functionalities (e.g. mean) but more advanced routines can be found in ndarray-stats.

If you are looking to generate random arrays instead, check out ndarray-rand.

For conversion between ndarray, nalgebra and image check out nshare.

Re-exports§

  • pub use crate::slice::SliceNextDim;
  • pub use crate::layout::Layout;

Modules§

  • Standalone documentation pages.
  • Producers, iterables and iterators.
  • Linear algebra.
  • Parallelization features for ndarray.
  • ndarray prelude.

Macros§

  • Create an Array with one, two, three, four, five, or six dimensions.
  • Array zip macro: lock step function application across several arrays and producers.
  • Concatenate arrays along the given axis.
  • Parallelized array zip macro: lock step function application across several arrays and producers.
  • Slice argument constructor.
  • Stack arrays along the new axis.

Structs§

  • An n-dimensional array.
  • An axis index.
  • Description of the axis, its length and its stride.
  • Dimension description.
  • Dynamic dimension or index type.
  • An iterator of a sequence of evenly spaced floats.
  • An iterator of a sequence of logarithmically spaced number.
  • A transparent wrapper of Cell<T> which is identical in every way, except it will implement arithmetic operators as well.
  • Token to represent a new axis in a slice description.
  • ArcArray’s representation.
  • Array’s representation.
  • Array pointer’s representation.
  • A contiguous array shape of n dimensions.
  • An error related to array shape or layout.
  • A slice (range with step size).
  • Represents all of the necessary information to perform a slice.
  • An array shape of n dimensions in c-order, f-order or custom strides.
  • Array view’s representation.
  • Lock step function application across several arrays or other producers.

Enums§

  • CowArray’s representation.
  • Error code for an error related to array shape or layout.
  • Value controlling the execution of .fold_while on Zip.
  • Array order
  • A slice (range with step), an index, or a new axis token.

Traits§

  • Argument conversion into an array view
  • A producer element that can be assigned to once
  • Array representation trait.
  • Array representation trait.
  • Array representation trait.
  • Array representation trait.
  • Adds the two dimensions at compile time.
  • Array shape and index trait.
  • Extra indexing methods for array views
  • Argument conversion a dimension.
  • Argument conversion into a producer.
  • Elements that support linear algebra operations.
  • Slicing information describing multiple mutable, disjoint slices.
  • Floating-point element types f32 and f64.
  • Tuple or fixed size arrays that can be used to index an array.
  • A producer of an n-dimensional set of elements; for example an array view, mutable array view or an iterator that yields chunks.
  • Array representation trait.
  • Array representation trait.
  • Array representation trait.
  • Array representation trait.
  • Array shape with a next smaller dimension.
  • Elements that can be used as direct operands in arithmetic with arrays.
  • Array shape argument with optional order parameter
  • A trait for Shape and D where D: Dimension that allows customizing the memory layout (strides) of an array shape.
  • A type that can slice an array of dimension D.

Functions§

  • Create a new dimension value.
  • Create a zero-dimensional index
  • Create a one-dimensional index
  • Create a two-dimensional index
  • Create a three-dimensional index
  • Create a four-dimensional index
  • Create a five-dimensional index
  • Create a six-dimensional index
  • Create a dynamic-dimensional index
  • Create a zero-dimensional array with the element x.
  • Create a one-dimensional array with elements from xs.
  • Create a two-dimensional array with elements from xs.
  • Create a three-dimensional array with elements from xs.
  • Create a zero-dimensional array view borrowing x.
  • Create a one-dimensional array view with elements borrowing xs.
  • Create a two-dimensional array view with elements borrowing xs.
  • Create a one-dimensional read-write array view with elements borrowing xs.
  • Create a two-dimensional read-write array view with elements borrowing xs.
  • Concatenate arrays along the given axis.
  • Create an iterable of the array shape shape.
  • Return an iterable of the indices of the passed-in array.
  • Return an iterator of evenly spaced floats.
  • An iterator of a sequence of logarithmically spaced numbers.
  • Return an iterator of floats from a to b (exclusive), incrementing by step.
  • Create a one-dimensional array with elements from xs.
  • Create a two-dimensional array with elements from xs.
  • Create a three-dimensional array with elements from xs.
  • Stack arrays along the new axis.

Type Aliases§