Struct ndarray::ArrayBase

source ·

pub struct ArrayBase<S, D>where
    S: Data,{ /* private fields */ }

Expand description

An n-dimensional array.

The array is a general container of elements. It cannot grow or shrink, but can be sliced into subsets of its data. The array supports arithmetic operations by applying them elementwise.

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 is accessed by using that many indices.

The ArrayBase<S, D> is parameterized by S for the data container and D for the dimensionality.

Type aliases Array, ArcArray, ArrayView, and ArrayViewMut refer to ArrayBase with different types for the data container.

Array
ArcArray
Array Views
Indexing and Dimension
Loops, Producers and Iterators
Slicing
Subviews
Arithmetic Operations
Broadcasting
Conversions
Constructor Methods for Owned Arrays
Methods For All Array Types
Methods For 1-D Arrays
Methods For 2-D Arrays
Methods for Dynamic-Dimensional Arrays
Numerical Methods for Arrays

`Array`

Array is an owned array that owns the underlying array elements directly (just like a Vec) and it is the default way to create and store n-dimensional data. Array<A, D> has two type parameters: A for the element type, and D for the dimensionality. A particular dimensionality’s type alias like Array3<A> just has the type parameter A for element type.

An example:

// Create a three-dimensional f64 array, initialized with zeros
use ndarray::Array3;
let mut temperature = Array3::<f64>::zeros((3, 4, 5));
// Increase the temperature in this location
temperature[[2, 2, 2]] += 0.5;

`ArcArray`

ArcArray is an owned array with reference counted data (shared ownership). Sharing requires that it uses copy-on-write for mutable operations. Calling a method for mutating elements on ArcArray, for example view_mut() or get_mut(), will break sharing and require a clone of the data (if it is not uniquely held).

Array Views

ArrayView and ArrayViewMut are read-only and read-write array views respectively. They use dimensionality, indexing, and almost all other methods the same was as the other array types.

Methods for ArrayBase apply to array views too, when the trait bounds allow.

Please see the documentation for the respective array view for an overview of methods specific to array views: ArrayView, ArrayViewMut.

A view is created from an array using .view(), .view_mut(), using slicing (.slice(), .slice_mut()) or from one of the many iterators that yield array views.

You can also create an array view from a regular slice of data not allocated with Array — see array view methods or their From impls.

Note that all ArrayBase variants can change their view (slicing) of the data freely, even when their data can’t be mutated.

Indexing and Dimension

The dimensionality of the array determines the number of axes, for example a 2D array has two axes. These are listed in “big endian” order, so that the greatest dimension is listed first, the lowest dimension with the most rapidly varying index is the last.

In a 2D array the index of each element is [row, column] as seen in this 4 × 3 example:

[[ [0, 0], [0, 1], [0, 2] ],  // row 0
 [ [1, 0], [1, 1], [1, 2] ],  // row 1
 [ [2, 0], [2, 1], [2, 2] ],  // row 2
 [ [3, 0], [3, 1], [3, 2] ]]  // row 3
//    \       \       \
//   column 0  \     column 2
//            column 1

The number of axes for an array is fixed by its D type parameter: Ix1 for a 1D array, Ix2 for a 2D array etc. The dimension type IxDyn allows a dynamic number of axes.

A fixed size array ([usize; N]) of the corresponding dimensionality is used to index the Array, making the syntax array[[ i, j, …]]

use ndarray::Array2;
let mut array = Array2::zeros((4, 3));
array[[1, 1]] = 7;

Important traits and types for dimension and indexing:

A Dim value represents a dimensionality or index.
Trait Dimension is implemented by all dimensionalities. It defines many operations for dimensions and indices.
Trait IntoDimension is used to convert into a Dim value.
Trait ShapeBuilder is an extension of IntoDimension and is used when constructing an array. A shape describes not just the extent of each axis but also their strides.
Trait NdIndex is an extension of Dimension and is for values that can be used with indexing syntax.

The default memory order of an array is row major order (a.k.a “c” order), where each row is contiguous in memory. A column major (a.k.a. “f” or fortran) memory order array has columns (or, in general, the outermost axis) with contiguous elements.

The logical order of any array’s elements is the row major order (the rightmost index is varying the fastest). The iterators .iter(), .iter_mut() always adhere to this order, for example.

Loops, Producers and Iterators

Using Zip is the most general way to apply a procedure across one or several arrays or producers.

NdProducer is like an iterable but for multidimensional data. All producers have dimensions and axes, like an array view, and they can be split and used with parallelization using Zip.

For example, ArrayView<A, D> is a producer, it has the same dimensions as the array view and for each iteration it produces a reference to the array element (&A in this case).

Another example, if we have a 10 × 10 array and use .exact_chunks((2, 2)) we get a producer of chunks which has the dimensions 5 × 5 (because there are 10 / 2 = 5 chunks in either direction). The 5 × 5 chunks producer can be paired with any other producers of the same dimension with Zip, for example 5 × 5 arrays.

`.iter()` and `.iter_mut()`

These are the element iterators of arrays and they produce an element sequence in the logical order of the array, that means that the elements will be visited in the sequence that corresponds to increasing the last index first: 0, …, 0, 0; 0, …, 0, 1; 0, …0, 2 and so on.

`.outer_iter()` and `.axis_iter()`

These iterators produce array views of one smaller dimension.

For example, for a 2D array, .outer_iter() will produce the 1D rows. For a 3D array, .outer_iter() produces 2D subviews.

.axis_iter() is like outer_iter() but allows you to pick which axis to traverse.

The outer_iter and axis_iter are one dimensional producers.

`.genrows()`, `.gencolumns()` and `.lanes()`

.genrows() is a producer (and iterable) of all rows in an array.

use ndarray::Array;

// 1. Loop over the rows of a 2D array
let mut a = Array::zeros((10, 10));
for mut row in a.genrows_mut() {
    row.fill(1.);
}

// 2. Use Zip to pair each row in 2D `a` with elements in 1D `b`
use ndarray::Zip;
let mut b = Array::zeros(a.rows());

Zip::from(a.genrows())
    .and(&mut b)
    .apply(|a_row, b_elt| {
        *b_elt = a_row[a.cols() - 1] - a_row[0];
    });

The lanes of an array are 1D segments along an axis and when pointed along the last axis they are rows, when pointed along the first axis they are columns.

A m × n array has m rows each of length n and conversely n columns each of length m.

To generalize this, we say that an array of dimension a × m × n has a m rows. It’s composed of a times the previous array, so it has a times as many rows.

All methods: .genrows(), .genrows_mut(), .gencolumns(), .gencolumns_mut(), .lanes(axis), .lanes_mut(axis).

Yes, for 2D arrays .genrows() and .outer_iter() have about the same effect:

genrows() is a producer with n - 1 dimensions of 1 dimensional items
outer_iter() is a producer with 1 dimension of n - 1 dimensional items

Slicing

You can use slicing to create a view of a subset of the data in the array. Slicing methods include .slice(), .slice_mut(), .slice_move(), and .slice_collapse().

The slicing argument can be passed using the macro s![], which will be used in all examples. (The explicit form is an instance of &SliceInfo; see its docs for more information.)

If a range is used, the axis is preserved. If an index is used, that index is selected and the axis is removed; this selects a subview. See Subviews for more information about subviews. Note that .slice_collapse() behaves like .collapse_axis() by preserving the number of dimensions.

// import the s![] macro
#[macro_use(s)]
extern crate ndarray;

use ndarray::{arr2, arr3};

fn main() {

// 2 submatrices of 2 rows with 3 elements per row, means a shape of `[2, 2, 3]`.

let a = arr3(&[[[ 1,  2,  3],     // -- 2 rows  \_
                [ 4,  5,  6]],    // --         /
               [[ 7,  8,  9],     //            \_ 2 submatrices
                [10, 11, 12]]]);  //            /
//  3 columns ..../.../.../

assert_eq!(a.shape(), &[2, 2, 3]);

// Let’s create a slice with
//
// - Both of the submatrices of the greatest dimension: `..`
// - Only the first row in each submatrix: `0..1`
// - Every element in each row: `..`

let b = a.slice(s![.., 0..1, ..]);
let c = arr3(&[[[ 1,  2,  3]],
               [[ 7,  8,  9]]]);
assert_eq!(b, c);
assert_eq!(b.shape(), &[2, 1, 3]);

// Let’s create a slice with
//
// - Both submatrices of the greatest dimension: `..`
// - The last row in each submatrix: `-1..`
// - Row elements in reverse order: `..;-1`
let d = a.slice(s![.., -1.., ..;-1]);
let e = arr3(&[[[ 6,  5,  4]],
               [[12, 11, 10]]]);
assert_eq!(d, e);
assert_eq!(d.shape(), &[2, 1, 3]);

// Let’s create a slice while selecting a subview with
//
// - Both submatrices of the greatest dimension: `..`
// - The last row in each submatrix, removing that axis: `-1`
// - Row elements in reverse order: `..;-1`
let f = a.slice(s![.., -1, ..;-1]);
let g = arr2(&[[ 6,  5,  4],
               [12, 11, 10]]);
assert_eq!(f, g);
assert_eq!(f.shape(), &[2, 3]);
}

Subviews

Subview methods allow you to restrict the array view while removing one axis from the array. Methods for selecting individual subviews include .index_axis(), .index_axis_mut(), .index_axis_move(), and .index_axis_inplace(). You can also select a subview by using a single index instead of a range when slicing. Some other methods, such as .fold_axis(), .axis_iter(), .axis_iter_mut(), .outer_iter(), and .outer_iter_mut() operate on all the subviews along an axis.

A related method is .collapse_axis(), which modifies the view in the same way as .index_axis() except for removing the collapsed axis, since it operates in place. The length of the axis becomes 1.

Methods for selecting an individual subview take two arguments: axis and index.

#[macro_use(s)] extern crate ndarray;

use ndarray::{arr3, aview1, aview2, Axis};


// 2 submatrices of 2 rows with 3 elements per row, means a shape of `[2, 2, 3]`.

let a = arr3(&[[[ 1,  2,  3],    // \ axis 0, submatrix 0
                [ 4,  5,  6]],   // /
               [[ 7,  8,  9],    // \ axis 0, submatrix 1
                [10, 11, 12]]]); // /
        //        \
        //         axis 2, column 0

assert_eq!(a.shape(), &[2, 2, 3]);

// Let’s take a subview along the greatest dimension (axis 0),
// taking submatrix 0, then submatrix 1

let sub_0 = a.index_axis(Axis(0), 0);
let sub_1 = a.index_axis(Axis(0), 1);

assert_eq!(sub_0, aview2(&[[ 1,  2,  3],
                           [ 4,  5,  6]]));
assert_eq!(sub_1, aview2(&[[ 7,  8,  9],
                           [10, 11, 12]]));
assert_eq!(sub_0.shape(), &[2, 3]);

// This is the subview picking only axis 2, column 0
let sub_col = a.index_axis(Axis(2), 0);

assert_eq!(sub_col, aview2(&[[ 1,  4],
                             [ 7, 10]]));

// You can take multiple subviews at once (and slice at the same time)
let double_sub = a.slice(s![1, .., 0]);
assert_eq!(double_sub, aview1(&[7, 10]));

Arithmetic Operations

Arrays support all arithmetic operations the same way: they apply elementwise.

Since the trait implementations are hard to overview, here is a summary.

Binary Operators with Two Arrays

Let A be an array or view of any kind. Let B be an array with owned storage (either Array or ArcArray). Let C be an array with mutable data (either Array, ArcArray or ArrayViewMut). The following combinations of operands are supported for an arbitrary binary operator denoted by @ (it can be +, -, *, / and so on).

&A @ &A which produces a new Array
B @ A which consumes B, updates it with the result, and returns it
B @ &A which consumes B, updates it with the result, and returns it
C @= &A which performs an arithmetic operation in place

Binary Operators with Array and Scalar

The trait ScalarOperand marks types that can be used in arithmetic with arrays directly. For a scalar K the following combinations of operands are supported (scalar can be on either the left or right side, but ScalarOperand docs has the detailed condtions).

&A @ K or K @ &A which produces a new Array
B @ K or K @ B which consumes B, updates it with the result and returns it
C @= K which performs an arithmetic operation in place

Unary Operators

Let A be an array or view of any kind. Let B be an array with owned storage (either Array or ArcArray). The following operands are supported for an arbitrary unary operator denoted by @ (it can be - or !).

@&A which produces a new Array
@B which consumes B, updates it with the result, and returns it

Broadcasting

Arrays support limited broadcasting, where arithmetic operations with array operands of different sizes can be carried out by repeating the elements of the smaller dimension array. See .broadcast() for a more detailed description.

use ndarray::arr2;

let a = arr2(&[[1., 1.],
               [1., 2.],
               [0., 3.],
               [0., 4.]]);

let b = arr2(&[[0., 1.]]);

let c = arr2(&[[1., 2.],
               [1., 3.],
               [0., 4.],
               [0., 5.]]);
// We can add because the shapes are compatible even if not equal.
// The `b` array is shape 1 × 2 but acts like a 4 × 2 array.
assert!(
    c == a + b
);

Conversions

Conversions Between Array Types

This table is a summary of the conversions between arrays of different ownership, dimensionality, and element type. All of the conversions in this table preserve the shape of the array.

Output	Input
Output	`Array<A, D>`	`ArcArray<A, D>`	`ArrayView<'a, A, D>`	`ArrayViewMut<'a, A, D>`
`Array<A, D>`	no-op	`a.into_owned()`	`a.to_owned()`	`a.to_owned()`
`ArcArray<A, D>`	`a.into_shared()`	no-op	`a.to_owned().into_shared()`	`a.to_owned().into_shared()`
`ArrayView<'b, A, D>`	`a.view()`	`a.view()`	`a.view()` or `a.reborrow()`	`a.view()`
`ArrayViewMut<'b, A, D>`	`a.view_mut()`	`a.view_mut()`	illegal	`a.view_mut()` or `a.reborrow()`
equivalent with dim `D2` (e.g. converting from dynamic dim to const dim)	`a.into_dimensionality::<D2>()`
equivalent with dim `IxDyn`	`a.into_dyn()`
`Array<B, D>` (new element type)	`a.map(\|x\| x.do_your_conversion())`

Conversions Between Arrays and `Vec`s/Slices/Scalars

This is a table of the safe conversions between arrays and Vecs/slices/scalars. Note that some of the return values are actually Result/Option wrappers around the indicated output types.

Input	Output	Methods
`Vec<A>`	`ArrayBase<S: DataOwned, Ix1>`	`::from_vec()`
`Vec<A>`	`ArrayBase<S: DataOwned, D>`	`::from_shape_vec()`
`&[A]`	`ArrayView1<A>`	`::from()`
`&[A]`	`ArrayView<A, D>`	`::from_shape()`
`&mut [A]`	`ArrayViewMut1<A>`	`::from()`
`&mut [A]`	`ArrayViewMut<A, D>`	`::from_shape()`
`&ArrayBase<S, Ix1>`	`Vec<A>`	`.to_vec()`
`Array<A, D>`	`Vec<A>`	`.into_raw_vec()`¹
`&ArrayBase<S, D>`	`&[A]`	`.as_slice()`², `.as_slice_memory_order()`³
`&mut ArrayBase<S: DataMut, D>`	`&mut [A]`	`.as_slice_mut()`², `.as_slice_memory_order_mut()`³
`ArrayView<A, D>`	`&[A]`	`.into_slice()`
`ArrayViewMut<A, D>`	`&mut [A]`	`.into_slice()`
`Array0<A>`	`A`	`.into_scalar()`

¹Returns the data in memory order.

²Works only if the array is contiguous and in standard order.

³Works only if the array is contiguous.

The table above does not include all the constructors; it only shows conversions to/from Vecs/slices. See below for more constructors.

Struct ndarray::ArrayBase

Implementations§

impl<S, A> ArrayBase<S, Ix1>where S: DataOwned<Elem = A>,

pub fn from_vec(v: Vec<A>) -> Self

pub fn from_iter<I>(iterable: I) -> Selfwhere I: IntoIterator<Item = A>,

pub fn linspace(start: A, end: A, n: usize) -> Selfwhere A: Float,

pub fn range(start: A, end: A, step: A) -> Selfwhere A: Float,

impl<S, A> ArrayBase<S, Ix2>where S: DataOwned<Elem = A>,

pub fn eye(n: Ix) -> Selfwhere S: DataMut, A: Clone + Zero + One,

impl<S, A, D> ArrayBase<S, D>where S: DataOwned<Elem = A>, D: Dimension,

pub fn from_elem<Sh>(shape: Sh, elem: A) -> Selfwhere A: Clone, Sh: ShapeBuilder<Dim = D>,

pub fn zeros<Sh>(shape: Sh) -> Selfwhere A: Clone + Zero, Sh: ShapeBuilder<Dim = D>,

pub fn ones<Sh>(shape: Sh) -> Selfwhere A: Clone + One, Sh: ShapeBuilder<Dim = D>,

pub fn default<Sh>(shape: Sh) -> Selfwhere A: Default, Sh: ShapeBuilder<Dim = D>,

pub fn from_shape_fn<Sh, F>(shape: Sh, f: F) -> Selfwhere Sh: ShapeBuilder<Dim = D>, F: FnMut(D::Pattern) -> A,

pub fn from_shape_vec<Sh>(shape: Sh, v: Vec<A>) -> Result<Self, ShapeError>where Sh: Into<StrideShape<D>>,

pub unsafe fn from_shape_vec_unchecked<Sh>(shape: Sh, v: Vec<A>) -> Selfwhere Sh: Into<StrideShape<D>>,

pub unsafe fn uninitialized<Sh>(shape: Sh) -> Selfwhere A: Copy, Sh: ShapeBuilder<Dim = D>,

impl<A, S, D> ArrayBase<S, D>where S: Data<Elem = A>, D: Dimension,

pub fn len(&self) -> usize

pub fn len_of(&self, axis: Axis) -> usize

pub fn is_empty(&self) -> bool

pub fn ndim(&self) -> usize

pub fn dim(&self) -> D::Pattern

pub fn raw_dim(&self) -> D

pub fn shape(&self) -> &[Ix]

pub fn strides(&self) -> &[Ixs]

pub fn stride_of(&self, axis: Axis) -> isize

pub fn view(&self) -> ArrayView<'_, A, D>

pub fn view_mut(&mut self) -> ArrayViewMut<'_, A, D>where S: DataMut,

pub fn to_owned(&self) -> Array<A, D>where A: Clone,

pub fn to_shared(&self) -> ArcArray<A, D>where A: Clone,

pub fn into_owned(self) -> Array<A, D>where A: Clone,

pub fn into_shared(self) -> ArcArray<A, D>where S: DataOwned,

pub fn first(&self) -> Option<&A>

pub fn first_mut(&mut self) -> Option<&mut A>where S: DataMut,

pub fn iter(&self) -> Iter<'_, A, D> ⓘ

pub fn iter_mut(&mut self) -> IterMut<'_, A, D> ⓘwhere S: DataMut,

pub fn indexed_iter(&self) -> IndexedIter<'_, A, D> ⓘ

pub fn indexed_iter_mut(&mut self) -> IndexedIterMut<'_, A, D> ⓘwhere S: DataMut,

pub fn slice<Do>( &self, info: &SliceInfo<D::SliceArg, Do>) -> ArrayView<'_, A, Do>where Do: Dimension,

pub fn slice_mut<Do>( &mut self, info: &SliceInfo<D::SliceArg, Do>) -> ArrayViewMut<'_, A, Do>where Do: Dimension, S: DataMut,

pub fn slice_move<Do>( self, info: &SliceInfo<D::SliceArg, Do>) -> ArrayBase<S, Do>where Do: Dimension,

pub fn slice_collapse(&mut self, indices: &D::SliceArg)

pub fn slice_inplace(&mut self, indices: &D::SliceArg)

pub fn slice_axis(&self, axis: Axis, indices: Slice) -> ArrayView<'_, A, D>

pub fn slice_axis_mut( &mut self, axis: Axis, indices: Slice) -> ArrayViewMut<'_, A, D>where S: DataMut,

pub fn slice_axis_inplace(&mut self, axis: Axis, indices: Slice)

pub fn get<I>(&self, index: I) -> Option<&A>where I: NdIndex<D>,

pub fn get_mut<I>(&mut self, index: I) -> Option<&mut A>where S: DataMut, I: NdIndex<D>,

pub unsafe fn uget<I>(&self, index: I) -> &Awhere I: NdIndex<D>,

pub unsafe fn uget_mut<I>(&mut self, index: I) -> &mut Awhere S: DataMut, I: NdIndex<D>,

pub fn swap<I>(&mut self, index1: I, index2: I)where S: DataMut, I: NdIndex<D>,

pub unsafe fn uswap<I>(&mut self, index1: I, index2: I)where S: DataMut, I: NdIndex<D>,

pub fn index_axis(&self, axis: Axis, index: usize) -> ArrayView<'_, A, D::Smaller>where D: RemoveAxis,

pub fn index_axis_mut( &mut self, axis: Axis, index: usize) -> ArrayViewMut<'_, A, D::Smaller>where S: DataMut, D: RemoveAxis,

pub fn index_axis_move(self, axis: Axis, index: usize) -> ArrayBase<S, D::Smaller>where D: RemoveAxis,

pub fn collapse_axis(&mut self, axis: Axis, index: usize)

pub fn subview(&self, axis: Axis, index: Ix) -> ArrayView<'_, A, D::Smaller>where D: RemoveAxis,

pub fn subview_mut( &mut self, axis: Axis, index: Ix) -> ArrayViewMut<'_, A, D::Smaller>where S: DataMut, D: RemoveAxis,

pub fn subview_inplace(&mut self, axis: Axis, index: Ix)

pub fn into_subview(self, axis: Axis, index: Ix) -> ArrayBase<S, D::Smaller>where D: RemoveAxis,

pub fn select(&self, axis: Axis, indices: &[Ix]) -> Array<A, D>where A: Copy, D: RemoveAxis,

pub fn genrows(&self) -> Lanes<'_, A, D::Smaller>

pub fn genrows_mut(&mut self) -> LanesMut<'_, A, D::Smaller>where S: DataMut,

pub fn gencolumns(&self) -> Lanes<'_, A, D::Smaller>

pub fn gencolumns_mut(&mut self) -> LanesMut<'_, A, D::Smaller>where S: DataMut,

pub fn lanes(&self, axis: Axis) -> Lanes<'_, A, D::Smaller>

pub fn lanes_mut(&mut self, axis: Axis) -> LanesMut<'_, A, D::Smaller>where S: DataMut,

pub fn outer_iter(&self) -> AxisIter<'_, A, D::Smaller> ⓘwhere D: RemoveAxis,

pub fn outer_iter_mut(&mut self) -> AxisIterMut<'_, A, D::Smaller> ⓘwhere S: DataMut, D: RemoveAxis,

pub fn axis_iter(&self, axis: Axis) -> AxisIter<'_, A, D::Smaller> ⓘwhere D: RemoveAxis,

pub fn axis_iter_mut(&mut self, axis: Axis) -> AxisIterMut<'_, A, D::Smaller> ⓘwhere S: DataMut, D: RemoveAxis,

pub fn axis_chunks_iter( &self, axis: Axis, size: usize) -> AxisChunksIter<'_, A, D> ⓘ

pub fn axis_chunks_iter_mut( &mut self, axis: Axis, size: usize) -> AxisChunksIterMut<'_, A, D> ⓘwhere S: DataMut,

pub fn exact_chunks<E>(&self, chunk_size: E) -> ExactChunks<'_, A, D>where E: IntoDimension<Dim = D>,

pub fn exact_chunks_mut<E>(&mut self, chunk_size: E) -> ExactChunksMut<'_, A, D>where E: IntoDimension<Dim = D>, S: DataMut,

pub fn windows<E>(&self, window_size: E) -> Windows<'_, A, D>where E: IntoDimension<Dim = D>,

pub fn diag(&self) -> ArrayView1<'_, A>

pub fn diag_mut(&mut self) -> ArrayViewMut1<'_, A>where S: DataMut,

impl<S, A> ArrayBase<S, Ix1>where
S: DataOwned<Elem = A>,

pub fn from_iter<I>(iterable: I) -> Selfwhere
I: IntoIterator<Item = A>,

pub fn linspace(start: A, end: A, n: usize) -> Selfwhere
A: Float,

pub fn range(start: A, end: A, step: A) -> Selfwhere
A: Float,

impl<S, A> ArrayBase<S, Ix2>where
S: DataOwned<Elem = A>,

pub fn eye(n: Ix) -> Selfwhere
S: DataMut,
A: Clone + Zero + One,

impl<S, A, D> ArrayBase<S, D>where
S: DataOwned<Elem = A>,
D: Dimension,

pub fn from_elem<Sh>(shape: Sh, elem: A) -> Selfwhere
A: Clone,
Sh: ShapeBuilder<Dim = D>,

pub fn zeros<Sh>(shape: Sh) -> Selfwhere
A: Clone + Zero,
Sh: ShapeBuilder<Dim = D>,

pub fn ones<Sh>(shape: Sh) -> Selfwhere
A: Clone + One,
Sh: ShapeBuilder<Dim = D>,

pub fn default<Sh>(shape: Sh) -> Selfwhere
A: Default,
Sh: ShapeBuilder<Dim = D>,

pub fn from_shape_fn<Sh, F>(shape: Sh, f: F) -> Selfwhere
Sh: ShapeBuilder<Dim = D>,
F: FnMut(D::Pattern) -> A,

pub fn from_shape_vec<Sh>(shape: Sh, v: Vec<A>) -> Result<Self, ShapeError>where
Sh: Into<StrideShape<D>>,

pub unsafe fn from_shape_vec_unchecked<Sh>(shape: Sh, v: Vec<A>) -> Selfwhere
Sh: Into<StrideShape<D>>,

pub unsafe fn uninitialized<Sh>(shape: Sh) -> Selfwhere
A: Copy,
Sh: ShapeBuilder<Dim = D>,

impl<A, S, D> ArrayBase<S, D>where
S: Data<Elem = A>,
D: Dimension,

pub fn view_mut(&mut self) -> ArrayViewMut<'_, A, D>where
S: DataMut,

pub fn to_owned(&self) -> Array<A, D>where
A: Clone,

pub fn to_shared(&self) -> ArcArray<A, D>where
A: Clone,

pub fn into_owned(self) -> Array<A, D>where
A: Clone,

pub fn into_shared(self) -> ArcArray<A, D>where
S: DataOwned,

pub fn first_mut(&mut self) -> Option<&mut A>where
S: DataMut,

pub fn iter_mut(&mut self) -> IterMut<'_, A, D> ⓘwhere
S: DataMut,

pub fn indexed_iter_mut(&mut self) -> IndexedIterMut<'_, A, D> ⓘwhere
S: DataMut,

pub fn slice<Do>(
&self,
info: &SliceInfo<D::SliceArg, Do>
) -> ArrayView<'_, A, Do>where
Do: Dimension,

pub fn slice_mut<Do>(
&mut self,
info: &SliceInfo<D::SliceArg, Do>
) -> ArrayViewMut<'_, A, Do>where
Do: Dimension,
S: DataMut,

pub fn slice_move<Do>(
self,
info: &SliceInfo<D::SliceArg, Do>
) -> ArrayBase<S, Do>where
Do: Dimension,

pub fn slice_axis_mut(
&mut self,
axis: Axis,
indices: Slice
) -> ArrayViewMut<'_, A, D>where
S: DataMut,

pub fn get<I>(&self, index: I) -> Option<&A>where
I: NdIndex<D>,

pub fn get_mut<I>(&mut self, index: I) -> Option<&mut A>where
S: DataMut,
I: NdIndex<D>,

pub unsafe fn uget<I>(&self, index: I) -> &Awhere
I: NdIndex<D>,

pub unsafe fn uget_mut<I>(&mut self, index: I) -> &mut Awhere
S: DataMut,
I: NdIndex<D>,

pub fn swap<I>(&mut self, index1: I, index2: I)where
S: DataMut,
I: NdIndex<D>,

pub unsafe fn uswap<I>(&mut self, index1: I, index2: I)where
S: DataMut,
I: NdIndex<D>,

pub fn index_axis(&self, axis: Axis, index: usize) -> ArrayView<'_, A, D::Smaller>where
D: RemoveAxis,

pub fn index_axis_mut(
&mut self,
axis: Axis,
index: usize
) -> ArrayViewMut<'_, A, D::Smaller>where
S: DataMut,
D: RemoveAxis,

pub fn index_axis_move(self, axis: Axis, index: usize) -> ArrayBase<S, D::Smaller>where
D: RemoveAxis,

pub fn subview(&self, axis: Axis, index: Ix) -> ArrayView<'_, A, D::Smaller>where
D: RemoveAxis,

pub fn subview_mut(
&mut self,
axis: Axis,
index: Ix
) -> ArrayViewMut<'_, A, D::Smaller>where
S: DataMut,
D: RemoveAxis,

pub fn into_subview(self, axis: Axis, index: Ix) -> ArrayBase<S, D::Smaller>where
D: RemoveAxis,

pub fn select(&self, axis: Axis, indices: &[Ix]) -> Array<A, D>where
A: Copy,
D: RemoveAxis,

pub fn genrows_mut(&mut self) -> LanesMut<'_, A, D::Smaller>where
S: DataMut,

pub fn gencolumns_mut(&mut self) -> LanesMut<'_, A, D::Smaller>where
S: DataMut,

pub fn lanes_mut(&mut self, axis: Axis) -> LanesMut<'_, A, D::Smaller>where
S: DataMut,

pub fn outer_iter(&self) -> AxisIter<'_, A, D::Smaller> ⓘwhere
D: RemoveAxis,

pub fn outer_iter_mut(&mut self) -> AxisIterMut<'_, A, D::Smaller> ⓘwhere
S: DataMut,
D: RemoveAxis,

pub fn axis_iter(&self, axis: Axis) -> AxisIter<'_, A, D::Smaller> ⓘwhere
D: RemoveAxis,

pub fn axis_iter_mut(&mut self, axis: Axis) -> AxisIterMut<'_, A, D::Smaller> ⓘwhere
S: DataMut,
D: RemoveAxis,

pub fn axis_chunks_iter(
&self,
axis: Axis,
size: usize
) -> AxisChunksIter<'_, A, D> ⓘ

pub fn axis_chunks_iter_mut(
&mut self,
axis: Axis,
size: usize
) -> AxisChunksIterMut<'_, A, D> ⓘwhere
S: DataMut,

pub fn exact_chunks<E>(&self, chunk_size: E) -> ExactChunks<'_, A, D>where
E: IntoDimension<Dim = D>,

pub fn exact_chunks_mut<E>(&mut self, chunk_size: E) -> ExactChunksMut<'_, A, D>where
E: IntoDimension<Dim = D>,
S: DataMut,

pub fn windows<E>(&self, window_size: E) -> Windows<'_, A, D>where
E: IntoDimension<Dim = D>,

pub fn diag_mut(&mut self) -> ArrayViewMut1<'_, A>where
S: DataMut,

pub fn as_mut_ptr(&mut self) -> *mut Awhere
S: DataMut,

pub fn as_slice_mut(&mut self) -> Option<&mut [A]>where
S: DataMut,

pub fn as_slice_memory_order_mut(&mut self) -> Option<&mut [A]>where
S: DataMut,

pub fn into_shape<E>(self, shape: E) -> Result<ArrayBase<S, E::Dim>, ShapeError>where
E: IntoDimension,

pub fn reshape<E>(&self, shape: E) -> ArrayBase<S, E::Dim>where
S: DataShared + DataOwned,
A: Clone,
E: IntoDimension,

pub fn into_dimensionality<D2>(self) -> Result<ArrayBase<S, D2>, ShapeError>where
D2: Dimension,

pub fn broadcast<E>(&self, dim: E) -> Option<ArrayView<'_, A, E::Dim>>where
E: IntoDimension,

pub fn permuted_axes<T>(self, axes: T) -> ArrayBase<S, D>where
T: IntoDimension<Dim = D>,

pub fn remove_axis(self, axis: Axis) -> ArrayBase<S, D::Smaller>where
D: RemoveAxis,

pub fn assign<E: Dimension, S2>(&mut self, rhs: &ArrayBase<S2, E>)where
S: DataMut,
A: Clone,
S2: Data<Elem = A>,

pub fn fill(&mut self, x: A)where
S: DataMut,
A: Clone,

pub fn zip_mut_with<B, S2, E, F>(&mut self, rhs: &ArrayBase<S2, E>, f: F)where
S: DataMut,
S2: Data<Elem = B>,
E: Dimension,
F: FnMut(&mut A, &B),

pub fn fold<'a, F, B>(&'a self, init: B, f: F) -> Bwhere
F: FnMut(B, &'a A) -> B,
A: 'a,

pub fn map<'a, B, F>(&'a self, f: F) -> Array<B, D>where
F: FnMut(&'a A) -> B,
A: 'a,

pub fn map_mut<'a, B, F>(&'a mut self, f: F) -> Array<B, D>where
F: FnMut(&'a mut A) -> B,
A: 'a,
S: DataMut,

pub fn mapv<B, F>(&self, f: F) -> Array<B, D>where
F: FnMut(A) -> B,
A: Clone,

pub fn mapv_into<F>(self, f: F) -> Selfwhere
S: DataMut,
F: FnMut(A) -> A,
A: Clone,

pub fn map_inplace<F>(&mut self, f: F)where
S: DataMut,
F: FnMut(&mut A),

pub fn mapv_inplace<F>(&mut self, f: F)where
S: DataMut,
F: FnMut(A) -> A,
A: Clone,

pub fn visit<'a, F>(&'a self, f: F)where
F: FnMut(&'a A),
A: 'a,

pub fn fold_axis<B, F>(&self, axis: Axis, init: B, fold: F) -> Array<B, D::Smaller>where
D: RemoveAxis,
F: FnMut(&B, &A) -> B,
B: Clone,

pub fn map_axis<'a, B, F>(
&'a self,
axis: Axis,
mapping: F
) -> Array<B, D::Smaller>where
D: RemoveAxis,
F: FnMut(ArrayView1<'a, A>) -> B,
A: 'a,