Struct ndarray::ArrayBase

pub struct ArrayBase<S, D> where S: Data {
    // some fields omitted
}

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.

The ArrayBase<S, D> is parameterized by: - S for the data container - D for the number of dimensions

Type aliases OwnedArray, RcArray, ArrayView, and ArrayViewMut refer to ArrayBase with different types for the data storage.

OwnedArray and RcArray

OwnedArray owns the underlying array elements directly (just like a Vec), while RcArray is a an array with reference counted data. RcArray can act both as an owner or as a view in that regard. Sharing requires that it uses copy-on-write for mutable operations. Calling a method for mutating elements on RcArray, for example view_mut() or get_mut(), will break sharing and require a clone of the data (if it is not uniquely held).

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

Array indexes are represented by the types Ix and Ixs (signed).

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 3 × 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
//    \       \       \
//   column 0  \     column 2
//            column 1

The number of axes for an array is fixed by the D parameter: Ix for a 1D array, (Ix, Ix) for a 2D array etc. The D type is also used for element indices in .get() and array[index]. The dimension type Vec<Ix> allows a dynamic number of axes.

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

Slicing

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

The slicing argument can be passed using the macro s![], which will be used in all examples. (The explicit form is a reference to a fixed size array of Si; see its docs for more information.)

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

use ndarray::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, ..]);
// without the macro, the explicit argument is `&[S, Si(0, Some(1), 1), S]`

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);
}

Subviews

Subview methods allow you to restrict the array view while removing one axis from the array. Subview methods include .subview(), .isubview(), .subview_mut().

Subview takes two arguments: axis and index.

use ndarray::{arr3, aview2};

// 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.subview(0, 0);
let sub_1 = a.subview(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.subview(2, 0);

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

.isubview() modifies the view in the same way as subview(), but since it is in place, it cannot remove the collapsed axis. It becomes an axis of length 1.

.outer_iter() is an iterator of every subview along the zeroth (outer) axis, while .axis_iter() is an iterator of every subview along a specific axis.

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.

Let A be an array or view of any kind. Let B be a mutable array (that is, either OwnedArray, RcArray, or ArrayViewMut) The following combinations of operands are supported for an arbitrary binary operator denoted by @.

• &A @ &A which produces a new OwnedArray
• 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
• B @= &A which performs an arithmetic operation in place (requires features = "assign_ops")

The trait Scalar 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 side).

• &A @ K or K @ &A which produces a new OwnedArray
• B @ K or K @ B which consumes B, updates it with the result and returns it
• B @= K which performs an arithmetic operation in place (requires features = "assign_ops")

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.]]);
let b = arr2(&[[0., 1.]]);

let c = arr2(&[[1., 2.],
               [1., 3.]]);
// We can add because the shapes are compatible even if not equal.
assert!(
    c == a + b
);

Methods

impl<S> ArrayBase<S, Ix> where S: DataOwned

Constructor methods for one-dimensional arrays.

fn from_vec(v: Vec<S::Elem>) -> ArrayBase<S, Ix>

Create a one-dimensional array from a vector (no allocation needed).

fn from_iter<I: IntoIterator<Item=S::Elem>>(iterable: I) -> ArrayBase<S, Ix>

Create a one-dimensional array from an iterable.

fn linspace<F>(start: F, end: F, n: usize) -> ArrayBase<S, Ix> where S: Data<Elem=F>, F: Float

Create a one-dimensional array from inclusive interval [start, end] with n elements. F must be a floating point type.

impl<S, A> ArrayBase<S, (Ix, Ix)> where S: DataOwned<Elem=A>

Constructor methods for two-dimensional arrays.

fn eye(n: Ix) -> ArrayBase<S, (Ix, Ix)> where S: DataMut, A: Clone + Zero + One

Create an identity matrix of size n (square 2D array).

Panics if n * n would overflow usize.

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

Constructor methods for arrays.

fn from_elem(dim: D, elem: A) -> ArrayBase<S, D> where A: Clone

Create an array with copies of elem, dimension dim.

Panics if the number of elements in dim would overflow usize.

use ndarray::RcArray;
use ndarray::arr3;

let a = RcArray::from_elem((2, 2, 2), 1.);

assert!(
    a == arr3(&[[[1., 1.],
                 [1., 1.]],
                [[1., 1.],
                 [1., 1.]]])
);

fn from_elem_f(dim: D, elem: A) -> ArrayBase<S, D> where A: Clone

Create an array with copies of elem, dimension dim and fortran memory order.

Panics if the number of elements would overflow usize.

use ndarray::RcArray;
use ndarray::arr3;

let a = RcArray::from_elem_f((2, 2, 2), 1.);

assert!(
    a == arr3(&[[[1., 1.],
                 [1., 1.]],
                [[1., 1.],
                 [1., 1.]]])
);
assert!(a.strides() == &[1, 2, 4]);

fn zeros(dim: D) -> ArrayBase<S, D> where A: Clone + Zero

Create an array with zeros, dimension dim.

Panics if the number of elements in dim would overflow usize.

fn zeros_f(dim: D) -> ArrayBase<S, D> where A: Clone + Zero

Create an array with zeros, dimension dim and fortran memory order.

Panics if the number of elements in dim would overflow usize.

fn default(dim: D) -> ArrayBase<S, D> where A: Default

Create an array with default values, dimension dim.

Panics if the number of elements in dim would overflow usize.

fn from_vec_dim(dim: D, v: Vec<A>) -> Result<ArrayBase<S, D>, ShapeError>

Create an array from a vector (with no allocation needed).

Errors if dim does not correspond to the number of elements in v.

unsafe fn from_vec_dim_unchecked(dim: D, v: Vec<A>) -> ArrayBase<S, D>

Create an array from a vector (with no allocation needed).

Unsafe because dimension is unchecked, and must be correct.

unsafe fn from_vec_dim_unchecked_f(dim: D, v: Vec<A>) -> ArrayBase<S, D>

Create an array from a vector (with no allocation needed), using fortran memory order to interpret the data.

Unsafe because dimension is unchecked, and must be correct.

fn from_vec_dim_stride(dim: D, strides: D, v: Vec<A>) -> Result<ArrayBase<S, D>, StrideError>

Create an array from a vector and interpret it according to the provided dimensions and strides. No allocation needed.

Checks whether dim and strides are compatible with the vector's length, returning an Err if not compatible.

Errors if strides and dimensions can point out of bounds of v.
Errors if strides allow multiple indices to point to the same element.

unsafe fn from_vec_dim_stride_unchecked(dim: D, strides: D, v: Vec<A>) -> ArrayBase<S, D>

Create an array from a vector and interpret it according to the provided dimensions and strides. No allocation needed.

Unsafe because dimension and strides are unchecked.

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

fn len(&self) -> usize

Return the total number of elements in the array.

fn dim(&self) -> D

Return the shape of the array.

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

Return the shape of the array as a slice.

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

Return the strides of the array

fn ndim(&self) -> usize

Return the number of dimensions (axes) in the array

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

Return a read-only view of the array

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

Return a read-write view of the array

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

Return an uniquely owned copy of the array

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

Return a shared ownership (copy on write) array.

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

Turn the array into a shared ownership (copy on write) array, without any copying.

fn iter(&self) -> Elements<A, D>

Return an iterator of references to the elements of the array.

Iterator element type is &A.

fn iter_mut(&mut self) -> ElementsMut<A, D> where S: DataMut

Return an iterator of mutable references to the elements of the array.

Iterator element type is &mut A.

fn indexed_iter(&self) -> Indexed<A, D>

Return an iterator of indexes and references to the elements of the array.

Iterator element type is (D, &A).

fn indexed_iter_mut(&mut self) -> IndexedMut<A, D> where S: DataMut

Return an iterator of indexes and mutable references to the elements of the array.

Iterator element type is (D, &mut A).

fn slice(&self, indexes: &D::SliceArg) -> ArrayView<A, D>

Return a sliced array.

See Slicing for full documentation. See also D::SliceArg.

Panics if an index is out of bounds or stride is zero.
(Panics if D is Vec and indexes does not match the number of array axes.)

fn slice_mut(&mut self, indexes: &D::SliceArg) -> ArrayViewMut<A, D> where S: DataMut

Return a sliced read-write view of the array.

See also D::SliceArg.

Panics if an index is out of bounds or stride is zero.
(Panics if D is Vec and indexes does not match the number of array axes.)

fn islice(&mut self, indexes: &D::SliceArg)

Slice the array’s view in place.

See also D::SliceArg.

Panics if an index is out of bounds or stride is zero.
(Panics if D is Vec and indexes does not match the number of array axes.)

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

Return a reference to the element at index, or return None if the index is out of bounds.

Arrays also support indexing syntax: array[index].

use ndarray::arr2;

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

assert!(
    a.get((0, 1)) == Some(&2.) &&
    a.get((0, 2)) == None &&
    a[(0, 1)] == 2. &&
    a[[0, 1]] == 2.
);

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

Return a mutable reference to the element at index, or return None if the index is out of bounds.

unsafe fn uget(&self, index: D) -> &A

Perform unchecked array indexing.

Return a reference to the element at index.

Note: only unchecked for non-debug builds of ndarray.

unsafe fn uget_mut(&mut self, index: D) -> &mut A where S: DataMut

Perform unchecked array indexing.

Return a mutable reference to the element at index.

Note: Only unchecked for non-debug builds of ndarray.
Note: The array must be uniquely held when mutating it.

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

Along axis, select the subview index and return a view with that axis removed.

See Subviews for full documentation.

Panics if axis or index is out of bounds.

use ndarray::{arr1, arr2};

let a = arr2(&[[1., 2.],    // -- axis 0, row 0
               [3., 4.],    // -- axis 0, row 1
               [5., 6.]]);  // -- axis 0, row 2
//               \   \
//                \   axis 1, column 1
//                 axis 1, column 0
assert!(
    a.subview(0, 1) == arr1(&[3., 4.]) &&
    a.subview(1, 1) == arr1(&[2., 4., 6.])
);

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

Along axis, select the subview index and return a read-write view with the axis removed.

Panics if axis or index is out of bounds.

use ndarray::{arr2, aview2};

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

a.subview_mut(1, 1).iadd_scalar(&10.);

assert!(
    a == aview2(&[[1., 12.],
                  [3., 14.]])
);

fn isubview(&mut self, axis: usize, index: Ix)

Collapse dimension axis into length one, and select the subview of index along that axis.

Panics if index is past the length of the axis.

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

Along axis, select the subview index and return self with that axis removed.

See .subview() and Subviews for full documentation.

fn inner_iter(&self) -> InnerIter<A, D>

Return an iterator that traverses over all dimensions but the innermost, and yields each inner row.

For example, in a 2 × 2 × 3 array, the iterator element is a row of 3 elements (and there are 2 × 2 = 4 rows in total).

Iterator element is ArrayView<A, Ix> (1D array view).

use ndarray::arr3;
let a = arr3(&[[[ 0,  1,  2],    // -- row 0, 0
                [ 3,  4,  5]],   // -- row 0, 1
               [[ 6,  7,  8],    // -- row 1, 0
                [ 9, 10, 11]]]); // -- row 1, 1
// `inner_iter` yields the four inner rows of the 3D array.
let mut row_sums = a.inner_iter().map(|v| v.scalar_sum());
assert_eq!(row_sums.collect::<Vec<_>>(), vec![3, 12, 21, 30]);

fn inner_iter_mut(&mut self) -> InnerIterMut<A, D> where S: DataMut

Return an iterator that traverses over all dimensions but the innermost, and yields each inner row.

Iterator element is ArrayViewMut<A, Ix> (1D read-write array view).

fn outer_iter(&self) -> OuterIter<A, D::Smaller> where D: RemoveAxis

Return an iterator that traverses over the outermost dimension and yields each subview.

For example, in a 2 × 2 × 3 array, the iterator element is a 2 × 3 subview (and there are 2 in total).

Iterator element is ArrayView<A, D::Smaller> (read-only array view).

use ndarray::arr3;
let a = arr3(&[[[ 0,  1,  2],    // \ axis 0, submatrix 0
                [ 3,  4,  5]],   // /
               [[ 6,  7,  8],    // \ axis 0, submatrix 1
                [ 9, 10, 11]]]); // /
// `outer_iter` yields the two submatrices along axis 0.
let mut iter = a.outer_iter();
assert_eq!(iter.next().unwrap(), a.subview(0, 0));
assert_eq!(iter.next().unwrap(), a.subview(0, 1));

fn outer_iter_mut(&mut self) -> OuterIterMut<A, D::Smaller> where S: DataMut, D: RemoveAxis

Return an iterator that traverses over the outermost dimension and yields each subview.

Iterator element is ArrayViewMut<A, D::Smaller> (read-write array view).

fn axis_iter(&self, axis: usize) -> OuterIter<A, D::Smaller> where D: RemoveAxis

Return an iterator that traverses over axis and yields each subview along it.

For example, in a 2 × 2 × 3 array, with axis equal to 1, the iterator element is a 2 × 3 subview (and there are 2 in total).

Iterator element is ArrayView<A, D::Smaller> (read-only array view).

See Subviews for full documentation.

Panics if axis is out of bounds.

fn axis_iter_mut(&mut self, axis: usize) -> OuterIterMut<A, D::Smaller> where S: DataMut, D: RemoveAxis

Return an iterator that traverses over axis and yields each mutable subview along it.

Iterator element is ArrayViewMut<A, D::Smaller> (read-write array view).

Panics if axis is out of bounds.

fn axis_chunks_iter(&self, axis: usize, size: usize) -> AxisChunksIter<A, D>

Return an iterator that traverses over axis by chunks of size, yielding non-overlapping views along that axis.

Iterator element is ArrayView<A, D>

The last view may have less elements if size does not divide the axis' dimension.

Panics if axis is out of bounds.

use ndarray::OwnedArray;
use ndarray::arr3;

let a = OwnedArray::from_iter(0..28).into_shape((2, 7, 2)).unwrap();
let mut iter = a.axis_chunks_iter(1, 2);

// first iteration yields a 2 × 2 × 2 view
assert_eq!(iter.next().unwrap(),
           arr3(&[[[0, 1], [2, 3]], [[14, 15], [16, 17]]]));

// however the last element is a 2 × 1 × 2 view since 7 % 2 == 1
assert_eq!(iter.next_back().unwrap(), arr3(&[[[12, 13]], [[26, 27]]]));

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

Return an iterator that traverses over axis by chunks of size, yielding non-overlapping read-write views along that axis.

Iterator element is ArrayViewMut<A, D>

Panics if axis is out of bounds.

fn diag(&self) -> ArrayView<A, Ix>

Return an view of the diagonal elements of the array.

The diagonal is simply the sequence indexed by (0, 0, .., 0), (1, 1, ..., 1) etc as long as all axes have elements.

fn diag_mut(&mut self) -> ArrayViewMut<A, Ix> where S: DataMut

Return a read-write view over the diagonal elements of the array.

fn into_diag(self) -> ArrayBase<S, Ix>

Return the diagonal as a one-dimensional array.

fn is_standard_layout(&self) -> bool

Return true if the array data is laid out in contiguous “C order” in memory (where the last index is the most rapidly varying).

Return false otherwise, i.e the array is possibly not contiguous in memory, it has custom strides, etc.

fn as_slice(&self) -> Option<&[A]>

Return the array’s data as a slice, if it is contiguous and the element order corresponds to the memory order. Return None otherwise.

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

Return the array’s data as a slice, if it is contiguous and the element order corresponds to the memory order. Return None otherwise.

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

Transform the array into shape; any shape with the same number of elements is accepted.

May clone all elements if needed to arrange elements in standard layout (and break sharing).

Panics if shapes are incompatible.

use ndarray::{rcarr1, rcarr2};

assert!(
    rcarr1(&[1., 2., 3., 4.]).reshape((2, 2))
    == rcarr2(&[[1., 2.],
                [3., 4.]])
);

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

Transform the array into shape; any shape with the same number of elements is accepted, but the source array or view must be contiguous, otherwise we cannot rearrange the dimension.

Errors if the shapes don't have the same number of elements.
Errors if the input array is not c-contiguous (this will be slightly improved in the future).

use ndarray::{aview1, aview2};

assert!(
    aview1(&[1., 2., 3., 4.]).into_shape((2, 2)).unwrap()
    == aview2(&[[1., 2.],
                [3., 4.]])
);

fn broadcast<E>(&self, dim: E) -> Option<ArrayView<A, E>> where E: Dimension

Act like a larger size and/or shape array by broadcasting into a larger shape, if possible.

Return None if shapes can not be broadcast together.

Background

• Two axes are compatible if they are equal, or one of them is 1.
• In this instance, only the axes of the smaller side (self) can be 1.

Compare axes beginning with the last axis of each shape.

For example (1, 2, 4) can be broadcast into (7, 6, 2, 4) because its axes are either equal or 1 (or missing); while (2, 2) can not be broadcast into (2, 4).

The implementation creates a view with strides set to zero for the axes that are to be repeated.

The broadcasting documentation for Numpy has more information.

use ndarray::{aview1, aview2};

assert!(
    aview1(&[1., 0.]).broadcast((10, 2)).unwrap()
    == aview2(&[[1., 0.]; 10])
);

fn swap_axes(&mut self, ax: usize, bx: usize)

Swap axes ax and bx.

This does not move any data, it just adjusts the array’s dimensions and strides.

Panics if the axes are out of bounds.

use ndarray::arr2;

let mut a = arr2(&[[1., 2., 3.]]);
a.swap_axes(0, 1);
assert!(
    a == arr2(&[[1.], [2.], [3.]])
);

fn reversed_axes(self) -> ArrayBase<S, D>

Transpose the array by reversing axes.

Transposition reverses the order of the axes (dimensions and strides) while retaining the same data.

fn raw_data(&self) -> &[A]

Return a slice of the array’s backing data in memory order.

Note: Data memory order may not correspond to the index order of the array. Neither is the raw data slice is restricted to just the array’s view.
Note: the slice may be empty.

fn raw_data_mut(&mut self) -> &mut [A] where S: DataMut

Return a mutable slice of the array’s backing data in memory order.

Note: Data memory order may not correspond to the index order of the array. Neither is the raw data slice is restricted to just the array’s view.
Note: the slice may be empty.

Note: The data is uniquely held and nonaliased while it is mutably borrowed.

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

Perform an elementwise assigment to self from rhs.

If their shapes disagree, rhs is broadcast to the shape of self.

Panics if broadcasting isn’t possible.

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

Perform an elementwise assigment to self from scalar x.

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)

Traverse two arrays in unspecified order, in lock step, calling the closure f on each element pair.

If their shapes disagree, rhs is broadcast to the shape of self.

Panics if broadcasting isn’t possible.

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

Traverse the array elements in order and apply a fold, returning the resulting value.

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

Apply f elementwise and return a new array with the results.

Return an array with the same shape as self.

use ndarray::arr2;

let a = arr2(&[[ 0., 1.],
               [-1., 2.]]);
assert!(
    a.map(|x| *x >= 1.0)
    == arr2(&[[false, true],
              [false, true]])
);

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

fn sum(&self, axis: usize) -> OwnedArray<A, D::Smaller> where A: Clone + Add<Output=A>, D: RemoveAxis

Return sum along axis.

use ndarray::{aview0, aview1, arr2};

let a = arr2(&[[1., 2.],
               [3., 4.]]);
assert!(
    a.sum(0) == aview1(&[4., 6.]) &&
    a.sum(1) == aview1(&[3., 7.]) &&

    a.sum(0).sum(0) == aview0(&10.)
);

Panics if axis is out of bounds.

fn scalar_sum(&self) -> A where A: Clone + Add<Output=A> + Zero

Return the sum of all elements in the array.

use ndarray::arr2;

let a = arr2(&[[1., 2.],
               [3., 4.]]);
assert_eq!(a.scalar_sum(), 10.);

fn mean(&self, axis: usize) -> OwnedArray<A, D::Smaller> where A: Copy + Field, D: RemoveAxis

Return mean along axis.

use ndarray::{aview1, arr2};

let a = arr2(&[[1., 2.],
               [3., 4.]]);
assert!(
    a.mean(0) == aview1(&[2.0, 3.0]) &&
    a.mean(1) == aview1(&[1.5, 3.5])
);

Panics if axis is out of bounds.

fn allclose<S2>(&self, rhs: &ArrayBase<S2, D>, tol: A) -> bool where A: Float, S2: Data<Elem=A>

Return true if the arrays' elementwise differences are all within the given absolute tolerance.
Return false otherwise, or if the shapes disagree.

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

fn dot<S2>(&self, rhs: &ArrayBase<S2, Ix>) -> A where S2: Data<Elem=A>, A: Clone + Add<Output=A> + Mul<Output=A> + Zero

Compute the dot product of one-dimensional arrays.

The dot product is a sum of the elementwise products (no conjugation of complex operands, and thus not their inner product).

Panics if the arrays are not of the same length.

impl<A, S> ArrayBase<S, (Ix, Ix)> where S: Data<Elem=A>

fn row(&self, index: Ix) -> ArrayView<A, Ix>

Return an array view of row index.

Panics if index is out of bounds.

fn row_mut(&mut self, index: Ix) -> ArrayViewMut<A, Ix> where S: DataMut

Return a mutable array view of row index.

Panics if index is out of bounds.

fn column(&self, index: Ix) -> ArrayView<A, Ix>

Return an array view of column index.

Panics if index is out of bounds.

fn column_mut(&mut self, index: Ix) -> ArrayViewMut<A, Ix> where S: DataMut

Return a mutable array view of column index.

Panics if index is out of bounds.

fn mat_mul(&self, rhs: &ArrayBase<S, (Ix, Ix)>) -> OwnedArray<A, (Ix, Ix)> where A: Copy + Ring

Perform matrix multiplication of rectangular arrays self and rhs.

The array shapes must agree in the way that if self is M × N, then rhs is N × K.

Return a result array with shape M × K.

Panics if shapes are incompatible.

use ndarray::arr2;

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

assert!(
    a.mat_mul(&b) == arr2(&[[5., 8.],
                            [2., 3.]])
);

fn mat_mul_col(&self, rhs: &ArrayBase<S, Ix>) -> OwnedArray<A, Ix> where A: Copy + Ring

Perform the matrix multiplication of the rectangular array self and column vector rhs.

The array shapes must agree in the way that if self is M × N, then rhs is N.

Return a result array with shape M.

Panics if shapes are incompatible.

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

In-place arithmetic operations.

fn iadd<E: Dimension, S2>(&mut self, rhs: &ArrayBase<S2, E>) where A: Clone + Add<A, Output=A>, S2: Data<Elem=A>

Perform elementwise addition between self and rhs, in place.

If their shapes disagree, rhs is broadcast to the shape of self.

Panics if broadcasting isn’t possible.

fn iadd_scalar(&mut self, x: &A) where A: Clone + Add<A, Output=A>

Perform elementwise addition between self and the scalar x, in place.

fn isub<E: Dimension, S2>(&mut self, rhs: &ArrayBase<S2, E>) where A: Clone + Sub<A, Output=A>, S2: Data<Elem=A>

Perform elementwise subtraction between self and rhs, in place.

If their shapes disagree, rhs is broadcast to the shape of self.

Panics if broadcasting isn’t possible.

fn isub_scalar(&mut self, x: &A) where A: Clone + Sub<A, Output=A>

Perform elementwise subtraction between self and the scalar x, in place.

fn imul<E: Dimension, S2>(&mut self, rhs: &ArrayBase<S2, E>) where A: Clone + Mul<A, Output=A>, S2: Data<Elem=A>

Perform elementwise multiplication between self and rhs, in place.

If their shapes disagree, rhs is broadcast to the shape of self.

Panics if broadcasting isn’t possible.

fn imul_scalar(&mut self, x: &A) where A: Clone + Mul<A, Output=A>

Perform elementwise multiplication between self and the scalar x, in place.

fn idiv<E: Dimension, S2>(&mut self, rhs: &ArrayBase<S2, E>) where A: Clone + Div<A, Output=A>, S2: Data<Elem=A>

Perform elementwise division between self and rhs, in place.

If their shapes disagree, rhs is broadcast to the shape of self.

Panics if broadcasting isn’t possible.

fn idiv_scalar(&mut self, x: &A) where A: Clone + Div<A, Output=A>

Perform elementwise division between self and the scalar x, in place.

fn irem<E: Dimension, S2>(&mut self, rhs: &ArrayBase<S2, E>) where A: Clone + Rem<A, Output=A>, S2: Data<Elem=A>

Perform elementwise remainder between self and rhs, in place.

If their shapes disagree, rhs is broadcast to the shape of self.

Panics if broadcasting isn’t possible.

fn irem_scalar(&mut self, x: &A) where A: Clone + Rem<A, Output=A>

Perform elementwise remainder between self and the scalar x, in place.

fn ibitand<E: Dimension, S2>(&mut self, rhs: &ArrayBase<S2, E>) where A: Clone + BitAnd<A, Output=A>, S2: Data<Elem=A>

Perform elementwise bit and between self and rhs, in place.

If their shapes disagree, rhs is broadcast to the shape of self.

Panics if broadcasting isn’t possible.

fn ibitand_scalar(&mut self, x: &A) where A: Clone + BitAnd<A, Output=A>

Perform elementwise bit and between self and the scalar x, in place.

fn ibitor<E: Dimension, S2>(&mut self, rhs: &ArrayBase<S2, E>) where A: Clone + BitOr<A, Output=A>, S2: Data<Elem=A>

Perform elementwise bit or between self and rhs, in place.

If their shapes disagree, rhs is broadcast to the shape of self.

Panics if broadcasting isn’t possible.

fn ibitor_scalar(&mut self, x: &A) where A: Clone + BitOr<A, Output=A>

Perform elementwise bit or between self and the scalar x, in place.

fn ibitxor<E: Dimension, S2>(&mut self, rhs: &ArrayBase<S2, E>) where A: Clone + BitXor<A, Output=A>, S2: Data<Elem=A>

Perform elementwise bit xor between self and rhs, in place.

If their shapes disagree, rhs is broadcast to the shape of self.

Panics if broadcasting isn’t possible.

fn ibitxor_scalar(&mut self, x: &A) where A: Clone + BitXor<A, Output=A>

Perform elementwise bit xor between self and the scalar x, in place.

fn ishl<E: Dimension, S2>(&mut self, rhs: &ArrayBase<S2, E>) where A: Clone + Shl<A, Output=A>, S2: Data<Elem=A>

Perform elementwise left shift between self and rhs, in place.

If their shapes disagree, rhs is broadcast to the shape of self.

Panics if broadcasting isn’t possible.

fn ishl_scalar(&mut self, x: &A) where A: Clone + Shl<A, Output=A>

Perform elementwise left shift between self and the scalar x, in place.

fn ishr<E: Dimension, S2>(&mut self, rhs: &ArrayBase<S2, E>) where A: Clone + Shr<A, Output=A>, S2: Data<Elem=A>

Perform elementwise right shift between self and rhs, in place.

If their shapes disagree, rhs is broadcast to the shape of self.

Panics if broadcasting isn’t possible.

fn ishr_scalar(&mut self, x: &A) where A: Clone + Shr<A, Output=A>

Perform elementwise right shift between self and the scalar x, in place.

fn ineg(&mut self) where A: Clone + Neg<Output=A>

Perform an elementwise negation of self, in place.

fn inot(&mut self) where A: Clone + Not<Output=A>

Perform an elementwise unary not of self, in place.

Trait Implementations

impl<S, D, I> Index<I> for ArrayBase<S, D> where D: Dimension, I: NdIndex<Dim=D>, S: Data

Access the element at index.

Panics if index is out of bounds.

type Output = S::Elem

The returned type after indexing

fn index(&self, index: I) -> &S::Elem

The method for the indexing (Foo[Bar]) operation

impl<S, D, I> IndexMut<I> for ArrayBase<S, D> where D: Dimension, I: NdIndex<Dim=D>, S: DataMut

Access the element at index mutably.

Panics if index is out of bounds.

fn index_mut(&mut self, index: I) -> &mut S::Elem

The method for the indexing (Foo[Bar]) operation

impl<S, S2, D> PartialEq<ArrayBase<S2, D>> for ArrayBase<S, D> where D: Dimension, S: Data, S2: Data<Elem=S::Elem>, S::Elem: PartialEq

Return true if the array shapes and all elements of self and rhs are equal. Return false otherwise.

fn eq(&self, rhs: &ArrayBase<S2, D>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<S, D> Eq for ArrayBase<S, D> where D: Dimension, S: Data, S::Elem: Eq

impl<A, S> FromIterator<A> for ArrayBase<S, Ix> where S: DataOwned<Elem=A>

fn from_iter<I>(iterable: I) -> ArrayBase<S, Ix> where I: IntoIterator<Item=A>

Creates a value from an iterator.

impl<'a, S, D> IntoIterator for &'a ArrayBase<S, D> where D: Dimension, S: Data

type Item = &'a S::Elem

The type of the elements being iterated over.

type IntoIter = Elements<'a, S::Elem, D>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, S, D> IntoIterator for &'a mut ArrayBase<S, D> where D: Dimension, S: DataMut

type Item = &'a mut S::Elem

The type of the elements being iterated over.

type IntoIter = ElementsMut<'a, S::Elem, D>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, S, D> Hash for ArrayBase<S, D> where D: Dimension, S: Data, S::Elem: Hash

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the state given, updating the hasher as necessary.

fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher

Feeds a slice of this type into the state provided.

impl<S, D> Sync for ArrayBase<S, D> where S: Sync + Data, D: Sync

ArrayBase is Sync when the storage type is.

impl<S, D> Send for ArrayBase<S, D> where S: Send + Data, D: Send

ArrayBase is Send when the storage type is.

impl<'a, A: Display, S, D: Dimension> Display for ArrayBase<S, D> where S: Data<Elem=A>

Format the array using Display and apply the formatting parameters used to each element.

The array is shown in multiline style, unless the alternate form is used, {:#}.

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

Formats the value using the given formatter.

impl<'a, A: Debug, S, D: Dimension> Debug for ArrayBase<S, D> where S: Data<Elem=A>

Format the array using Debug and apply the formatting parameters used to each element.

The array is shown in multiline style, unless the alternate form is used, {:#?}.

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

Formats the value using the given formatter.

impl<'a, A: LowerExp, S, D: Dimension> LowerExp for ArrayBase<S, D> where S: Data<Elem=A>

Format the array using LowerExp and apply the formatting parameters used to each element.

The array is shown in multiline style, unless the alternate form is used, {:#e}.

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

Formats the value using the given formatter.

impl<'a, A: UpperExp, S, D: Dimension> UpperExp for ArrayBase<S, D> where S: Data<Elem=A>

Format the array using UpperExp and apply the formatting parameters used to each element.

The array is shown in multiline style, unless the alternate form is used, {:#E}.

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

Formats the value using the given formatter.

impl<'a, A: LowerHex, S, D: Dimension> LowerHex for ArrayBase<S, D> where S: Data<Elem=A>

Format the array using LowerHex and apply the formatting parameters used to each element.

The array is shown in multiline style, unless the alternate form is used, {:#x}.

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

Formats the value using the given formatter.

impl<A, S, S2, D, E> Add<ArrayBase<S2, E>> for ArrayBase<S, D> where A: Clone + Add<A, Output=A>, S: DataMut<Elem=A>, S2: Data<Elem=A>, D: Dimension, E: Dimension

Perform elementwise addition between self and rhs, and return the result (based on self).

If their shapes disagree, rhs is broadcast to the shape of self.

Panics if broadcasting isn’t possible.

type Output = ArrayBase<S, D>

The resulting type after applying the + operator

fn add(self, rhs: ArrayBase<S2, E>) -> ArrayBase<S, D>

The method for the + operator

impl<'a, A, S, S2, D, E> Add<&'a ArrayBase<S2, E>> for ArrayBase<S, D> where A: Clone + Add<A, Output=A>, S: DataMut<Elem=A>, S2: Data<Elem=A>, D: Dimension, E: Dimension

Perform elementwise addition between self and reference rhs, and return the result (based on self).

If their shapes disagree, rhs is broadcast to the shape of self.

Panics if broadcasting isn’t possible.

type Output = ArrayBase<S, D>

The resulting type after applying the + operator

fn add(self, rhs: &ArrayBase<S2, E>) -> ArrayBase<S, D>

The method for the + operator

impl<'a, A, S, S2, D, E> Add<&'a ArrayBase<S2, E>> for &'a ArrayBase<S, D> where A: Clone + Add<A, Output=A>, S: Data<Elem=A>, S2: Data<Elem=A>, D: Dimension, E: Dimension

Perform elementwise addition between references self and rhs, and return the result as a new OwnedArray.

If their shapes disagree, rhs is broadcast to the shape of self.

Panics if broadcasting isn’t possible.

type Output = OwnedArray<A, D>

The resulting type after applying the + operator

fn add(self, rhs: &'a ArrayBase<S2, E>) -> OwnedArray<A, D>

The method for the + operator

impl<A, S, D, B> Add<B> for ArrayBase<S, D> where A: Clone + Add<B, Output=A>, S: DataMut<Elem=A>, D: Dimension, B: Clone + Scalar

Perform elementwise addition between self and the scalar x, and return the result (based on self).

type Output = ArrayBase<S, D>

The resulting type after applying the + operator

fn add(self, x: B) -> ArrayBase<S, D>

The method for the + operator

impl<'a, A, S, D, B> Add<B> for &'a ArrayBase<S, D> where A: Clone + Add<B, Output=A>, S: Data<Elem=A>, D: Dimension, B: Clone + Scalar

Perform elementwise addition between the reference self and the scalar x, and return the result as a new OwnedArray.

type Output = OwnedArray<A, D>

The resulting type after applying the + operator

fn add(self, x: B) -> OwnedArray<A, D>

The method for the + operator

impl<A, S, S2, D, E> Sub<ArrayBase<S2, E>> for ArrayBase<S, D> where A: Clone + Sub<A, Output=A>, S: DataMut<Elem=A>, S2: Data<Elem=A>, D: Dimension, E: Dimension

Perform elementwise subtraction between self and rhs, and return the result (based on self).

If their shapes disagree, rhs is broadcast to the shape of self.

Panics if broadcasting isn’t possible.

type Output = ArrayBase<S, D>

The resulting type after applying the - operator

fn sub(self, rhs: ArrayBase<S2, E>) -> ArrayBase<S, D>

The method for the - operator

impl<'a, A, S, S2, D, E> Sub<&'a ArrayBase<S2, E>> for ArrayBase<S, D> where A: Clone + Sub<A, Output=A>, S: DataMut<Elem=A>, S2: Data<Elem=A>, D: Dimension, E: Dimension

Perform elementwise subtraction between self and reference rhs, and return the result (based on self).

If their shapes disagree, rhs is broadcast to the shape of self.

Panics if broadcasting isn’t possible.

type Output = ArrayBase<S, D>

The resulting type after applying the - operator

fn sub(self, rhs: &ArrayBase<S2, E>) -> ArrayBase<S, D>

The method for the - operator

impl<'a, A, S, S2, D, E> Sub<&'a ArrayBase<S2, E>> for &'a ArrayBase<S, D> where A: Clone + Sub<A, Output=A>, S: Data<Elem=A>, S2: Data<Elem=A>, D: Dimension, E: Dimension

Perform elementwise subtraction between references self and rhs, and return the result as a new OwnedArray.

If their shapes disagree, rhs is broadcast to the shape of self.

Panics if broadcasting isn’t possible.

type Output = OwnedArray<A, D>

The resulting type after applying the - operator

fn sub(self, rhs: &'a ArrayBase<S2, E>) -> OwnedArray<A, D>

The method for the - operator

impl<A, S, D, B> Sub<B> for ArrayBase<S, D> where A: Clone + Sub<B, Output=A>, S: DataMut<Elem=A>, D: Dimension, B: Clone + Scalar

Perform elementwise subtraction between self and the scalar x, and return the result (based on self).

type Output = ArrayBase<S, D>

The resulting type after applying the - operator

fn sub(self, x: B) -> ArrayBase<S, D>

The method for the - operator

impl<'a, A, S, D, B> Sub<B> for &'a ArrayBase<S, D> where A: Clone + Sub<B, Output=A>, S: Data<Elem=A>, D: Dimension, B: Clone + Scalar

Perform elementwise subtraction between the reference self and the scalar x, and return the result as a new OwnedArray.

type Output = OwnedArray<A, D>

The resulting type after applying the - operator

fn sub(self, x: B) -> OwnedArray<A, D>

The method for the - operator

impl<A, S, S2, D, E> Mul<ArrayBase<S2, E>> for ArrayBase<S, D> where A: Clone + Mul<A, Output=A>, S: DataMut<Elem=A>, S2: Data<Elem=A>, D: Dimension, E: Dimension

Perform elementwise multiplication between self and rhs, and return the result (based on self).

If their shapes disagree, rhs is broadcast to the shape of self.

Panics if broadcasting isn’t possible.

type Output = ArrayBase<S, D>

The resulting type after applying the * operator

fn mul(self, rhs: ArrayBase<S2, E>) -> ArrayBase<S, D>

The method for the * operator

impl<'a, A, S, S2, D, E> Mul<&'a ArrayBase<S2, E>> for ArrayBase<S, D> where A: Clone + Mul<A, Output=A>, S: DataMut<Elem=A>, S2: Data<Elem=A>, D: Dimension, E: Dimension

Perform elementwise multiplication between self and reference rhs, and return the result (based on self).

If their shapes disagree, rhs is broadcast to the shape of self.

Panics if broadcasting isn’t possible.

type Output = ArrayBase<S, D>

The resulting type after applying the * operator

fn mul(self, rhs: &ArrayBase<S2, E>) -> ArrayBase<S, D>

The method for the * operator

impl<'a, A, S, S2, D, E> Mul<&'a ArrayBase<S2, E>> for &'a ArrayBase<S, D> where A: Clone + Mul<A, Output=A>, S: Data<Elem=A>, S2: Data<Elem=A>, D: Dimension, E: Dimension

Perform elementwise multiplication between references self and rhs, and return the result as a new OwnedArray.

If their shapes disagree, rhs is broadcast to the shape of self.

Panics if broadcasting isn’t possible.

type Output = OwnedArray<A, D>

The resulting type after applying the * operator

fn mul(self, rhs: &'a ArrayBase<S2, E>) -> OwnedArray<A, D>

The method for the * operator

impl<A, S, D, B> Mul<B> for ArrayBase<S, D> where A: Clone + Mul<B, Output=A>, S: DataMut<Elem=A>, D: Dimension, B: Clone + Scalar

Perform elementwise multiplication between self and the scalar x, and return the result (based on self).

type Output = ArrayBase<S, D>

The resulting type after applying the * operator

fn mul(self, x: B) -> ArrayBase<S, D>

The method for the * operator

impl<'a, A, S, D, B> Mul<B> for &'a ArrayBase<S, D> where A: Clone + Mul<B, Output=A>, S: Data<Elem=A>, D: Dimension, B: Clone + Scalar

Perform elementwise multiplication between the reference self and the scalar x, and return the result as a new OwnedArray.

type Output = OwnedArray<A, D>

The resulting type after applying the * operator

fn mul(self, x: B) -> OwnedArray<A, D>

The method for the * operator

impl<A, S, S2, D, E> Div<ArrayBase<S2, E>> for ArrayBase<S, D> where A: Clone + Div<A, Output=A>, S: DataMut<Elem=A>, S2: Data<Elem=A>, D: Dimension, E: Dimension

Perform elementwise division between self and rhs, and return the result (based on self).

If their shapes disagree, rhs is broadcast to the shape of self.

Panics if broadcasting isn’t possible.

type Output = ArrayBase<S, D>

The resulting type after applying the / operator

fn div(self, rhs: ArrayBase<S2, E>) -> ArrayBase<S, D>

The method for the / operator

impl<'a, A, S, S2, D, E> Div<&'a ArrayBase<S2, E>> for ArrayBase<S, D> where A: Clone + Div<A, Output=A>, S: DataMut<Elem=A>, S2: Data<Elem=A>, D: Dimension, E: Dimension

Perform elementwise division between self and reference rhs, and return the result (based on self).

If their shapes disagree, rhs is broadcast to the shape of self.

Panics if broadcasting isn’t possible.

type Output = ArrayBase<S, D>

The resulting type after applying the / operator

fn div(self, rhs: &ArrayBase<S2, E>) -> ArrayBase<S, D>

The method for the / operator

impl<'a, A, S, S2, D, E> Div<&'a ArrayBase<S2, E>> for &'a ArrayBase<S, D> where A: Clone + Div<A, Output=A>, S: Data<Elem=A>, S2: Data<Elem=A>, D: Dimension, E: Dimension

Perform elementwise division between references self and rhs, and return the result as a new OwnedArray.

If their shapes disagree, rhs is broadcast to the shape of self.

Panics if broadcasting isn’t possible.

type Output = OwnedArray<A, D>

The resulting type after applying the / operator

fn div(self, rhs: &'a ArrayBase<S2, E>) -> OwnedArray<A, D>

The method for the / operator

impl<A, S, D, B> Div<B> for ArrayBase<S, D> where A: Clone + Div<B, Output=A>, S: DataMut<Elem=A>, D: Dimension, B: Clone + Scalar

Perform elementwise division between self and the scalar x, and return the result (based on self).

type Output = ArrayBase<S, D>

The resulting type after applying the / operator

fn div(self, x: B) -> ArrayBase<S, D>

The method for the / operator

impl<'a, A, S, D, B> Div<B> for &'a ArrayBase<S, D> where A: Clone + Div<B, Output=A>, S: Data<Elem=A>, D: Dimension, B: Clone + Scalar

Perform elementwise division between the reference self and the scalar x, and return the result as a new OwnedArray.

type Output = OwnedArray<A, D>

The resulting type after applying the / operator

fn div(self, x: B) -> OwnedArray<A, D>

The method for the / operator

impl<A, S, S2, D, E> Rem<ArrayBase<S2, E>> for ArrayBase<S, D> where A: Clone + Rem<A, Output=A>, S: DataMut<Elem=A>, S2: Data<Elem=A>, D: Dimension, E: Dimension

Perform elementwise remainder between self and rhs, and return the result (based on self).

If their shapes disagree, rhs is broadcast to the shape of self.

Panics if broadcasting isn’t possible.

type Output = ArrayBase<S, D>

The resulting type after applying the % operator

fn rem(self, rhs: ArrayBase<S2, E>) -> ArrayBase<S, D>

The method for the % operator

impl<'a, A, S, S2, D, E> Rem<&'a ArrayBase<S2, E>> for ArrayBase<S, D> where A: Clone + Rem<A, Output=A>, S: DataMut<Elem=A>, S2: Data<Elem=A>, D: Dimension, E: Dimension

Perform elementwise remainder between self and reference rhs, and return the result (based on self).

If their shapes disagree, rhs is broadcast to the shape of self.

Panics if broadcasting isn’t possible.

type Output = ArrayBase<S, D>

The resulting type after applying the % operator

fn rem(self, rhs: &ArrayBase<S2, E>) -> ArrayBase<S, D>

The method for the % operator

impl<'a, A, S, S2, D, E> Rem<&'a ArrayBase<S2, E>> for &'a ArrayBase<S, D> where A: Clone + Rem<A, Output=A>, S: Data<Elem=A>, S2: Data<Elem=A>, D: Dimension, E: Dimension

Perform elementwise remainder between references self and rhs, and return the result as a new OwnedArray.

If their shapes disagree, rhs is broadcast to the shape of self.

Panics if broadcasting isn’t possible.

type Output = OwnedArray<A, D>

The resulting type after applying the % operator

fn rem(self, rhs: &'a ArrayBase<S2, E>) -> OwnedArray<A, D>

The method for the % operator

impl<A, S, D, B> Rem<B> for ArrayBase<S, D> where A: Clone + Rem<B, Output=A>, S: DataMut<Elem=A>, D: Dimension, B: Clone + Scalar

Perform elementwise remainder between self and the scalar x, and return the result (based on self).

type Output = ArrayBase<S, D>

The resulting type after applying the % operator

fn rem(self, x: B) -> ArrayBase<S, D>

The method for the % operator

impl<'a, A, S, D, B> Rem<B> for &'a ArrayBase<S, D> where A: Clone + Rem<B, Output=A>, S: Data<Elem=A>, D: Dimension, B: Clone + Scalar

Perform elementwise remainder between the reference self and the scalar x, and return the result as a new OwnedArray.

type Output = OwnedArray<A, D>

The resulting type after applying the % operator

fn rem(self, x: B) -> OwnedArray<A, D>

The method for the % operator

impl<A, S, S2, D, E> BitAnd<ArrayBase<S2, E>> for ArrayBase<S, D> where A: Clone + BitAnd<A, Output=A>, S: DataMut<Elem=A>, S2: Data<Elem=A>, D: Dimension, E: Dimension

Perform elementwise bit and between self and rhs, and return the result (based on self).

If their shapes disagree, rhs is broadcast to the shape of self.

Panics if broadcasting isn’t possible.

type Output = ArrayBase<S, D>

The resulting type after applying the & operator

fn bitand(self, rhs: ArrayBase<S2, E>) -> ArrayBase<S, D>

The method for the & operator

impl<'a, A, S, S2, D, E> BitAnd<&'a ArrayBase<S2, E>> for ArrayBase<S, D> where A: Clone + BitAnd<A, Output=A>, S: DataMut<Elem=A>, S2: Data<Elem=A>, D: Dimension, E: Dimension

Perform elementwise bit and between self and reference rhs, and return the result (based on self).

If their shapes disagree, rhs is broadcast to the shape of self.

Panics if broadcasting isn’t possible.

type Output = ArrayBase<S, D>

The resulting type after applying the & operator

fn bitand(self, rhs: &ArrayBase<S2, E>) -> ArrayBase<S, D>

The method for the & operator

impl<'a, A, S, S2, D, E> BitAnd<&'a ArrayBase<S2, E>> for &'a ArrayBase<S, D> where A: Clone + BitAnd<A, Output=A>, S: Data<Elem=A>, S2: Data<Elem=A>, D: Dimension, E: Dimension

Perform elementwise bit and between references self and rhs, and return the result as a new OwnedArray.

If their shapes disagree, rhs is broadcast to the shape of self.

Panics if broadcasting isn’t possible.

type Output = OwnedArray<A, D>

The resulting type after applying the & operator

fn bitand(self, rhs: &'a ArrayBase<S2, E>) -> OwnedArray<A, D>

The method for the & operator

impl<A, S, D, B> BitAnd<B> for ArrayBase<S, D> where A: Clone + BitAnd<B, Output=A>, S: DataMut<Elem=A>, D: Dimension, B: Clone + Scalar

Perform elementwise bit and between self and the scalar x, and return the result (based on self).

type Output = ArrayBase<S, D>

The resulting type after applying the & operator

fn bitand(self, x: B) -> ArrayBase<S, D>

The method for the & operator

impl<'a, A, S, D, B> BitAnd<B> for &'a ArrayBase<S, D> where A: Clone + BitAnd<B, Output=A>, S: Data<Elem=A>, D: Dimension, B: Clone + Scalar

Perform elementwise bit and between the reference self and the scalar x, and return the result as a new OwnedArray.

type Output = OwnedArray<A, D>

The resulting type after applying the & operator

fn bitand(self, x: B) -> OwnedArray<A, D>

The method for the & operator

impl<A, S, S2, D, E> BitOr<ArrayBase<S2, E>> for ArrayBase<S, D> where A: Clone + BitOr<A, Output=A>, S: DataMut<Elem=A>, S2: Data<Elem=A>, D: Dimension, E: Dimension

Perform elementwise bit or between self and rhs, and return the result (based on self).

If their shapes disagree, rhs is broadcast to the shape of self.

Panics if broadcasting isn’t possible.

type Output = ArrayBase<S, D>

The resulting type after applying the | operator

fn bitor(self, rhs: ArrayBase<S2, E>) -> ArrayBase<S, D>

The method for the | operator

impl<'a, A, S, S2, D, E> BitOr<&'a ArrayBase<S2, E>> for ArrayBase<S, D> where A: Clone + BitOr<A, Output=A>, S: DataMut<Elem=A>, S2: Data<Elem=A>, D: Dimension, E: Dimension

Perform elementwise bit or between self and reference rhs, and return the result (based on self).

If their shapes disagree, rhs is broadcast to the shape of self.

Panics if broadcasting isn’t possible.

type Output = ArrayBase<S, D>

The resulting type after applying the | operator

fn bitor(self, rhs: &ArrayBase<S2, E>) -> ArrayBase<S, D>

The method for the | operator

impl<'a, A, S, S2, D, E> BitOr<&'a ArrayBase<S2, E>> for &'a ArrayBase<S, D> where A: Clone + BitOr<A, Output=A>, S: Data<Elem=A>, S2: Data<Elem=A>, D: Dimension, E: Dimension

Perform elementwise bit or between references self and rhs, and return the result as a new OwnedArray.

If their shapes disagree, rhs is broadcast to the shape of self.

Panics if broadcasting isn’t possible.

type Output = OwnedArray<A, D>

The resulting type after applying the | operator

fn bitor(self, rhs: &'a ArrayBase<S2, E>) -> OwnedArray<A, D>

The method for the | operator

impl<A, S, D, B> BitOr<B> for ArrayBase<S, D> where A: Clone + BitOr<B, Output=A>, S: DataMut<Elem=A>, D: Dimension, B: Clone + Scalar

Perform elementwise bit or between self and the scalar x, and return the result (based on self).

type Output = ArrayBase<S, D>

The resulting type after applying the | operator

fn bitor(self, x: B) -> ArrayBase<S, D>

The method for the | operator

impl<'a, A, S, D, B> BitOr<B> for &'a ArrayBase<S, D> where A: Clone + BitOr<B, Output=A>, S: Data<Elem=A>, D: Dimension, B: Clone + Scalar

Perform elementwise bit or between the reference self and the scalar x, and return the result as a new OwnedArray.

type Output = OwnedArray<A, D>

The resulting type after applying the | operator

fn bitor(self, x: B) -> OwnedArray<A, D>

The method for the | operator

impl<A, S, S2, D, E> BitXor<ArrayBase<S2, E>> for ArrayBase<S, D> where A: Clone + BitXor<A, Output=A>, S: DataMut<Elem=A>, S2: Data<Elem=A>, D: Dimension, E: Dimension

Perform elementwise bit xor between self and rhs, and return the result (based on self).

If their shapes disagree, rhs is broadcast to the shape of self.

Panics if broadcasting isn’t possible.

type Output = ArrayBase<S, D>

The resulting type after applying the ^ operator

fn bitxor(self, rhs: ArrayBase<S2, E>) -> ArrayBase<S, D>

The method for the ^ operator

impl<'a, A, S, S2, D, E> BitXor<&'a ArrayBase<S2, E>> for ArrayBase<S, D> where A: Clone + BitXor<A, Output=A>, S: DataMut<Elem=A>, S2: Data<Elem=A>, D: Dimension, E: Dimension

Perform elementwise bit xor between self and reference rhs, and return the result (based on self).

If their shapes disagree, rhs is broadcast to the shape of self.

Panics if broadcasting isn’t possible.

type Output = ArrayBase<S, D>

The resulting type after applying the ^ operator

fn bitxor(self, rhs: &ArrayBase<S2, E>) -> ArrayBase<S, D>

The method for the ^ operator

impl<'a, A, S, S2, D, E> BitXor<&'a ArrayBase<S2, E>> for &'a ArrayBase<S, D> where A: Clone + BitXor<A, Output=A>, S: Data<Elem=A>, S2: Data<Elem=A>, D: Dimension, E: Dimension

Perform elementwise bit xor between references self and rhs, and return the result as a new OwnedArray.

If their shapes disagree, rhs is broadcast to the shape of self.

Panics if broadcasting isn’t possible.

type Output = OwnedArray<A, D>

The resulting type after applying the ^ operator

fn bitxor(self, rhs: &'a ArrayBase<S2, E>) -> OwnedArray<A, D>

The method for the ^ operator

impl<A, S, D, B> BitXor<B> for ArrayBase<S, D> where A: Clone + BitXor<B, Output=A>, S: DataMut<Elem=A>, D: Dimension, B: Clone + Scalar

Perform elementwise bit xor between self and the scalar x, and return the result (based on self).

type Output = ArrayBase<S, D>

The resulting type after applying the ^ operator

fn bitxor(self, x: B) -> ArrayBase<S, D>

The method for the ^ operator

impl<'a, A, S, D, B> BitXor<B> for &'a ArrayBase<S, D> where A: Clone + BitXor<B, Output=A>, S: Data<Elem=A>, D: Dimension, B: Clone + Scalar

Perform elementwise bit xor between the reference self and the scalar x, and return the result as a new OwnedArray.

type Output = OwnedArray<A, D>

The resulting type after applying the ^ operator

fn bitxor(self, x: B) -> OwnedArray<A, D>

The method for the ^ operator

impl<A, S, S2, D, E> Shl<ArrayBase<S2, E>> for ArrayBase<S, D> where A: Clone + Shl<A, Output=A>, S: DataMut<Elem=A>, S2: Data<Elem=A>, D: Dimension, E: Dimension

Perform elementwise left shift between self and rhs, and return the result (based on self).

If their shapes disagree, rhs is broadcast to the shape of self.

Panics if broadcasting isn’t possible.

type Output = ArrayBase<S, D>

The resulting type after applying the << operator

fn shl(self, rhs: ArrayBase<S2, E>) -> ArrayBase<S, D>

The method for the << operator

impl<'a, A, S, S2, D, E> Shl<&'a ArrayBase<S2, E>> for ArrayBase<S, D> where A: Clone + Shl<A, Output=A>, S: DataMut<Elem=A>, S2: Data<Elem=A>, D: Dimension, E: Dimension

Perform elementwise left shift between self and reference rhs, and return the result (based on self).

If their shapes disagree, rhs is broadcast to the shape of self.

Panics if broadcasting isn’t possible.

type Output = ArrayBase<S, D>

The resulting type after applying the << operator

fn shl(self, rhs: &ArrayBase<S2, E>) -> ArrayBase<S, D>

The method for the << operator

impl<'a, A, S, S2, D, E> Shl<&'a ArrayBase<S2, E>> for &'a ArrayBase<S, D> where A: Clone + Shl<A, Output=A>, S: Data<Elem=A>, S2: Data<Elem=A>, D: Dimension, E: Dimension

Perform elementwise left shift between references self and rhs, and return the result as a new OwnedArray.

If their shapes disagree, rhs is broadcast to the shape of self.

Panics if broadcasting isn’t possible.

type Output = OwnedArray<A, D>

The resulting type after applying the << operator

fn shl(self, rhs: &'a ArrayBase<S2, E>) -> OwnedArray<A, D>

The method for the << operator

impl<A, S, D, B> Shl<B> for ArrayBase<S, D> where A: Clone + Shl<B, Output=A>, S: DataMut<Elem=A>, D: Dimension, B: Clone + Scalar

Perform elementwise left shift between self and the scalar x, and return the result (based on self).

type Output = ArrayBase<S, D>

The resulting type after applying the << operator

fn shl(self, x: B) -> ArrayBase<S, D>

The method for the << operator

impl<'a, A, S, D, B> Shl<B> for &'a ArrayBase<S, D> where A: Clone + Shl<B, Output=A>, S: Data<Elem=A>, D: Dimension, B: Clone + Scalar

Perform elementwise left shift between the reference self and the scalar x, and return the result as a new OwnedArray.

type Output = OwnedArray<A, D>

The resulting type after applying the << operator

fn shl(self, x: B) -> OwnedArray<A, D>

The method for the << operator

impl<A, S, S2, D, E> Shr<ArrayBase<S2, E>> for ArrayBase<S, D> where A: Clone + Shr<A, Output=A>, S: DataMut<Elem=A>, S2: Data<Elem=A>, D: Dimension, E: Dimension

Perform elementwise right shift between self and rhs, and return the result (based on self).

If their shapes disagree, rhs is broadcast to the shape of self.

Panics if broadcasting isn’t possible.

type Output = ArrayBase<S, D>

The resulting type after applying the >> operator

fn shr(self, rhs: ArrayBase<S2, E>) -> ArrayBase<S, D>

The method for the >> operator

impl<'a, A, S, S2, D, E> Shr<&'a ArrayBase<S2, E>> for ArrayBase<S, D> where A: Clone + Shr<A, Output=A>, S: DataMut<Elem=A>, S2: Data<Elem=A>, D: Dimension, E: Dimension

Perform elementwise right shift between self and reference rhs, and return the result (based on self).

If their shapes disagree, rhs is broadcast to the shape of self.

Panics if broadcasting isn’t possible.

type Output = ArrayBase<S, D>

The resulting type after applying the >> operator

fn shr(self, rhs: &ArrayBase<S2, E>) -> ArrayBase<S, D>

The method for the >> operator

impl<'a, A, S, S2, D, E> Shr<&'a ArrayBase<S2, E>> for &'a ArrayBase<S, D> where A: Clone + Shr<A, Output=A>, S: Data<Elem=A>, S2: Data<Elem=A>, D: Dimension, E: Dimension

Perform elementwise right shift between references self and rhs, and return the result as a new OwnedArray.

If their shapes disagree, rhs is broadcast to the shape of self.

Panics if broadcasting isn’t possible.

type Output = OwnedArray<A, D>

The resulting type after applying the >> operator

fn shr(self, rhs: &'a ArrayBase<S2, E>) -> OwnedArray<A, D>

The method for the >> operator

impl<A, S, D, B> Shr<B> for ArrayBase<S, D> where A: Clone + Shr<B, Output=A>, S: DataMut<Elem=A>, D: Dimension, B: Clone + Scalar

Perform elementwise right shift between self and the scalar x, and return the result (based on self).

type Output = ArrayBase<S, D>

The resulting type after applying the >> operator

fn shr(self, x: B) -> ArrayBase<S, D>

The method for the >> operator

impl<'a, A, S, D, B> Shr<B> for &'a ArrayBase<S, D> where A: Clone + Shr<B, Output=A>, S: Data<Elem=A>, D: Dimension, B: Clone + Scalar

Perform elementwise right shift between the reference self and the scalar x, and return the result as a new OwnedArray.

type Output = OwnedArray<A, D>

The resulting type after applying the >> operator

fn shr(self, x: B) -> OwnedArray<A, D>

The method for the >> operator

impl<A, S, D> Neg for ArrayBase<S, D> where A: Clone + Neg<Output=A>, S: DataMut<Elem=A>, D: Dimension

type Output = Self

The resulting type after applying the - operator

fn neg(self) -> Self

Perform an elementwise negation of self and return the result.

impl<A, S, D> Not for ArrayBase<S, D> where A: Clone + Not<Output=A>, S: DataMut<Elem=A>, D: Dimension

type Output = Self

The resulting type after applying the ! operator

fn not(self) -> Self

Perform an elementwise unary not of self and return the result.

impl<S: DataClone, D: Clone> Clone for ArrayBase<S, D>

fn clone(&self) -> ArrayBase<S, D>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S: DataClone + Copy, D: Copy> Copy for ArrayBase<S, D>