Type Alias IxDyn

pub type IxDyn = Dim<IxDynImpl>;

dynamic-dimensional

You can use the IxDyn function to create a dimension for an array with dynamic number of dimensions. (Vec<usize> and &[usize] also implement IntoDimension to produce IxDyn).

use ndarray::ArrayD;
use ndarray::IxDyn;

// Create a 5 × 6 × 3 × 4 array using the dynamic dimension type
let mut a = ArrayD::<f64>::zeros(IxDyn(&[5, 6, 3, 4]));
// Create a 1 × 3 × 4 array using the dynamic dimension type
let mut b = ArrayD::<f64>::zeros(IxDyn(&[1, 3, 4]));

// We can use broadcasting to add arrays of compatible shapes together:
a += &b;

// We can index into a, b using fixed size arrays:
a[[0, 0, 0, 0]] = 0.;
b[[0, 2, 3]] = a[[0, 0, 2, 3]];
// Note: indexing will panic at runtime if the number of indices given does
// not match the array.

// We can keep them in the same vector because both the arrays have
// the same type `Array<f64, IxDyn>` a.k.a `ArrayD<f64>`:
let arrays = vec![a, b];

Aliased Type

struct IxDyn { /* private fields */ }

Implementations

impl Dim<IxDynImpl>

pub fn zeros(n: usize) -> Dim<IxDynImpl>

Create a new dimension value with n axes, all zeros

Trait Implementations

impl<I> Add for Dim<I>

where Dim<I>: Dimension,

type Output = Dim<I>

The resulting type after applying the + operator.

fn add(self, rhs: Dim<I>) -> Dim<I>

Performs the + operation.

impl<'a, I> AddAssign<&'a Dim<I>> for Dim<I>

where Dim<I>: Dimension,

fn add_assign(&mut self, rhs: &Dim<I>)

Performs the += operation.

impl<I> AddAssign for Dim<I>

where Dim<I>: Dimension,

fn add_assign(&mut self, rhs: Dim<I>)

Performs the += operation.

impl<I> Clone for Dim<I>

where I: Clone + ?Sized,

fn clone(&self) -> Dim<I>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<I> Debug for Dim<I>

where I: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<I> Default for Dim<I>

where I: Default + ?Sized,

fn default() -> Dim<I>

Returns the “default value” for a type.

impl<D> DimAdd<D> for Dim<IxDynImpl>

where D: Dimension,

type Output = Dim<IxDynImpl>

The sum of the two dimensions.

impl DimMax<Dim<[usize; 0]>> for Dim<IxDynImpl>

type Output = Dim<IxDynImpl>

The resulting dimension type after broadcasting.

impl DimMax<Dim<[usize; 1]>> for Dim<IxDynImpl>

type Output = Dim<IxDynImpl>

The resulting dimension type after broadcasting.

impl DimMax<Dim<[usize; 2]>> for Dim<IxDynImpl>

type Output = Dim<IxDynImpl>

The resulting dimension type after broadcasting.

impl DimMax<Dim<[usize; 3]>> for Dim<IxDynImpl>

type Output = Dim<IxDynImpl>

The resulting dimension type after broadcasting.

impl DimMax<Dim<[usize; 4]>> for Dim<IxDynImpl>

type Output = Dim<IxDynImpl>

The resulting dimension type after broadcasting.

impl DimMax<Dim<[usize; 5]>> for Dim<IxDynImpl>

type Output = Dim<IxDynImpl>

The resulting dimension type after broadcasting.

impl DimMax<Dim<[usize; 6]>> for Dim<IxDynImpl>

type Output = Dim<IxDynImpl>

The resulting dimension type after broadcasting.

impl Dimension for Dim<IxDynImpl>

IxDyn is a “dynamic” index, pretty hard to use when indexing, and memory wasteful, but it allows an arbitrary and dynamic number of axes.

const NDIM: Option<usize> = None

For fixed-size dimension representations (e.g. Ix2), this should be Some(ndim), and for variable-size dimension representations (e.g. IxDyn), this should be None.

type Pattern = Dim<IxDynImpl>

Pattern matching friendly form of the dimension value.

type Smaller = Dim<IxDynImpl>

Next smaller dimension (if applicable)

type Larger = Dim<IxDynImpl>

Next larger dimension

fn ndim(&self) -> usize

Returns the number of dimensions (number of axes).

fn into_pattern(self) -> <Dim<IxDynImpl> as Dimension>::Pattern

Convert the dimension into a pattern matching friendly value.

fn zeros(ndim: usize) -> Dim<IxDynImpl>

Creates a dimension of all zeros with the specified ndim.

fn into_dyn(self) -> Dim<IxDynImpl>

Convert the dimensional into a dynamic dimensional (IxDyn).

fn size(&self) -> usize

Compute the size of the dimension (number of elements)

fn size_checked(&self) -> Option<usize>

Compute the size while checking for overflow.

fn as_array_view(&self) -> ArrayBase<ViewRepr<&usize>, Dim<[usize; 1]>>

Borrow as a read-only array view.

fn as_array_view_mut( &mut self, ) -> ArrayBase<ViewRepr<&mut usize>, Dim<[usize; 1]>>

Borrow as a read-write array view.

impl<I> Hash for Dim<I>

where I: Hash + ?Sized,

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

where __H: Hasher,

Feeds this value into the given Hasher.

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

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Index<usize> for Dim<IxDynImpl>

type Output = <IxDynImpl as Index<usize>>::Output

The returned type after indexing.

fn index(&self, index: usize) -> &<Dim<IxDynImpl> as Index<usize>>::Output

Performs the indexing (container[index]) operation.

impl IndexMut<usize> for Dim<IxDynImpl>

fn index_mut( &mut self, index: usize, ) -> &mut <Dim<IxDynImpl> as Index<usize>>::Output

Performs the mutable indexing (container[index]) operation.

impl<I> Mul<usize> for Dim<I>

where Dim<I>: Dimension,

type Output = Dim<I>

The resulting type after applying the * operator.

fn mul(self, rhs: usize) -> Dim<I>

Performs the * operation.

impl<I> Mul for Dim<I>

where Dim<I>: Dimension,

type Output = Dim<I>

The resulting type after applying the * operator.

fn mul(self, rhs: Dim<I>) -> Dim<I>

Performs the * operation.

impl<'a, I> MulAssign<&'a Dim<I>> for Dim<I>

where Dim<I>: Dimension,

fn mul_assign(&mut self, rhs: &Dim<I>)

Performs the *= operation.

impl<I> MulAssign<usize> for Dim<I>

where Dim<I>: Dimension,

fn mul_assign(&mut self, rhs: usize)

Performs the *= operation.

impl<I> MulAssign for Dim<I>

where Dim<I>: Dimension,

fn mul_assign(&mut self, rhs: Dim<I>)

Performs the *= operation.

impl<I> PartialEq<I> for Dim<I>

where I: PartialEq + ?Sized,

fn eq(&self, rhs: &I) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<I> PartialEq for Dim<I>

where I: PartialEq + ?Sized,

fn eq(&self, other: &Dim<I>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl RemoveAxis for Dim<IxDynImpl>

fn remove_axis(&self, axis: Axis) -> Dim<IxDynImpl>

impl<I> Sub for Dim<I>

where Dim<I>: Dimension,

type Output = Dim<I>

The resulting type after applying the - operator.

fn sub(self, rhs: Dim<I>) -> Dim<I>

Performs the - operation.

impl<'a, I> SubAssign<&'a Dim<I>> for Dim<I>

where Dim<I>: Dimension,

fn sub_assign(&mut self, rhs: &Dim<I>)

Performs the -= operation.

impl<I> SubAssign for Dim<I>

where Dim<I>: Dimension,

fn sub_assign(&mut self, rhs: Dim<I>)

Performs the -= operation.

impl<I> Copy for Dim<I>

where I: Copy + ?Sized,

impl<I> Eq for Dim<I>

where I: Eq + ?Sized,

impl<I> StructuralPartialEq for Dim<I>

where I: ?Sized,