Crate ndarray [−] [src]
The ndarray crate provides an N-dimensional container for general elements
and for numerics.
ArrayBase: The N-dimensional array type itself.Array: An array where the data is owned uniquely.RcArray: An array where the data has shared ownership and is copy on write.ArrayView,ArrayViewMut: Lightweight array views.
Highlights
- Generic N-dimensional array
 - Slicing, also with arbitrary step size, and negative indices to mean elements from the end of the axis.
 - There is both a copy on write array (
RcArray), or a regular uniquely owned array (Array), and both can use read-only and read-write array views. - Iteration and most operations are efficient on arrays with contiguous innermost dimension.
 - Array views can be used to slice and mutate any 
[T]data usingArrayView::fromandArrayViewMut::from. 
Crate Status
- Still iterating on and evolving the API
- The crate is continuously developing, and breaking changes are expected during evolution from version to version. We adhere to semver, but alpha releases break at will.
 - We adopt the newest stable rust features we need.
 
 - Performance status:
- 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).
 - Arithmetic optimizes very well if the arrays are have contiguous inner dimension.
 - The higher order functions like 
.map(),.map_inplace()and.zip_mut_with()are the most efficient ways to perform single traversal and lock step traversal respectively. .iter()is efficient for c-contiguous arrays.- Can use BLAS in matrix multiplication.
 
 
Crate Feature Flags
The following crate feature flags are available. They are configured in your
Cargo.toml.
rustc-serialize- Optional, compatible with Rust stable
 - Enables serialization support for rustc-serialize 0.3
 
serde- Optional, compatible with Rust stable
 - Enables serialization support for serde 0.8
 
blas- Optional and experimental, compatible with Rust stable
 - Enable transparent BLAS support for matrix multiplication. Pluggable
backend via 
blas-sys. 
Modules
| linalg | 
                                 Linear algebra.  | 
                       
| prelude | 
                                 ndarray prelude.  | 
                       
Macros
| s | 
                                 Slice argument constructor.  | 
                       
| stack | 
                                 Stack arrays along the given axis.  | 
                       
Structs
| ArrayBase | 
                                 An N-dimensional array.  | 
                       
| Axis | 
                                 An axis index.  | 
                       
| AxisChunksIter | 
                                 An iterator that traverses over the specified axis and yields views of the specified size on this axis.  | 
                       
| AxisChunksIterMut | 
                                 An iterator that traverses over the specified axis and yields mutable views of the specified size on this axis.  | 
                       
| AxisIter | 
                                 An iterator that traverses over an axis and and yields each subview.  | 
                       
| AxisIterMut | 
                                 An iterator that traverses over an axis and and yields each subview (mutable)  | 
                       
| Elements | 
                                 An iterator over the elements of an array.  | 
                       
| ElementsMut | 
                                 An iterator over the elements of an array (mutable).  | 
                       
| Indexed | 
                                 An iterator over the indexes and elements of an array.  | 
                       
| IndexedMut | 
                                 An iterator over the indexes and elements of an array (mutable).  | 
                       
| Indexes | 
                                 An iterator over the indexes of an array shape.  | 
                       
| InnerIter | 
                                 An iterator that traverses over all dimensions but the innermost, and yields each inner row.  | 
                       
| InnerIterMut | 
                                 An iterator that traverses over all dimensions but the innermost, and yields each inner row (mutable).  | 
                       
| Shape | 
                                 A contiguous array shape of n dimensions.  | 
                       
| ShapeError | 
                                 An error related to array shape or layout.  | 
                       
| Si | 
                                 A slice, a description of a range of an array axis.  | 
                       
| StrideShape | 
                                 An array shape of n dimensions c-order, f-order or custom strides.  | 
                       
| ViewRepr | 
                                 Array view’s representation.  | 
                       
Enums
| ErrorKind | 
                                 Error code for an error related to array shape or layout.  | 
                       
Constants
| S | 
                                 Slice value for the full range of an axis.  | 
                       
Traits
| AsArray | 
                                 Argument conversion into an array view  | 
                       
| Data | 
                                 Array representation trait.  | 
                       
| DataClone | 
                                 Array representation trait.  | 
                       
| DataMut | 
                                 Array representation trait.  | 
                       
| DataOwned | 
                                 Array representation trait.  | 
                       
| DataShared | 
                                 Array representation trait.  | 
                       
| Dimension | 
                                 Array shape and index trait.  | 
                       
| FixedInitializer | 
                                 Fixed-size array used for array initialization  | 
                       
| LinalgScalar | 
                                 Elements that support linear algebra operations.  | 
                       
| NdFloat | 
                                 Floating-point element types   | 
                       
| NdIndex | 
                                 Tuple or fixed size arrays that can be used to index an array.  | 
                       
| RemoveAxis | 
                                 Array shape with a next smaller dimension.  | 
                       
| ScalarOperand | 
                                 Elements that can be used as direct operands in arithmetic with arrays.  | 
                       
| ShapeBuilder | 
                                 A trait for   | 
                       
Functions
| arr0 | 
                                 Create a zero-dimensional array with the element   | 
                       
| arr1 | 
                                 Create a one-dimensional array with elements from   | 
                       
| arr2 | 
                                 Create a two-dimensional array with elements from   | 
                       
| arr3 | 
                                 Create a three-dimensional array with elements from   | 
                       
| aview0 | 
                                 Create a zero-dimensional array view borrowing   | 
                       
| aview1 | 
                                 Create a one-dimensional array view with elements borrowing   | 
                       
| aview2 | 
                                 Create a two-dimensional array view with elements borrowing   | 
                       
| aview_mut1 | 
                                 Create a one-dimensional read-write array view with elements borrowing   | 
                       
| rcarr1 | 
                                 Create a one-dimensional array with elements from   | 
                       
| rcarr2 | 
                                 Create a two-dimensional array with elements from   | 
                       
| rcarr3 | 
                                 Create a three-dimensional array with elements from   | 
                       
| stack | 
                                 Stack arrays along the given axis.  | 
                       
Type Definitions
| Array | 
                                 Array where the data is owned uniquely.  | 
                       
| Array0 | 
                                 zero-dimensional array  | 
                       
| Array1 | 
                                 one-dimensional array  | 
                       
| Array2 | 
                                 two-dimensional array  | 
                       
| Array3 | 
                                 three-dimensional array  | 
                       
| Array4 | 
                                 four-dimensional array  | 
                       
| ArrayD | 
                                 dynamic-dimensional array  | 
                       
| ArrayView | 
                                 A lightweight array view.  | 
                       
| ArrayView0 | 
                                 zero-dimensional array view  | 
                       
| ArrayView1 | 
                                 one-dimensional array view  | 
                       
| ArrayView2 | 
                                 two-dimensional array view  | 
                       
| ArrayView3 | 
                                 three-dimensional array view  | 
                       
| ArrayView4 | 
                                 four-dimensional array view  | 
                       
| ArrayViewD | 
                                 dynamic-dimensional array view  | 
                       
| ArrayViewMut | 
                                 A lightweight read-write array view.  | 
                       
| ArrayViewMut0 | 
                                 zero-dimensional read-write array view  | 
                       
| ArrayViewMut1 | 
                                 one-dimensional read-write array view  | 
                       
| ArrayViewMut2 | 
                                 two-dimensional read-write array view  | 
                       
| ArrayViewMut3 | 
                                 three-dimensional read-write array view  | 
                       
| ArrayViewMut4 | 
                                 four-dimensional read-write array view  | 
                       
| ArrayViewMutD | 
                                 dynamic-dimensional read-write array view  | 
                       
| Ix | 
                                 Array index type  | 
                       
| Ix0 | 
                                 zero-dimensionial  | 
                       
| Ix1 | 
                                 one-dimensional  | 
                       
| Ix2 | 
                                 two-dimensional  | 
                       
| Ix3 | 
                                 three-dimensional  | 
                       
| Ix4 | 
                                 four-dimensional  | 
                       
| IxDyn | 
                                 dynamic-dimensional  | 
                       
| Ixs | 
                                 Array index type (signed)  | 
                       
| OwnedArray | 
                               [Deprecated]  Array where the data is owned uniquely.  | 
                       
| RcArray | 
                                 Array where the data is reference counted and copy on write, it can act as both an owner as the data as well as a lightweight view.  |