Struct extendr_api::prelude::prelude::ArrayBase

source ·

pub struct ArrayBase<S, D>where
    S: RawData,{
    pub(crate) data: S,
    pub(crate) ptr: NonNull<<S as RawData>::Elem>,
    pub(crate) dim: D,
    pub(crate) strides: D,
}

Expand description

An n-dimensional array.

The array is a general container of elements. The array supports arithmetic operations by applying them elementwise, if the elements are numeric, but it supports non-numeric elements too.

The arrays rarely grow or shrink, since those operations can be costly. On the other hand there is a rich set of methods and operations for taking views, slices, and making traversals over one or more arrays.

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

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

Type aliases Array, ArcArray, CowArray, ArrayView, and ArrayViewMut refer to ArrayBase with different types for the data container: arrays with different kinds of ownership or different kinds of array views.

§Contents

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

§`Array`

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

An example:

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

§`ArcArray`

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

§`CowArray`

CowArray is analogous to std::borrow::Cow. It can represent either an immutable view or a uniquely owned array. If a CowArray instance is the immutable view variant, then calling a method for mutating elements in the array will cause it to be converted into the owned variant (by cloning all the elements) before the modification is performed.

§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 way as the other array types.

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

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

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

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

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

§Indexing and Dimension

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

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

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

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

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

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

Important traits and types for dimension and indexing:

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

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

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

§Loops, Producers and Iterators

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

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

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

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

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

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

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

These iterators produce array views of one smaller dimension.

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

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

The outer_iter and axis_iter are one dimensional producers.

§`.rows()`, `.columns()` and `.lanes()`

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

use ndarray::Array;

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

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

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

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

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

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

All methods: .rows(), .rows_mut(), .columns(), .columns_mut(), .lanes(axis), .lanes_mut(axis).

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

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

§Slicing

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

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

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

When slicing arrays with generic dimensionality, creating an instance of SliceInfo to pass to the multi-axis slicing methods like .slice() is awkward. In these cases, it’s usually more convenient to use .slice_each_axis()/.slice_each_axis_mut()/.slice_each_axis_inplace() or to create a view and then slice individual axes of the view using methods such as .slice_axis_inplace() and .collapse_axis().

It’s possible to take multiple simultaneous mutable slices with .multi_slice_mut() or (for ArrayViewMut only) .multi_slice_move().

use ndarray::{arr2, arr3, s, ArrayBase, DataMut, Dimension, NewAxis, Slice};

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

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

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

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

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

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

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

// Let's take two disjoint, mutable slices of a matrix with
//
// - One containing all the even-index columns in the matrix
// - One containing all the odd-index columns in the matrix
let mut h = arr2(&[[0, 1, 2, 3],
                   [4, 5, 6, 7]]);
let (s0, s1) = h.multi_slice_mut((s![.., ..;2], s![.., 1..;2]));
let i = arr2(&[[0, 2],
               [4, 6]]);
let j = arr2(&[[1, 3],
               [5, 7]]);
assert_eq!(s0, i);
assert_eq!(s1, j);

// Generic function which assigns the specified value to the elements which
// have indices in the lower half along all axes.
fn fill_lower<S, D>(arr: &mut ArrayBase<S, D>, x: S::Elem)
where
    S: DataMut,
    S::Elem: Clone,
    D: Dimension,
{
    arr.slice_each_axis_mut(|ax| Slice::from(0..ax.len / 2)).fill(x);
}
fill_lower(&mut h, 9);
let k = arr2(&[[9, 9, 2, 3],
               [4, 5, 6, 7]]);
assert_eq!(h, k);

§Subviews

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

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

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


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


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

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

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

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

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

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

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

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

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

§Arithmetic Operations

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

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

§Binary Operators with Two Arrays

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

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

Note that the element type needs to implement the operator trait and the Clone trait.

use ndarray::{array, ArrayView1};

let owned1 = array![1, 2];
let owned2 = array![3, 4];
let view1 = ArrayView1::from(&[5, 6]);
let view2 = ArrayView1::from(&[7, 8]);
let mut mutable = array![9, 10];

let sum1 = &view1 + &view2;   // Allocates a new array. Note the explicit `&`.
// let sum2 = view1 + &view2; // This doesn't work because `view1` is not an owned array.
let sum3 = owned1 + view1;    // Consumes `owned1`, updates it, and returns it.
let sum4 = owned2 + &view2;   // Consumes `owned2`, updates it, and returns it.
mutable += &view2;            // Updates `mutable` in-place.

§Binary Operators with Array and Scalar

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

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

§Unary Operators

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

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

§Broadcasting

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

use ndarray::arr2;

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

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

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

§Conversions

§Conversions Between Array Types

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

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

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

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

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

¹Returns the data in memory order.

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

³Works only if the array is contiguous.

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

§Conversions from Nested `Vec`s/`Array`s

It’s generally a good idea to avoid nested Vec/Array types, such as Vec<Vec<A>> or Vec<Array2<A>> because:

they require extra heap allocations compared to a single Array,
they can scatter data all over memory (because of multiple allocations),
they cause unnecessary indirection (traversing multiple pointers to reach the data),
they don’t enforce consistent shape within the nested Vecs/ArrayBases, and
they are generally more difficult to work with.

The most common case where users might consider using nested Vecs/Arrays is when creating an array by appending rows/subviews in a loop, where the rows/subviews are computed within the loop. However, there are better ways than using nested Vecs/Arrays.

If you know ahead-of-time the shape of the final array, the cleanest solution is to allocate the final array before the loop, and then assign the data to it within the loop, like this:

use ndarray::{array, Array2, Axis};

let mut arr = Array2::zeros((2, 3));
for (i, mut row) in arr.axis_iter_mut(Axis(0)).enumerate() {
    // Perform calculations and assign to `row`; this is a trivial example:
    row.fill(i);
}
assert_eq!(arr, array![[0, 0, 0], [1, 1, 1]]);

If you don’t know ahead-of-time the shape of the final array, then the cleanest solution is generally to append the data to a flat Vec, and then convert it to an Array at the end with ::from_shape_vec(). You just have to be careful that the layout of the data (the order of the elements in the flat Vec) is correct.

use ndarray::{array, Array2};

let ncols = 3;
let mut data = Vec::new();
let mut nrows = 0;
for i in 0..2 {
    // Compute `row` and append it to `data`; this is a trivial example:
    let row = vec![i; ncols];
    data.extend_from_slice(&row);
    nrows += 1;
}
let arr = Array2::from_shape_vec((nrows, ncols), data)?;
assert_eq!(arr, array![[0, 0, 0], [1, 1, 1]]);

If neither of these options works for you, and you really need to convert nested Vec/Array instances to an Array, the cleanest solution is generally to use Iterator::flatten() to get a flat Vec, and then convert the Vec to an Array with ::from_shape_vec(), like this:

use ndarray::{array, Array2, Array3};

let nested: Vec<Array2<i32>> = vec![
    array![[1, 2, 3], [4, 5, 6]],
    array![[7, 8, 9], [10, 11, 12]],
];
let inner_shape = nested[0].dim();
let shape = (nested.len(), inner_shape.0, inner_shape.1);
let flat: Vec<i32> = nested.iter().flatten().cloned().collect();
let arr = Array3::from_shape_vec(shape, flat)?;
assert_eq!(arr, array![
    [[1, 2, 3], [4, 5, 6]],
    [[7, 8, 9], [10, 11, 12]],
]);

Note that this implementation assumes that the nested Vecs are all the same shape and that the Vec is non-empty. Depending on your application, it may be a good idea to add checks for these assumptions and possibly choose a different way to handle the empty case.

Fields§

§data: S§ptr: NonNull<<S as RawData>::Elem>§dim: D§strides: D

Struct extendr_api::prelude::prelude::ArrayBase

§Contents

§Array

§ArcArray

§CowArray

§Array Views

§Indexing and Dimension

§Loops, Producers and Iterators

§.iter() and .iter_mut()

§.outer_iter() and .axis_iter()

§.rows(), .columns() and .lanes()

§Slicing

§Subviews

§Arithmetic Operations

§Binary Operators with Two Arrays

§Binary Operators with Array and Scalar

§Unary Operators

§Broadcasting

§Conversions

§Conversions Between Array Types

§Conversions Between Arrays and Vecs/Slices/Scalars

§Conversions from Nested Vecs/Arrays

Fields§

Implementations§

impl<S, A> ArrayBase<S, Dim<[usize; 1]>>where S: DataOwned<Elem = A>,

§Constructor Methods for Owned Arrays

§Constructor methods for one-dimensional arrays.

pub fn from_vec(v: Vec<A>) -> ArrayBase<S, Dim<[usize; 1]>>

pub fn from_iter<I>(iterable: I) -> ArrayBase<S, Dim<[usize; 1]>>where I: IntoIterator<Item = A>,

pub fn linspace(start: A, end: A, n: usize) -> ArrayBase<S, Dim<[usize; 1]>>where A: Float,

pub fn range(start: A, end: A, step: A) -> ArrayBase<S, Dim<[usize; 1]>>where A: Float,

pub fn logspace( base: A, start: A, end: A, n: usize ) -> ArrayBase<S, Dim<[usize; 1]>>where A: Float,

pub fn geomspace( start: A, end: A, n: usize ) -> Option<ArrayBase<S, Dim<[usize; 1]>>>where A: Float,

impl<S, A> ArrayBase<S, Dim<[usize; 2]>>where S: DataOwned<Elem = A>,

§Constructor methods for two-dimensional arrays.

pub fn eye(n: usize) -> ArrayBase<S, Dim<[usize; 2]>>where S: DataMut, A: Clone + Zero + One,

pub fn from_diag<S2>( diag: &ArrayBase<S2, Dim<[usize; 1]>> ) -> ArrayBase<S, Dim<[usize; 2]>>where A: Clone + Zero, S: DataMut, S2: Data<Elem = A>,

pub fn from_diag_elem(n: usize, elem: A) -> ArrayBase<S, Dim<[usize; 2]>>where S: DataMut, A: Clone + Zero,

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

§Constructor methods for n-dimensional arrays.

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

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

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

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

pub fn from_shape_simple_fn<Sh, F>(shape: Sh, f: F) -> ArrayBase<S, D>where Sh: ShapeBuilder<Dim = D>, F: FnMut() -> A,

pub fn from_shape_fn<Sh, F>(shape: Sh, f: F) -> ArrayBase<S, D>where Sh: ShapeBuilder<Dim = D>, F: FnMut(<D as Dimension>::Pattern) -> A,

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

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

§Safety

pub fn uninit<Sh>(shape: Sh) -> ArrayBase<<S as DataOwned>::MaybeUninit, D>where Sh: ShapeBuilder<Dim = D>,

§Safety

§Examples

pub fn build_uninit<Sh, F>( shape: Sh, builder: F ) -> ArrayBase<<S as DataOwned>::MaybeUninit, D>where Sh: ShapeBuilder<Dim = D>, F: FnOnce(ArrayBase<ViewRepr<&mut MaybeUninit<A>>, D>),

§Safety

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

§Safety

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

pub fn maybe_uninit<Sh>(shape: Sh) -> ArrayBase<S, D>where Sh: ShapeBuilder<Dim = D>,

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

§Methods For All Array Types

pub fn len(&self) -> usize

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

pub fn is_empty(&self) -> bool

pub fn ndim(&self) -> usize

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

pub fn raw_dim(&self) -> D

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

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

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

pub fn view(&self) -> ArrayBase<ViewRepr<&A>, D>where S: Data,

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

pub fn cell_view(&mut self) -> ArrayBase<ViewRepr<&MathCell<A>>, D>where S: DataMut,

pub fn to_owned(&self) -> ArrayBase<OwnedRepr<A>, D>where A: Clone, S: Data,

pub fn to_shared(&self) -> ArrayBase<OwnedArcRepr<A>, D>where A: Clone, S: Data,

pub fn into_owned(self) -> ArrayBase<OwnedRepr<A>, D>where A: Clone, S: Data,

pub fn try_into_owned_nocopy( self ) -> Result<ArrayBase<OwnedRepr<A>, D>, ArrayBase<S, D>>where S: Data,

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

pub fn first(&self) -> Option<&A>where S: Data,

§Example

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

§`Array`

§`ArcArray`

§`CowArray`

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

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

§`.rows()`, `.columns()` and `.lanes()`

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

§Conversions from Nested `Vec`s/`Array`s

impl<S, A> ArrayBase<S, Dim<[usize; 1]>>
where S: DataOwned<Elem = A>,

pub fn from_iter<I>(iterable: I) -> ArrayBase<S, Dim<[usize; 1]>>
where I: IntoIterator<Item = A>,

pub fn linspace(start: A, end: A, n: usize) -> ArrayBase<S, Dim<[usize; 1]>>
where A: Float,

pub fn range(start: A, end: A, step: A) -> ArrayBase<S, Dim<[usize; 1]>>
where A: Float,

pub fn logspace( base: A, start: A, end: A, n: usize ) -> ArrayBase<S, Dim<[usize; 1]>>
where A: Float,

pub fn geomspace( start: A, end: A, n: usize ) -> Option<ArrayBase<S, Dim<[usize; 1]>>>
where A: Float,

impl<S, A> ArrayBase<S, Dim<[usize; 2]>>
where S: DataOwned<Elem = A>,

pub fn eye(n: usize) -> ArrayBase<S, Dim<[usize; 2]>>
where S: DataMut, A: Clone + Zero + One,

pub fn from_diag<S2>( diag: &ArrayBase<S2, Dim<[usize; 1]>> ) -> ArrayBase<S, Dim<[usize; 2]>>
where A: Clone + Zero, S: DataMut, S2: Data<Elem = A>,

pub fn from_diag_elem(n: usize, elem: A) -> ArrayBase<S, Dim<[usize; 2]>>
where S: DataMut, A: Clone + Zero,

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

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

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

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

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

pub fn from_shape_simple_fn<Sh, F>(shape: Sh, f: F) -> ArrayBase<S, D>
where Sh: ShapeBuilder<Dim = D>, F: FnMut() -> A,

pub fn from_shape_fn<Sh, F>(shape: Sh, f: F) -> ArrayBase<S, D>
where Sh: ShapeBuilder<Dim = D>, F: FnMut(<D as Dimension>::Pattern) -> A,

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

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

pub fn uninit<Sh>(shape: Sh) -> ArrayBase<<S as DataOwned>::MaybeUninit, D>
where Sh: ShapeBuilder<Dim = D>,

pub fn build_uninit<Sh, F>( shape: Sh, builder: F ) -> ArrayBase<<S as DataOwned>::MaybeUninit, D>
where Sh: ShapeBuilder<Dim = D>, F: FnOnce(ArrayBase<ViewRepr<&mut MaybeUninit<A>>, D>),

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

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

pub fn maybe_uninit<Sh>(shape: Sh) -> ArrayBase<S, D>
where Sh: ShapeBuilder<Dim = D>,

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

pub fn view(&self) -> ArrayBase<ViewRepr<&A>, D>
where S: Data,

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

pub fn cell_view(&mut self) -> ArrayBase<ViewRepr<&MathCell<A>>, D>
where S: DataMut,

pub fn to_owned(&self) -> ArrayBase<OwnedRepr<A>, D>
where A: Clone, S: Data,

pub fn to_shared(&self) -> ArrayBase<OwnedArcRepr<A>, D>
where A: Clone, S: Data,

pub fn into_owned(self) -> ArrayBase<OwnedRepr<A>, D>
where A: Clone, S: Data,

pub fn try_into_owned_nocopy( self ) -> Result<ArrayBase<OwnedRepr<A>, D>, ArrayBase<S, D>>
where S: Data,

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

pub fn first(&self) -> Option<&A>
where S: Data,

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

pub fn last(&self) -> Option<&A>
where S: Data,

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

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

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

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

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

pub fn slice<I>( &self, info: I ) -> ArrayBase<ViewRepr<&A>, <I as SliceArg<D>>::OutDim>
where I: SliceArg<D>, S: Data,

pub fn slice_mut<I>( &mut self, info: I ) -> ArrayBase<ViewRepr<&mut A>, <I as SliceArg<D>>::OutDim>
where I: SliceArg<D>, S: DataMut,

pub fn multi_slice_mut<'a, M>( &'a mut self, info: M ) -> <M as MultiSliceArg<'a, A, D>>::Output
where M: MultiSliceArg<'a, A, D>, S: DataMut,

pub fn slice_move<I>(self, info: I) -> ArrayBase<S, <I as SliceArg<D>>::OutDim>
where I: SliceArg<D>,

pub fn slice_collapse<I>(&mut self, info: I)
where I: SliceArg<D>,

pub fn slice_axis( &self, axis: Axis, indices: Slice ) -> ArrayBase<ViewRepr<&A>, D>
where S: Data,

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

pub fn slice_each_axis<F>(&self, f: F) -> ArrayBase<ViewRepr<&A>, D>
where F: FnMut(AxisDescription) -> Slice, S: Data,

pub fn slice_each_axis_mut<F>(&mut self, f: F) -> ArrayBase<ViewRepr<&mut A>, D>
where F: FnMut(AxisDescription) -> Slice, S: DataMut,

pub fn slice_each_axis_inplace<F>(&mut self, f: F)
where F: FnMut(AxisDescription) -> Slice,

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

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

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

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

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

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

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

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

pub fn index_axis( &self, axis: Axis, index: usize ) -> ArrayBase<ViewRepr<&A>, <D as Dimension>::Smaller>
where S: Data, D: RemoveAxis,

pub fn index_axis_mut( &mut self, axis: Axis, index: usize ) -> ArrayBase<ViewRepr<&mut A>, <D as Dimension>::Smaller>
where S: DataMut, D: RemoveAxis,

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

pub fn select( &self, axis: Axis, indices: &[usize] ) -> ArrayBase<OwnedRepr<A>, D>
where A: Clone, S: Data, D: RemoveAxis,

pub fn rows(&self) -> Lanes<'_, A, <D as Dimension>::Smaller>
where S: Data,

pub fn genrows(&self) -> Lanes<'_, A, <D as Dimension>::Smaller>
where S: Data,

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

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

pub fn columns(&self) -> Lanes<'_, A, <D as Dimension>::Smaller>
where S: Data,

pub fn gencolumns(&self) -> Lanes<'_, A, <D as Dimension>::Smaller>
where S: Data,

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

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

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