# Struct ndarray::ArrayBase
[−]
[src]

`pub struct ArrayBase<S, D> where S: Data { /* 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 and
`D`

for the dimensionality.

Type aliases `Array`

, `RcArray`

, `ArrayView`

, and `ArrayViewMut`

refer
to `ArrayBase`

with different types for the data container.

## Contents

- Array
- RcArray
- Array Views
- Indexing and Dimension
- Slicing
- Subviews
- Arithmetic Operations
- Broadcasting
- Constructor Methods for Owned Arrays
- Methods For All Array Types
- Methods Specific to Array Views

`Array`

`Array`

is an owned array that ows 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;

`RcArray`

`RcArray`

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 `RcArray`

, 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.

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 Methods Specific to Array
Views.

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.

## 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, 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.subview(Axis(0), 0); let sub_1 = a.subview(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.subview(Axis(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 an array
with owned storage (either `Array`

or `RcArray`

).
Let `C`

be an array with mutable data (either `Array`

, `RcArray`

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

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

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

## Methods

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

[src]

# Constructor Methods for Owned Arrays

Constructor methods for one-dimensional arrays.

Note that the constructor methods apply to `Array`

and `RcArray`

,
the two array types that have owned storage.

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

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

use ndarray::Array; let array = Array::from_vec(vec![1., 2., 3., 4.]);

`fn from_iter<I>(iterable: I) -> Self where I: IntoIterator<Item = A>`

Create a one-dimensional array from an iterable.

use ndarray::{Array, arr1}; let array = Array::from_iter((0..5).map(|x| x * x)); assert!(array == arr1(&[0, 1, 4, 9, 16]))

`fn linspace(start: A, end: A, n: usize) -> Self where A: Float`

Create a one-dimensional array from the inclusive interval
`[start, end]`

with `n`

elements. `A`

must be a floating point type.

use ndarray::{Array, arr1}; let array = Array::linspace(0., 1., 5); assert!(array == arr1(&[0.0, 0.25, 0.5, 0.75, 1.0]))

`fn range(start: A, end: A, step: A) -> Self where A: Float`

Create a one-dimensional array from the half-open interval
`[start, end)`

with elements spaced by `step`

. `A`

must be a floating
point type.

use ndarray::{Array, arr1}; let array = Array::range(0., 5., 1.); assert!(array == arr1(&[0., 1., 2., 3., 4.]))

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

[src]

Constructor methods for two-dimensional arrays.

`fn eye(n: Ix) -> Self 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`

[src]

Constructor methods for n-dimensional arrays.

`fn from_elem<Sh>(shape: Sh, elem: A) -> Self where A: Clone, Sh: ShapeBuilder<Dim = D>`

Create an array with copies of `elem`

, shape `shape`

.

**Panics** if the number of elements in `shape`

would overflow usize.

use ndarray::{Array, arr3, ShapeBuilder}; let a = Array::from_elem((2, 2, 2), 1.); assert!( a == arr3(&[[[1., 1.], [1., 1.]], [[1., 1.], [1., 1.]]]) ); assert!(a.strides() == &[4, 2, 1]); let b = Array::from_elem((2, 2, 2).f(), 1.); assert!(b.strides() == &[1, 2, 4]);

`fn zeros<Sh>(shape: Sh) -> Self where A: Clone + Zero, Sh: ShapeBuilder<Dim = D>`

Create an array with zeros, shape `shape`

.

**Panics** if the number of elements in `shape`

would overflow usize.

`fn default<Sh>(shape: Sh) -> Self where A: Default, Sh: ShapeBuilder<Dim = D>`

Create an array with default values, shape `shape`

**Panics** if the number of elements in `shape`

would overflow usize.

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

Create an array with values created by the function `f`

.

The elements are visited in arbitirary order.

**Panics** if the number of elements in `shape`

would overflow usize.

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

Create an array with the given shape from a vector. (No cloning of elements needed.)

For a contiguous c- or f-order shape, the following applies:

**Errors** if `shape`

does not correspond to the number of elements in `v`

.

For custom strides, the following applies:

**Errors** if strides and dimensions can point out of bounds of `v`

.

**Errors** if strides allow multiple indices to point to the same element.

use ndarray::Array; use ndarray::ShapeBuilder; // Needed for .strides() method use ndarray::arr2; let a = Array::from_shape_vec((2, 2), vec![1., 2., 3., 4.]); assert!(a.is_ok()); let b = Array::from_shape_vec((2, 2).strides((1, 2)), vec![1., 2., 3., 4.]).unwrap(); assert!( b == arr2(&[[1., 3.], [2., 4.]]) );

`unsafe fn from_shape_vec_unchecked<Sh>(shape: Sh, v: Vec<A>) -> Self where Sh: Into<StrideShape<D>>`

Create an array from a vector and interpret it according to the provided dimensions and strides. (No cloning of elements needed.)

Unsafe because dimension and strides are unchecked.

`unsafe fn uninitialized<Sh>(shape: Sh) -> Self where A: Copy, Sh: ShapeBuilder<Dim = D>`

Create an array with uninitalized elements, shape `shape`

.

**Panics** if the number of elements in `shape`

would overflow usize.

### Safety

Accessing uninitalized values is undefined behaviour. You must
overwrite *all* the elements in the array after it is created; for
example using the methods `.fill()`

or `.assign()`

.

The contents of the array is indeterminate before initialization and it
is an error to perform operations that use the previous values. For
example it would not be legal to use `a += 1.;`

on such an array.

This constructor is limited to elements where `A: Copy`

(no destructors)
to avoid users shooting themselves too hard in the foot; it is not
a problem to drop an array created with this method even before elements
are initialized. (Note that constructors `from_shape_vec`

and
`from_shape_vec_unchecked`

allow the user yet more control).

### Examples

#[macro_use(s)] extern crate ndarray; use ndarray::Array2; // Example Task: Let's create a column shifted copy of a in b fn shift_by_two(a: &Array2<f32>) -> Array2<f32> { let mut b = unsafe { Array2::uninitialized(a.dim()) }; // two first columns in b are two last in a // rest of columns in b are the initial columns in a b.slice_mut(s![.., ..2]).assign(&a.slice(s![.., -2..])); b.slice_mut(s![.., 2..]).assign(&a.slice(s![.., ..-2])); // `b` is safe to use with all operations at this point b }

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

[src]

`fn len(&self) -> usize`

Return the total number of elements in the array.

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

Return the length of `axis`

.

The axis should be in the range `Axis(`

0 .. *n* `)`

where *n* is the
number of dimensions (axes) of the array.

** Panics** if the axis is out of bounds.

`fn ndim(&self) -> usize`

Return the number of dimensions (axes) in the array

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

Return the shape of the array in its “pattern” form, an integer in the one-dimensional case, tuple in the n-dimensional cases and so on.

`fn raw_dim(&self) -> D`

Return the shape of the array as it stored in 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 as a slice

`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) -> Array<A, D> where A: Clone`

Return an uniquely owned copy of the array

Return a shared ownership (copy on write) array.

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

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

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

Elements are visited in the *logical order* of the array, which
is where the rightmost index is varying the fastest.

Iterator element type is `&A`

.

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

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

Elements are visited in the *logical order* of the array, which
is where the rightmost index is varying the fastest.

Iterator element type is `&mut A`

.

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

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

Elements are visited in the *logical order* of the array, which
is where the rightmost index is varying the fastest.

Iterator element type is `(D::Pattern, &A)`

.

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

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

*logical order* of the array, which
is where the rightmost index is varying the fastest.

Iterator element type is `(D::Pattern, &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 `IxDyn`

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 `IxDyn`

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 `IxDyn`

and `indexes`

does not match the number of array axes.)

`fn get<I>(&self, index: I) -> Option<&A> where I: NdIndex<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<D>`

Return a mutable reference to the element at `index`

, or return `None`

if the index is out of bounds.

`unsafe fn uget<I>(&self, index: I) -> &A where I: NdIndex<D>`

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<I>(&mut self, index: I) -> &mut A where S: DataMut, I: NdIndex<D>`

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 swap<I>(&mut self, index1: I, index2: I) where S: DataMut, I: NdIndex<D>`

Swap elements at indices `index1`

and `index2`

.

Indices may be equal.

** Panics** if an index is out of bounds.

`fn subview(&self, axis: Axis, 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::{arr2, ArrayView, Axis}; 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(Axis(0), 1) == ArrayView::from(&[3., 4.]) && a.subview(Axis(1), 1) == ArrayView::from(&[2., 4., 6.]) );

`fn subview_mut(&mut self, axis: Axis, 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, Axis}; let mut a = arr2(&[[1., 2. ], [3., 4. ]]); // . \ // . axis 1, column 1 // axis 1, column 0 { let mut column1 = a.subview_mut(Axis(1), 1); column1 += 10.; } assert!( a == aview2(&[[1., 12.], [3., 14.]]) );

`fn isubview(&mut self, axis: Axis, 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: Axis, 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 select(&self, axis: Axis, indices: &[Ix]) -> Array<A, D> where A: Copy, D: RemoveAxis`

Along `axis`

, select arbitrary subviews corresponding to `indices`

and and copy them into a new array.

**Panics** if `axis`

or an element of `indices`

is out of bounds.

use ndarray::{arr2, Axis}; let x = arr2(&[[0., 1.], [2., 3.], [4., 5.], [6., 7.], [8., 9.]]); let r = x.select(Axis(0), &[0, 4, 3]); assert!( r == arr2(&[[0., 1.], [8., 9.], [6., 7.]]) );

`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 `ArrayView1<A>`

(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 `ArrayViewMut1<A>`

(1D read-write array view).

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

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

This is equivalent to `.axis_iter(Axis(0))`

.

Iterator element is `ArrayView<A, D::Smaller>`

(read-only array view).

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

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

This is equivalent to `.axis_iter_mut(Axis(0))`

.

Iterator element is `ArrayViewMut<A, D::Smaller>`

(read-write array view).

`fn axis_iter(&self, axis: Axis) -> AxisIter<A, D::Smaller> where D: RemoveAxis`

Return an iterator that traverses over `axis`

and yields each subview along it.

For example, in a 3 × 4 × 5 array, with `axis`

equal to `Axis(2)`

,
the iterator element
is a 3 × 4 subview (and there are 5 in total), as shown
in the picture below.

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: Axis) -> AxisIterMut<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: Axis, 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::Array; use ndarray::{arr3, Axis}; let a = Array::from_iter(0..28).into_shape((2, 7, 2)).unwrap(); let mut iter = a.axis_chunks_iter(Axis(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: Axis,

size: usize)

-> AxisChunksIterMut<A, D> where S: DataMut

axis: Axis,

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 whole_chunks<E>(&self, chunk_size: E) -> WholeChunks<A, D> where E: IntoDimension<Dim = D>`

Return a whole chunks producer (and iterable).

It produces the whole chunks of a given n-dimensional chunk size, skipping the remainder along each dimension that doesn't fit evenly.

Iterator element is `ArrayView<A, D>`

**Panics** if any dimension of `chunk_size`

is zero

`fn diag(&self) -> ArrayView1<A>`

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) -> ArrayViewMut1<A> where S: DataMut`

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

`fn into_diag(self) -> ArrayBase<S, Ix1>`

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_ptr(&self) -> *const A`

Return a pointer to the first element in the array.

Raw access to array elements needs to follow the strided indexing
scheme: an element at multi-index *I* in an array with strides *S* is
located at offset

*Σ _{0 ≤ k < d} I_{k} × S_{k}*

where *d* is `self.ndim()`

.

`fn as_mut_ptr(&mut self) -> *mut A where S: DataMut`

Return a mutable pointer to the first element in the array.

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

Return the array’s data as a slice, if it is contiguous and in standard order.
Return `None`

otherwise.

If this function returns `Some(_)`

, then the element order in the slice
corresponds to the logical order of the array’s elements.

`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 in standard order.
Return `None`

otherwise.

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

Return the array’s data as a slice if it is contiguous,
return `None`

otherwise.

If this function returns `Some(_)`

, then the elements in the slice
have whatever order the elements have in memory.

Implementation notes: Does not yet support negatively strided arrays.

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

Return the array’s data as a slice if it is contiguous,
return `None`

otherwise.

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

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- or f-contiguous.

use ndarray::{aview1, aview2}; assert!( aview1(&[1., 2., 3., 4.]).into_shape((2, 2)).unwrap() == aview2(&[[1., 2.], [3., 4.]]) );

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

*Note: Reshape is for RcArray only. Use .into_shape() for
other arrays and array views.*

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 broadcast<E>(&self, dim: E) -> Option<ArrayView<A, E::Dim>> where E: IntoDimension`

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 t(&self) -> ArrayView<A, D>`

Return a transposed view of the array.

This is a shorthand for `self.view().reversed_axes()`

.

See also the more general methods `.reversed_axes()`

and `.swap_axes()`

.

`fn axes(&self) -> Axes<D>`

Return an iterator over the length and stride of each axis.

`fn max_stride_axis(&self) -> Axis`

Return the axis with the greatest stride (by absolute value), preferring axes with len > 1.

`fn invert_axis(&mut self, axis: Axis)`

Reverse the stride of `axis`

.

** Panics** if the axis is out of bounds.

`fn merge_axes(&mut self, take: Axis, into: Axis) -> bool`

If possible, merge in the axis `take`

to `into`

.

use ndarray::Array3; use ndarray::Axis; let mut a = Array3::<f64>::zeros((2, 3, 4)); a.merge_axes(Axis(1), Axis(2)); assert_eq!(a.shape(), &[2, 1, 12]);

** Panics** if an axis is out of bounds.

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

Remove array axis `axis`

and return the result.

`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 fill(&mut self, x: A) where S: DataMut, A: Clone`

Perform an elementwise assigment to `self`

from element `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 and apply a fold, returning the resulting value.

Elements are visited in arbitrary order.

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

Call `f`

by reference on each element and create a new array
with the new values.

Elements are visited in arbitrary order.

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

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

Call `f`

by **v**alue on each element and create a new array
with the new values.

Elements are visited in arbitrary order.

Return an array with the same shape as `self`

.

use ndarray::arr2; let a = arr2(&[[ 0., 1.], [-1., 2.]]); assert!( a.mapv(f32::abs) == arr2(&[[0., 1.], [1., 2.]]) );

`fn mapv_into<F>(self, f: F) -> Self where S: DataMut, F: Fn(A) -> A, A: Clone`

Call `f`

by **v**alue on each element, update the array with the new values
and return it.

Elements are visited in arbitrary order.

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

Modify the array in place by calling `f`

by mutable reference on each element.

Elements are visited in arbitrary order.

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

Modify the array in place by calling `f`

by **v**alue on each element.
The array is updated with the new values.

Elements are visited in arbitrary order.

use ndarray::arr2; let mut a = arr2(&[[ 0., 1.], [-1., 2.]]); a.mapv_inplace(f32::exp); assert!( a.all_close(&arr2(&[[1.00000, 2.71828], [0.36788, 7.38906]]), 1e-5) );

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

Visit each element in the array by calling `f`

by reference
on each element.

Elements are visited in arbitrary order.

`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`

Fold along an axis.

Combine the elements of each subview with the previous using the `fold`

function and initial value `init`

.

Return the result as an `Array`

.

`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`

Reduce the values along an axis into just one value, producing a new array with one less dimension.

Elements are visited in arbitrary order.

Return the result as an `Array`

.

**Panics** if `axis`

is out of bounds.

`impl<A, D> ArrayBase<Vec<A>, D> where D: Dimension`

[src]

`fn into_raw_vec(self) -> Vec<A>`

Return a vector of the elements in the array, in the way they are stored internally.

If the array is in standard memory layout, the logical element order
of the array (`.iter()`

order) and of the returned vector will be the same.

`impl<A, D> ArrayBase<Rc<Vec<A>>, D> where A: Clone, D: Dimension`

[src]

`fn into_owned(self) -> Array<A, D>`

Convert an `RcArray`

into `Array`

; cloning the array elements to unshare
them if necessary.

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

[src]

`fn to_vec(&self) -> Vec<A> where A: Clone`

Return an vector with the elements of the one-dimensional array.

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

[src]

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

Return an array view of row `index`

.

**Panics** if `index`

is out of bounds.

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

Return a mutable array view of row `index`

.

**Panics** if `index`

is out of bounds.

`fn rows(&self) -> usize`

Return the number of rows (length of `Axis(0)`

) in the two-dimensional array.

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

Return an array view of column `index`

.

**Panics** if `index`

is out of bounds.

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

Return a mutable array view of column `index`

.

**Panics** if `index`

is out of bounds.

`fn cols(&self) -> usize`

Return the number of columns (length of `Axis(1)`

) in the two-dimensional array.

`fn is_square(&self) -> bool`

Return true if the array is square, false otherwise.

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

[src]

Numerical methods for arrays.

`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 sum(&self, axis: Axis) -> Array<A, D::Smaller> where A: Clone + Zero + Add<Output = A>, D: RemoveAxis`

Return sum along `axis`

.

use ndarray::{aview0, aview1, arr2, Axis}; let a = arr2(&[[1., 2.], [3., 4.]]); assert!( a.sum(Axis(0)) == aview1(&[4., 6.]) && a.sum(Axis(1)) == aview1(&[3., 7.]) && a.sum(Axis(0)).sum(Axis(0)) == aview0(&10.) );

**Panics** if `axis`

is out of bounds.

`fn mean(&self, axis: Axis) -> Array<A, D::Smaller> where A: LinalgScalar, D: RemoveAxis`

Return mean along `axis`

.

**Panics** if `axis`

is out of bounds.

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

`fn all_close<S2, E>(&self, rhs: &ArrayBase<S2, E>, tol: A) -> bool where A: Float, S2: Data<Elem = A>, E: Dimension`

Return `true`

if the arrays' elementwise differences are all within
the given absolute tolerance, `false`

otherwise.

If their shapes disagree, `rhs`

is broadcast to the shape of `self`

.

**Panics** if broadcasting to the same shape isn’t possible.

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

[src]

`fn dot<S2>(&self, rhs: &ArrayBase<S2, Ix1>) -> A where S2: Data<Elem = A>, A: LinalgScalar`

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, Ix2> where S: Data<Elem = A>`

[src]

`fn dot<Rhs>(&self, rhs: &Rhs) -> Self::Output where Self: Dot<Rhs>`

Perform matrix multiplication of rectangular arrays `self`

and `rhs`

.

`Rhs`

may be either a one-dimensional or a two-dimensional array.

If Rhs is two-dimensional, they 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.dot(&b) == arr2(&[[5., 8.], [2., 3.]]) );

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

[src]

`fn scaled_add<S2, E>(&mut self, alpha: A, rhs: &ArrayBase<S2, E>) where S: DataMut, S2: Data<Elem = A>, A: LinalgScalar, E: Dimension`

Perform the operation `self += alpha * rhs`

efficiently, where
`alpha`

is a scalar and `rhs`

is another array. This operation is
also known as `axpy`

in BLAS.

If their shapes disagree, `rhs`

is broadcast to the shape of `self`

.

**Panics** if broadcasting isn’t possible.

`impl<'a, A, D> ArrayBase<ViewRepr<&'a A>, D> where D: Dimension`

[src]

# Methods Specific to Array Views

Methods for read-only array views `ArrayView<'a, A, D>`

Note that array views implement traits like `From`

and `IntoIterator`

too.

`fn from_shape<Sh>(shape: Sh, xs: &'a [A]) -> Result<Self, ShapeError> where Sh: Into<StrideShape<D>>`

Create a read-only array view borrowing its data from a slice.

Checks whether `shape`

are compatible with the slice's
length, returning an `Err`

if not compatible.

use ndarray::ArrayView; use ndarray::arr3; use ndarray::ShapeBuilder; let s = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]; let a = ArrayView::from_shape((2, 3, 2).strides((1, 4, 2)), &s).unwrap(); assert!( a == arr3(&[[[0, 2], [4, 6], [8, 10]], [[1, 3], [5, 7], [9, 11]]]) ); assert!(a.strides() == &[1, 4, 2]);

`unsafe fn from_shape_ptr<Sh>(shape: Sh, ptr: *const A) -> Self where Sh: Into<StrideShape<D>>`

Create an `ArrayView<A, D>`

from shape information and a
raw pointer to the elements.

Unsafe because caller is responsible for ensuring that the pointer is valid, not mutably aliased and coherent with the dimension and stride information.

`fn split_at(self, axis: Axis, index: Ix) -> (Self, Self)`

Split the array along `axis`

and return one view strictly before the
split and one view after the split.

**Panics** if `axis`

or `index`

is out of bounds.

Below, an illustration of `.split_at(Axis(2), 2)`

on
an array with shape 3 × 5 × 5.

`fn into_slice(&self) -> Option<&'a [A]>`

Return the array’s data as a slice, if it is contiguous and in standard order.
Return `None`

otherwise.

`impl<'a, A, D> ArrayBase<ViewRepr<&'a mut A>, D> where D: Dimension`

[src]

Methods for read-write array views `ArrayViewMut<'a, A, D>`

Note that array views implement traits like `From`

and `IntoIterator`

too.

`fn from_shape<Sh>(shape: Sh, xs: &'a mut [A]) -> Result<Self, ShapeError> where Sh: Into<StrideShape<D>>`

Create a read-write array view borrowing its data from a slice.

Checks whether `dim`

and `strides`

are compatible with the slice's
length, returning an `Err`

if not compatible.

use ndarray::ArrayViewMut; use ndarray::arr3; use ndarray::ShapeBuilder; let mut s = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]; let mut a = ArrayViewMut::from_shape((2, 3, 2).strides((1, 4, 2)), &mut s).unwrap(); a[[0, 0, 0]] = 1; assert!( a == arr3(&[[[1, 2], [4, 6], [8, 10]], [[1, 3], [5, 7], [9, 11]]]) ); assert!(a.strides() == &[1, 4, 2]);

`unsafe fn from_shape_ptr<Sh>(shape: Sh, ptr: *mut A) -> Self where Sh: Into<StrideShape<D>>`

Create an `ArrayViewMut<A, D>`

from shape information and a
raw pointer to the elements.

Unsafe because caller is responsible for ensuring that the pointer is valid, not aliased and coherent with the dimension and stride information.

`fn split_at(self, axis: Axis, index: Ix) -> (Self, Self)`

Split the array along `axis`

and return one mutable view strictly
before the split and one mutable view after the split.

**Panics** if `axis`

or `index`

is out of bounds.

`fn into_slice(self) -> Option<&'a mut [A]>`

`None`

otherwise.

## Trait Implementations

`impl<S, D, I> Index<I> for ArrayBase<S, D> where D: Dimension,`

I: NdIndex<D>,

S: Data

[src]

I: NdIndex<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 (`container[index]`

) operation

`impl<S, D, I> IndexMut<I> for ArrayBase<S, D> where D: Dimension,`

I: NdIndex<D>,

S: DataMut

[src]

I: NdIndex<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 mutable indexing (`container[index]`

) 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

[src]

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 `==`

. Read more

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

1.0.0

This method tests for `!=`

.

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

[src]

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

[src]

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

Creates a value from an iterator. Read more

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

[src]

`type Item = &'a S::Elem`

The type of the elements being iterated over.

`type IntoIter = Iter<'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. Read more

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

S: DataMut

[src]

S: DataMut

`type Item = &'a mut S::Elem`

The type of the elements being iterated over.

`type IntoIter = IterMut<'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. Read more

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

S: Data,

S::Elem: Hash

[src]

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`

1.3.0

Feeds a slice of this type into the state provided.

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

[src]

`ArrayBase`

is `Sync`

when the storage type is.

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

[src]

`ArrayBase`

is `Send`

when the storage type is.

`impl<'a, A, Slice: ?Sized> From<&'a Slice> for ArrayBase<ViewRepr<&'a A>, Ix1> where Slice: AsRef<[A]>`

[src]

Implementation of `ArrayView::from(&S)`

where `S`

is a slice or slicable.

Create a one-dimensional read-only array view of the data in `slice`

.

`fn from(slice: &'a Slice) -> Self`

Performs the conversion.

`impl<'a, A, S, D> From<&'a ArrayBase<S, D>> for ArrayBase<ViewRepr<&'a A>, D> where S: Data<Elem = A>,`

D: Dimension

[src]

D: Dimension

Implementation of `ArrayView::from(&A)`

where `A`

is an array.

Create a read-only array view of the array.

`impl<'a, A, Slice: ?Sized> From<&'a mut Slice> for ArrayBase<ViewRepr<&'a mut A>, Ix1> where Slice: AsMut<[A]>`

[src]

Implementation of `ArrayViewMut::from(&mut S)`

where `S`

is a slice or slicable.

Create a one-dimensional read-write array view of the data in `slice`

.

`fn from(slice: &'a mut Slice) -> Self`

Performs the conversion.

`impl<'a, A, S, D> From<&'a mut ArrayBase<S, D>> for ArrayBase<ViewRepr<&'a mut A>, D> where S: DataMut<Elem = A>,`

D: Dimension

[src]

D: Dimension

Implementation of `ArrayViewMut::from(&mut A)`

where `A`

is an array.

Create a read-write array view of the array.

`impl<A, S, D> Default for ArrayBase<S, D> where S: DataOwned<Elem = A>,`

D: Dimension,

A: Default

[src]

D: Dimension,

A: Default

Create an owned array with a default state.

The array is created with dimension `D::default()`

, which results
in for example dimensions `0`

and `(0, 0)`

with zero elements for the
one-dimensional and two-dimensional cases respectively, while for example
the zero dimensional case uses `()`

(or `Vec::new()`

) which
results in an array with one element.

Since arrays cannot grow, the intention is to use the default value as placeholder.

`impl<A, D, S> Serialize for ArrayBase<S, D> where A: Serialize,`

D: Dimension + Serialize,

S: Data<Elem = A>

[src]

D: Dimension + Serialize,

S: Data<Elem = A>

**Requires crate feature "serde"**

`fn serialize<Se>(&self, serializer: Se) -> Result<Se::Ok, Se::Error> where Se: Serializer`

Serialize this value into the given Serde serializer. Read more

`impl<A, Di, S> Deserialize for ArrayBase<S, Di> where A: Deserialize,`

Di: Deserialize + Dimension,

S: DataOwned<Elem = A>

[src]

Di: Deserialize + Dimension,

S: DataOwned<Elem = A>

**Requires crate feature "serde"**

`fn deserialize<D>(deserializer: D) -> Result<ArrayBase<S, Di>, D::Error> where D: Deserializer`

Deserialize this value from the given Serde deserializer. Read more

`impl<A, S, D> Encodable for ArrayBase<S, D> where A: Encodable,`

D: Dimension + Encodable,

S: Data<Elem = A>

[src]

D: Dimension + Encodable,

S: Data<Elem = A>

**Requires crate feature "rustc-serialize"**

`impl<A, S, D> Decodable for ArrayBase<S, D> where A: Decodable,`

D: Dimension + Decodable,

S: DataOwned<Elem = A>

[src]

D: Dimension + Decodable,

S: DataOwned<Elem = A>

**Requires crate feature "rustc-serialize"**

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

[src]

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, `{:#}`

.

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

[src]

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, `{:#?}`

.

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

[src]

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}`

.

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

[src]

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}`

.

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

[src]

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}`

.

`impl<'a, A: 'a, S, D> IntoNdProducer for &'a ArrayBase<S, D> where D: Dimension,`

S: Data<Elem = A>

[src]

S: Data<Elem = A>

An array reference is an n-dimensional producer of element references (like ArrayView).

`impl<'a, A: 'a, S, D> IntoNdProducer for &'a mut ArrayBase<S, D> where D: Dimension,`

S: DataMut<Elem = A>

[src]

S: DataMut<Elem = A>

A mutable array reference is an n-dimensional producer of mutable element references (like ArrayViewMut).

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

[src]

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

Returns a copy of the value. Read more

`fn clone_from(&mut self, other: &Self)`

`Array`

implements `.clone_from()`

to reuse an array's existing
allocation. Semantically equivalent to `*self = other.clone()`

, but
potentially more efficient.

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

[src]

`impl<A, S, S2> Dot<ArrayBase<S2, Ix2>> for ArrayBase<S, Ix2> where S: Data<Elem = A>,`

S2: Data<Elem = A>,

A: LinalgScalar

[src]

S2: Data<Elem = A>,

A: LinalgScalar

`type Output = Array2<A>`

The result of the operation. Read more

`fn dot(&self, b: &ArrayBase<S2, Ix2>) -> Array2<A>`

`impl<A, S, S2> Dot<ArrayBase<S2, Ix1>> for ArrayBase<S, Ix2> where S: Data<Elem = A>,`

S2: Data<Elem = A>,

A: LinalgScalar

[src]

S2: Data<Elem = A>,

A: LinalgScalar

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.

`type Output = Array<A, Ix1>`

The result of the operation. Read more

`fn dot(&self, rhs: &ArrayBase<S2, Ix1>) -> Array<A, Ix1>`

`impl<A, S, S2, D, E> Add<ArrayBase<S2, E>> for ArrayBase<S, D> where A: Clone + Add<A, Output = A>,`

S: DataOwned<Elem = A> + DataMut,

S2: Data<Elem = A>,

D: Dimension,

E: Dimension

[src]

S: DataOwned<Elem = A> + DataMut,

S2: Data<Elem = A>,

D: Dimension,

E: Dimension

Perform elementwise
addition
between `self`

and `rhs`

,
and return the result (based on `self`

).

`self`

must be an `Array`

or `RcArray`

.

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

[src]

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, 'b, A, S, S2, D, E> Add<&'a ArrayBase<S2, E>> for &'b ArrayBase<S, D> where A: Clone + Add<A, Output = A>,`

S: Data<Elem = A>,

S2: Data<Elem = A>,

D: Dimension,

E: Dimension

[src]

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 `Array`

.

If their shapes disagree, `rhs`

is broadcast to the shape of `self`

.

**Panics** if broadcasting isn’t possible.

`type Output = Array<A, D>`

The resulting type after applying the `+`

operator

`fn add(self, rhs: &'a ArrayBase<S2, E>) -> Array<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: DataOwned<Elem = A> + DataMut,

D: Dimension,

B: ScalarOperand

[src]

S: DataOwned<Elem = A> + DataMut,

D: Dimension,

B: ScalarOperand

Perform elementwise
addition
between `self`

and the scalar `x`

,
and return the result (based on `self`

).

`self`

must be an `Array`

or `RcArray`

.

`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: ScalarOperand

[src]

S: Data<Elem = A>,

D: Dimension,

B: ScalarOperand

Perform elementwise
addition
between the reference `self`

and the scalar `x`

,
and return the result as a new `Array`

.

`type Output = Array<A, D>`

The resulting type after applying the `+`

operator

`fn add(self, x: B) -> Array<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: DataOwned<Elem = A> + DataMut,

S2: Data<Elem = A>,

D: Dimension,

E: Dimension

[src]

S: DataOwned<Elem = A> + DataMut,

S2: Data<Elem = A>,

D: Dimension,

E: Dimension

Perform elementwise
subtraction
between `self`

and `rhs`

,
and return the result (based on `self`

).

`self`

must be an `Array`

or `RcArray`

.

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

[src]

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, 'b, A, S, S2, D, E> Sub<&'a ArrayBase<S2, E>> for &'b ArrayBase<S, D> where A: Clone + Sub<A, Output = A>,`

S: Data<Elem = A>,

S2: Data<Elem = A>,

D: Dimension,

E: Dimension

[src]

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 `Array`

.

If their shapes disagree, `rhs`

is broadcast to the shape of `self`

.

**Panics** if broadcasting isn’t possible.

`type Output = Array<A, D>`

The resulting type after applying the `-`

operator

`fn sub(self, rhs: &'a ArrayBase<S2, E>) -> Array<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: DataOwned<Elem = A> + DataMut,

D: Dimension,

B: ScalarOperand

[src]

S: DataOwned<Elem = A> + DataMut,

D: Dimension,

B: ScalarOperand

Perform elementwise
subtraction
between `self`

and the scalar `x`

,
and return the result (based on `self`

).

`self`

must be an `Array`

or `RcArray`

.

`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: ScalarOperand

[src]

S: Data<Elem = A>,

D: Dimension,

B: ScalarOperand

Perform elementwise
subtraction
between the reference `self`

and the scalar `x`

,
and return the result as a new `Array`

.

`type Output = Array<A, D>`

The resulting type after applying the `-`

operator

`fn sub(self, x: B) -> Array<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: DataOwned<Elem = A> + DataMut,

S2: Data<Elem = A>,

D: Dimension,

E: Dimension

[src]

S: DataOwned<Elem = A> + DataMut,

S2: Data<Elem = A>,

D: Dimension,

E: Dimension

Perform elementwise
multiplication
between `self`

and `rhs`

,
and return the result (based on `self`

).

`self`

must be an `Array`

or `RcArray`

.

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

[src]

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, 'b, A, S, S2, D, E> Mul<&'a ArrayBase<S2, E>> for &'b ArrayBase<S, D> where A: Clone + Mul<A, Output = A>,`

S: Data<Elem = A>,

S2: Data<Elem = A>,

D: Dimension,

E: Dimension

[src]

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 `Array`

.

If their shapes disagree, `rhs`

is broadcast to the shape of `self`

.

**Panics** if broadcasting isn’t possible.

`type Output = Array<A, D>`

The resulting type after applying the `*`

operator

`fn mul(self, rhs: &'a ArrayBase<S2, E>) -> Array<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: DataOwned<Elem = A> + DataMut,

D: Dimension,

B: ScalarOperand

[src]

S: DataOwned<Elem = A> + DataMut,

D: Dimension,

B: ScalarOperand

Perform elementwise
multiplication
between `self`

and the scalar `x`

,
and return the result (based on `self`

).

`self`

must be an `Array`

or `RcArray`

.

`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: ScalarOperand

[src]

S: Data<Elem = A>,

D: Dimension,

B: ScalarOperand

Perform elementwise
multiplication
between the reference `self`

and the scalar `x`

,
and return the result as a new `Array`

.

`type Output = Array<A, D>`

The resulting type after applying the `*`

operator

`fn mul(self, x: B) -> Array<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: DataOwned<Elem = A> + DataMut,

S2: Data<Elem = A>,

D: Dimension,

E: Dimension

[src]

S: DataOwned<Elem = A> + DataMut,

S2: Data<Elem = A>,

D: Dimension,

E: Dimension

Perform elementwise
division
between `self`

and `rhs`

,
and return the result (based on `self`

).

`self`

must be an `Array`

or `RcArray`

.

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

[src]

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, 'b, A, S, S2, D, E> Div<&'a ArrayBase<S2, E>> for &'b ArrayBase<S, D> where A: Clone + Div<A, Output = A>,`

S: Data<Elem = A>,

S2: Data<Elem = A>,

D: Dimension,

E: Dimension

[src]

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 `Array`

.

If their shapes disagree, `rhs`

is broadcast to the shape of `self`

.

**Panics** if broadcasting isn’t possible.

`type Output = Array<A, D>`

The resulting type after applying the `/`

operator

`fn div(self, rhs: &'a ArrayBase<S2, E>) -> Array<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: DataOwned<Elem = A> + DataMut,

D: Dimension,

B: ScalarOperand

[src]

S: DataOwned<Elem = A> + DataMut,

D: Dimension,

B: ScalarOperand

Perform elementwise
division
between `self`

and the scalar `x`

,
and return the result (based on `self`

).

`self`

must be an `Array`

or `RcArray`

.

`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: ScalarOperand

[src]

S: Data<Elem = A>,

D: Dimension,

B: ScalarOperand

Perform elementwise
division
between the reference `self`

and the scalar `x`

,
and return the result as a new `Array`

.

`type Output = Array<A, D>`

The resulting type after applying the `/`

operator

`fn div(self, x: B) -> Array<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: DataOwned<Elem = A> + DataMut,

S2: Data<Elem = A>,

D: Dimension,

E: Dimension

[src]

S: DataOwned<Elem = A> + DataMut,

S2: Data<Elem = A>,

D: Dimension,

E: Dimension

Perform elementwise
remainder
between `self`

and `rhs`

,
and return the result (based on `self`

).

`self`

must be an `Array`

or `RcArray`

.

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

[src]

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, 'b, A, S, S2, D, E> Rem<&'a ArrayBase<S2, E>> for &'b ArrayBase<S, D> where A: Clone + Rem<A, Output = A>,`

S: Data<Elem = A>,

S2: Data<Elem = A>,

D: Dimension,

E: Dimension

[src]

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 `Array`

.

If their shapes disagree, `rhs`

is broadcast to the shape of `self`

.

**Panics** if broadcasting isn’t possible.

`type Output = Array<A, D>`

The resulting type after applying the `%`

operator

`fn rem(self, rhs: &'a ArrayBase<S2, E>) -> Array<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: DataOwned<Elem = A> + DataMut,

D: Dimension,

B: ScalarOperand

[src]

S: DataOwned<Elem = A> + DataMut,

D: Dimension,

B: ScalarOperand

Perform elementwise
remainder
between `self`

and the scalar `x`

,
and return the result (based on `self`

).

`self`

must be an `Array`

or `RcArray`

.

`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: ScalarOperand

[src]

S: Data<Elem = A>,

D: Dimension,

B: ScalarOperand

Perform elementwise
remainder
between the reference `self`

and the scalar `x`

,
and return the result as a new `Array`

.

`type Output = Array<A, D>`

The resulting type after applying the `%`

operator

`fn rem(self, x: B) -> Array<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: DataOwned<Elem = A> + DataMut,

S2: Data<Elem = A>,

D: Dimension,

E: Dimension

[src]

S: DataOwned<Elem = A> + DataMut,

S2: Data<Elem = A>,

D: Dimension,

E: Dimension

Perform elementwise
bit and
between `self`

and `rhs`

,
and return the result (based on `self`

).

`self`

must be an `Array`

or `RcArray`

.

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

[src]

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, 'b, A, S, S2, D, E> BitAnd<&'a ArrayBase<S2, E>> for &'b ArrayBase<S, D> where A: Clone + BitAnd<A, Output = A>,`

S: Data<Elem = A>,

S2: Data<Elem = A>,

D: Dimension,

E: Dimension

[src]

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 `Array`

.

If their shapes disagree, `rhs`

is broadcast to the shape of `self`

.

**Panics** if broadcasting isn’t possible.

`type Output = Array<A, D>`

The resulting type after applying the `&`

operator

`fn bitand(self, rhs: &'a ArrayBase<S2, E>) -> Array<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: DataOwned<Elem = A> + DataMut,

D: Dimension,

B: ScalarOperand

[src]

S: DataOwned<Elem = A> + DataMut,

D: Dimension,

B: ScalarOperand

Perform elementwise
bit and
between `self`

and the scalar `x`

,
and return the result (based on `self`

).

`self`

must be an `Array`

or `RcArray`

.

`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: ScalarOperand

[src]

S: Data<Elem = A>,

D: Dimension,

B: ScalarOperand

Perform elementwise
bit and
between the reference `self`

and the scalar `x`

,
and return the result as a new `Array`

.

`type Output = Array<A, D>`

The resulting type after applying the `&`

operator

`fn bitand(self, x: B) -> Array<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: DataOwned<Elem = A> + DataMut,

S2: Data<Elem = A>,

D: Dimension,

E: Dimension

[src]

S: DataOwned<Elem = A> + DataMut,

S2: Data<Elem = A>,

D: Dimension,

E: Dimension

Perform elementwise
bit or
between `self`

and `rhs`

,
and return the result (based on `self`

).

`self`

must be an `Array`

or `RcArray`

.

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

[src]

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, 'b, A, S, S2, D, E> BitOr<&'a ArrayBase<S2, E>> for &'b ArrayBase<S, D> where A: Clone + BitOr<A, Output = A>,`

S: Data<Elem = A>,

S2: Data<Elem = A>,

D: Dimension,

E: Dimension

[src]

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 `Array`

.

If their shapes disagree, `rhs`

is broadcast to the shape of `self`

.

**Panics** if broadcasting isn’t possible.

`type Output = Array<A, D>`

The resulting type after applying the `|`

operator

`fn bitor(self, rhs: &'a ArrayBase<S2, E>) -> Array<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: DataOwned<Elem = A> + DataMut,

D: Dimension,

B: ScalarOperand

[src]

S: DataOwned<Elem = A> + DataMut,

D: Dimension,

B: ScalarOperand

Perform elementwise
bit or
between `self`

and the scalar `x`

,
and return the result (based on `self`

).

`self`

must be an `Array`

or `RcArray`

.

`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: ScalarOperand

[src]

S: Data<Elem = A>,

D: Dimension,

B: ScalarOperand

Perform elementwise
bit or
between the reference `self`

and the scalar `x`

,
and return the result as a new `Array`

.

`type Output = Array<A, D>`

The resulting type after applying the `|`

operator

`fn bitor(self, x: B) -> Array<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: DataOwned<Elem = A> + DataMut,

S2: Data<Elem = A>,

D: Dimension,

E: Dimension

[src]

S: DataOwned<Elem = A> + DataMut,

S2: Data<Elem = A>,

D: Dimension,

E: Dimension

Perform elementwise
bit xor
between `self`

and `rhs`

,
and return the result (based on `self`

).

`self`

must be an `Array`

or `RcArray`

.

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

[src]

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, 'b, A, S, S2, D, E> BitXor<&'a ArrayBase<S2, E>> for &'b ArrayBase<S, D> where A: Clone + BitXor<A, Output = A>,`

S: Data<Elem = A>,

S2: Data<Elem = A>,

D: Dimension,

E: Dimension

[src]

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 `Array`

.

If their shapes disagree, `rhs`

is broadcast to the shape of `self`

.

**Panics** if broadcasting isn’t possible.

`type Output = Array<A, D>`

The resulting type after applying the `^`

operator

`fn bitxor(self, rhs: &'a ArrayBase<S2, E>) -> Array<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: DataOwned<Elem = A> + DataMut,

D: Dimension,

B: ScalarOperand

[src]

S: DataOwned<Elem = A> + DataMut,

D: Dimension,

B: ScalarOperand

Perform elementwise
bit xor
between `self`

and the scalar `x`

,
and return the result (based on `self`

).

`self`

must be an `Array`

or `RcArray`

.

`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: ScalarOperand

[src]

S: Data<Elem = A>,

D: Dimension,

B: ScalarOperand

Perform elementwise
bit xor
between the reference `self`

and the scalar `x`

,
and return the result as a new `Array`

.

`type Output = Array<A, D>`

The resulting type after applying the `^`

operator

`fn bitxor(self, x: B) -> Array<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: DataOwned<Elem = A> + DataMut,

S2: Data<Elem = A>,

D: Dimension,

E: Dimension

[src]

S: DataOwned<Elem = A> + DataMut,

S2: Data<Elem = A>,

D: Dimension,

E: Dimension

Perform elementwise
left shift
between `self`

and `rhs`

,
and return the result (based on `self`

).

`self`

must be an `Array`

or `RcArray`

.

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

[src]

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, 'b, A, S, S2, D, E> Shl<&'a ArrayBase<S2, E>> for &'b ArrayBase<S, D> where A: Clone + Shl<A, Output = A>,`

S: Data<Elem = A>,

S2: Data<Elem = A>,

D: Dimension,

E: Dimension

[src]

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 `Array`

.

If their shapes disagree, `rhs`

is broadcast to the shape of `self`

.

**Panics** if broadcasting isn’t possible.

`type Output = Array<A, D>`

The resulting type after applying the `<<`

operator

`fn shl(self, rhs: &'a ArrayBase<S2, E>) -> Array<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: DataOwned<Elem = A> + DataMut,

D: Dimension,

B: ScalarOperand

[src]

S: DataOwned<Elem = A> + DataMut,

D: Dimension,

B: ScalarOperand

Perform elementwise
left shift
between `self`

and the scalar `x`

,
and return the result (based on `self`

).

`self`

must be an `Array`

or `RcArray`

.

`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: ScalarOperand

[src]

S: Data<Elem = A>,

D: Dimension,

B: ScalarOperand

Perform elementwise
left shift
between the reference `self`

and the scalar `x`

,
and return the result as a new `Array`

.

`type Output = Array<A, D>`

The resulting type after applying the `<<`

operator

`fn shl(self, x: B) -> Array<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: DataOwned<Elem = A> + DataMut,

S2: Data<Elem = A>,

D: Dimension,

E: Dimension

[src]

S: DataOwned<Elem = A> + DataMut,

S2: Data<Elem = A>,

D: Dimension,

E: Dimension

Perform elementwise
right shift
between `self`

and `rhs`

,
and return the result (based on `self`

).

`self`

must be an `Array`

or `RcArray`

.

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

[src]

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, 'b, A, S, S2, D, E> Shr<&'a ArrayBase<S2, E>> for &'b ArrayBase<S, D> where A: Clone + Shr<A, Output = A>,`

S: Data<Elem = A>,

S2: Data<Elem = A>,

D: Dimension,

E: Dimension

[src]

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 `Array`

.

If their shapes disagree, `rhs`

is broadcast to the shape of `self`

.

**Panics** if broadcasting isn’t possible.

`type Output = Array<A, D>`

The resulting type after applying the `>>`

operator

`fn shr(self, rhs: &'a ArrayBase<S2, E>) -> Array<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: DataOwned<Elem = A> + DataMut,

D: Dimension,

B: ScalarOperand

[src]

S: DataOwned<Elem = A> + DataMut,

D: Dimension,

B: ScalarOperand

Perform elementwise
right shift
between `self`

and the scalar `x`

,
and return the result (based on `self`

).

`self`

must be an `Array`

or `RcArray`

.

`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: ScalarOperand

[src]

S: Data<Elem = A>,

D: Dimension,

B: ScalarOperand

Perform elementwise
right shift
between the reference `self`

and the scalar `x`

,
and return the result as a new `Array`

.

`type Output = Array<A, D>`

The resulting type after applying the `>>`

operator

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

The method for the `>>`

operator

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

S: DataOwned<Elem = A> + DataMut,

D: Dimension

[src]

S: DataOwned<Elem = A> + DataMut,

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: DataOwned<Elem = A> + DataMut,

D: Dimension

[src]

S: DataOwned<Elem = A> + DataMut,

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<'a, A, S, S2, D, E> AddAssign<&'a ArrayBase<S2, E>> for ArrayBase<S, D> where A: Clone + AddAssign<A>,`

S: DataMut<Elem = A>,

S2: Data<Elem = A>,

D: Dimension,

E: Dimension

[src]

S: DataMut<Elem = A>,

S2: Data<Elem = A>,

D: Dimension,

E: Dimension

Perform `self += rhs`

as elementwise addition (in place).

If their shapes disagree, `rhs`

is broadcast to the shape of `self`

.

**Panics** if broadcasting isn’t possible.

`fn add_assign(&mut self, rhs: &ArrayBase<S2, E>)`

The method for the `+=`

operator

`impl<A, S, D> AddAssign<A> for ArrayBase<S, D> where A: ScalarOperand + AddAssign<A>,`

S: DataMut<Elem = A>,

D: Dimension

[src]

S: DataMut<Elem = A>,

D: Dimension

Perform `self += rhs`

as elementwise addition (in place).

`fn add_assign(&mut self, rhs: A)`

The method for the `+=`

operator

`impl<'a, A, S, S2, D, E> SubAssign<&'a ArrayBase<S2, E>> for ArrayBase<S, D> where A: Clone + SubAssign<A>,`

S: DataMut<Elem = A>,

S2: Data<Elem = A>,

D: Dimension,

E: Dimension

[src]

S: DataMut<Elem = A>,

S2: Data<Elem = A>,

D: Dimension,

E: Dimension

Perform `self -= rhs`

as elementwise subtraction (in place).

If their shapes disagree, `rhs`

is broadcast to the shape of `self`

.

**Panics** if broadcasting isn’t possible.

`fn sub_assign(&mut self, rhs: &ArrayBase<S2, E>)`

The method for the `-=`

operator

`impl<A, S, D> SubAssign<A> for ArrayBase<S, D> where A: ScalarOperand + SubAssign<A>,`

S: DataMut<Elem = A>,

D: Dimension

[src]

S: DataMut<Elem = A>,

D: Dimension

Perform `self -= rhs`

as elementwise subtraction (in place).

`fn sub_assign(&mut self, rhs: A)`

The method for the `-=`

operator

`impl<'a, A, S, S2, D, E> MulAssign<&'a ArrayBase<S2, E>> for ArrayBase<S, D> where A: Clone + MulAssign<A>,`

S: DataMut<Elem = A>,

S2: Data<Elem = A>,

D: Dimension,

E: Dimension

[src]

S: DataMut<Elem = A>,

S2: Data<Elem = A>,

D: Dimension,

E: Dimension

Perform `self *= rhs`

as elementwise multiplication (in place).

If their shapes disagree, `rhs`

is broadcast to the shape of `self`

.

**Panics** if broadcasting isn’t possible.

`fn mul_assign(&mut self, rhs: &ArrayBase<S2, E>)`

The method for the `*=`

operator

`impl<A, S, D> MulAssign<A> for ArrayBase<S, D> where A: ScalarOperand + MulAssign<A>,`

S: DataMut<Elem = A>,

D: Dimension

[src]

S: DataMut<Elem = A>,

D: Dimension

Perform `self *= rhs`

as elementwise multiplication (in place).

`fn mul_assign(&mut self, rhs: A)`

The method for the `*=`

operator

`impl<'a, A, S, S2, D, E> DivAssign<&'a ArrayBase<S2, E>> for ArrayBase<S, D> where A: Clone + DivAssign<A>,`

S: DataMut<Elem = A>,

S2: Data<Elem = A>,

D: Dimension,

E: Dimension

[src]

S: DataMut<Elem = A>,

S2: Data<Elem = A>,

D: Dimension,

E: Dimension

Perform `self /= rhs`

as elementwise division (in place).

If their shapes disagree, `rhs`

is broadcast to the shape of `self`

.

**Panics** if broadcasting isn’t possible.

`fn div_assign(&mut self, rhs: &ArrayBase<S2, E>)`

The method for the `/=`

operator

`impl<A, S, D> DivAssign<A> for ArrayBase<S, D> where A: ScalarOperand + DivAssign<A>,`

S: DataMut<Elem = A>,

D: Dimension

[src]

S: DataMut<Elem = A>,

D: Dimension

Perform `self /= rhs`

as elementwise division (in place).

`fn div_assign(&mut self, rhs: A)`

The method for the `/=`

operator

`impl<'a, A, S, S2, D, E> RemAssign<&'a ArrayBase<S2, E>> for ArrayBase<S, D> where A: Clone + RemAssign<A>,`

S: DataMut<Elem = A>,

S2: Data<Elem = A>,

D: Dimension,

E: Dimension

[src]

S: DataMut<Elem = A>,

S2: Data<Elem = A>,

D: Dimension,

E: Dimension

Perform `self %= rhs`

as elementwise remainder (in place).

If their shapes disagree, `rhs`

is broadcast to the shape of `self`

.

**Panics** if broadcasting isn’t possible.

`fn rem_assign(&mut self, rhs: &ArrayBase<S2, E>)`

The method for the `%=`

operator

`impl<A, S, D> RemAssign<A> for ArrayBase<S, D> where A: ScalarOperand + RemAssign<A>,`

S: DataMut<Elem = A>,

D: Dimension

[src]

S: DataMut<Elem = A>,

D: Dimension

Perform `self %= rhs`

as elementwise remainder (in place).

`fn rem_assign(&mut self, rhs: A)`

The method for the `%=`

operator

`impl<'a, A, S, S2, D, E> BitAndAssign<&'a ArrayBase<S2, E>> for ArrayBase<S, D> where A: Clone + BitAndAssign<A>,`

S: DataMut<Elem = A>,

S2: Data<Elem = A>,

D: Dimension,

E: Dimension

[src]

S: DataMut<Elem = A>,

S2: Data<Elem = A>,

D: Dimension,

E: Dimension

Perform `self &= rhs`

as elementwise bit and (in place).

If their shapes disagree, `rhs`

is broadcast to the shape of `self`

.

**Panics** if broadcasting isn’t possible.

`fn bitand_assign(&mut self, rhs: &ArrayBase<S2, E>)`

The method for the `&=`

operator

`impl<A, S, D> BitAndAssign<A> for ArrayBase<S, D> where A: ScalarOperand + BitAndAssign<A>,`

S: DataMut<Elem = A>,

D: Dimension

[src]

S: DataMut<Elem = A>,

D: Dimension

Perform `self &= rhs`

as elementwise bit and (in place).

`fn bitand_assign(&mut self, rhs: A)`

The method for the `&=`

operator

`impl<'a, A, S, S2, D, E> BitOrAssign<&'a ArrayBase<S2, E>> for ArrayBase<S, D> where A: Clone + BitOrAssign<A>,`

S: DataMut<Elem = A>,

S2: Data<Elem = A>,

D: Dimension,

E: Dimension

[src]

S: DataMut<Elem = A>,

S2: Data<Elem = A>,

D: Dimension,

E: Dimension

Perform `self |= rhs`

as elementwise bit or (in place).

If their shapes disagree, `rhs`

is broadcast to the shape of `self`

.

**Panics** if broadcasting isn’t possible.

`fn bitor_assign(&mut self, rhs: &ArrayBase<S2, E>)`

The method for the `|=`

operator

`impl<A, S, D> BitOrAssign<A> for ArrayBase<S, D> where A: ScalarOperand + BitOrAssign<A>,`

S: DataMut<Elem = A>,

D: Dimension

[src]

S: DataMut<Elem = A>,

D: Dimension

Perform `self |= rhs`

as elementwise bit or (in place).

`fn bitor_assign(&mut self, rhs: A)`

The method for the `|=`

operator

`impl<'a, A, S, S2, D, E> BitXorAssign<&'a ArrayBase<S2, E>> for ArrayBase<S, D> where A: Clone + BitXorAssign<A>,`

S: DataMut<Elem = A>,

S2: Data<Elem = A>,

D: Dimension,

E: Dimension

[src]

S: DataMut<Elem = A>,

S2: Data<Elem = A>,

D: Dimension,

E: Dimension

Perform `self ^= rhs`

as elementwise bit xor (in place).

If their shapes disagree, `rhs`

is broadcast to the shape of `self`

.

**Panics** if broadcasting isn’t possible.

`fn bitxor_assign(&mut self, rhs: &ArrayBase<S2, E>)`

The method for the `^=`

operator

`impl<A, S, D> BitXorAssign<A> for ArrayBase<S, D> where A: ScalarOperand + BitXorAssign<A>,`

S: DataMut<Elem = A>,

D: Dimension

[src]

S: DataMut<Elem = A>,

D: Dimension

Perform `self ^= rhs`

as elementwise bit xor (in place).

`fn bitxor_assign(&mut self, rhs: A)`

The method for the `^=`

operator

`impl<'a, A, S, S2, D, E> ShlAssign<&'a ArrayBase<S2, E>> for ArrayBase<S, D> where A: Clone + ShlAssign<A>,`

S: DataMut<Elem = A>,

S2: Data<Elem = A>,

D: Dimension,

E: Dimension

[src]

S: DataMut<Elem = A>,

S2: Data<Elem = A>,

D: Dimension,

E: Dimension

Perform `self <<= rhs`

as elementwise left shift (in place).

If their shapes disagree, `rhs`

is broadcast to the shape of `self`

.

**Panics** if broadcasting isn’t possible.

`fn shl_assign(&mut self, rhs: &ArrayBase<S2, E>)`

The method for the `<<=`

operator

`impl<A, S, D> ShlAssign<A> for ArrayBase<S, D> where A: ScalarOperand + ShlAssign<A>,`

S: DataMut<Elem = A>,

D: Dimension

[src]

S: DataMut<Elem = A>,

D: Dimension

Perform `self <<= rhs`

as elementwise left shift (in place).

`fn shl_assign(&mut self, rhs: A)`

The method for the `<<=`

operator

`impl<'a, A, S, S2, D, E> ShrAssign<&'a ArrayBase<S2, E>> for ArrayBase<S, D> where A: Clone + ShrAssign<A>,`

S: DataMut<Elem = A>,

S2: Data<Elem = A>,

D: Dimension,

E: Dimension

[src]

S: DataMut<Elem = A>,

S2: Data<Elem = A>,

D: Dimension,

E: Dimension

Perform `self >>= rhs`

as elementwise right shift (in place).

If their shapes disagree, `rhs`

is broadcast to the shape of `self`

.

**Panics** if broadcasting isn’t possible.

`fn shr_assign(&mut self, rhs: &ArrayBase<S2, E>)`

The method for the `>>=`

operator

`impl<A, S, D> ShrAssign<A> for ArrayBase<S, D> where A: ScalarOperand + ShrAssign<A>,`

S: DataMut<Elem = A>,

D: Dimension

[src]

S: DataMut<Elem = A>,

D: Dimension

Perform `self >>= rhs`

as elementwise right shift (in place).

`fn shr_assign(&mut self, rhs: A)`

The method for the `>>=`

operator