Struct Array 

pub struct Array { /* private fields */ }

An n-dimensional array.

Implementations

impl Array

pub unsafe fn from_ptr(c_array: mlx_array) -> Array

Create a new array from an existing mlx_array pointer.

Safety

c_array must be a valid, independently owned MLX array handle. Array takes ownership of that handle and frees it on drop. A borrowed handle, such as one returned by Array::as_ptr, must first be duplicated into a fresh handle with [mlx_sys::mlx_array_set].

use mlx_rs::Array;

let source = Array::from_int(1);
let duplicate = unsafe {
    let mut handle = mlx_sys::mlx_array_new();
    assert_eq!(mlx_sys::mlx_array_set(&mut handle, source.as_ptr()), 0);
    Array::from_ptr(handle)
};
assert_eq!(duplicate.item_exact::<i32>(), 1);

pub fn as_ptr(&self) -> mlx_array

Get the underlying mlx_array pointer.

pub fn from_bool(val: bool) -> Array

New array from a bool scalar.

pub fn from_int(val: i32) -> Array

New array from an int scalar.

pub fn from_f32(val: f32) -> Array

New array from a f32 scalar.

pub fn from_f64(val: f64) -> Array

New array from a f64 scalar.

pub fn from_complex(val: complex64) -> Array

New array from a complex scalar.

pub fn from_slice<T: FromSliceElement>(data: &[T], shape: &[i32]) -> Self

New array from existing buffer.

Please note that floating point literals are treated as f32 instead of f64. Use Array::from_slice_f64 for f64.

Parameters

• data: A buffer which will be copied.
• shape: Shape of the array.

Panic

• Panics if the product of the shape is not equal to the length of the data.
• Panics if the shape is too large.

pub fn from_slice_f64(data: &[f64], shape: &[i32]) -> Self

New array from a slice of f64.

A separate method is provided for f64 because f64 is not supported on GPU and rust defaults to f64 for floating point literals

pub unsafe fn from_raw_data( data: *const c_void, shape: &[i32], dtype: Dtype, ) -> Self

Create a new array from raw data buffer.

This is a convenience wrapper around [mlx_sy::mlx_array_new_data].

Safety

This is unsafe because the caller must ensure that the data buffer is valid and that the shape is correct.

pub fn from_iter<I: IntoIterator<Item = T>, T: FromSliceElement>( iter: I, shape: &[i32], ) -> Self

New array from an iterator.

Please note that floating point literals are treated as f32 instead of f64. Use Array::from_iter_f64 for f64.

This is a convenience method that is equivalent to

let data: Vec<T> = iter.collect();
Array::from_slice(&data, shape)

Example

use mlx_rs::Array;

let data = vec![1i32, 2, 3, 4, 5];
let mut array = Array::from_iter(data.clone(), &[5]);
assert_eq!(array.as_slice::<i32>(), &data[..]);

pub fn from_iter_f64<I: IntoIterator<Item = f64>>( iter: I, shape: &[i32], ) -> Self

New array from an iterator of f64.

A separate method is provided for f64 because f64 is not supported on GPU and rust defaults to f64 for floating point literals

pub fn item_size(&self) -> usize

The size of the array’s datatype in bytes.

pub fn size(&self) -> usize

Number of elements in the array.

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

The strides of the array.

pub fn nbytes(&self) -> usize

The number of bytes in the array.

pub fn ndim(&self) -> usize

The array’s dimension.

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

The shape of the array.

Returns: a pointer to the sizes of each dimension.

pub fn dim(&self, dim: i32) -> i32

The shape of the array in a particular dimension.

Panic

• Panics if the array is scalar.
• Panics if dim is negative and dim + ndim overflows
• Panics if the dimension is out of bounds.

pub fn dtype(&self) -> Dtype

The array element type.

pub fn eval(&self) -> Result<()>

Evaluate the array.

pub fn item_exact<T: ArrayElement>(&self) -> T

Access the value of a scalar array without dtype conversion.

This evaluates the array and panics if evaluation fails, the array is not scalar, or T does not exactly match the array dtype.

pub fn try_item_exact<T: ArrayElement>(&self) -> Result<T, ConversionError>

Access the value of a scalar array without dtype conversion.

This evaluates the array and returns an error if evaluation fails, the array is not scalar, or T does not exactly match the array dtype.

pub fn item_cast<T: ArrayElement>(&self) -> T

Access the value of a scalar array, converting it to T when necessary.

This evaluates the array and panics if evaluation or conversion fails or the array is not scalar.

pub fn try_item_cast<T: ArrayElement>(&self) -> Result<T, ConversionError>

Access the value of a scalar array, converting it to T when necessary.

This evaluates the array and returns an error if evaluation or conversion fails or the array is not scalar.

pub fn item<T: ArrayElement>(&self) -> T

👎Deprecated since 0.26.0:

use item_cast or item_exact

Compatibility alias for Array::item_cast.

pub fn try_item<T: ArrayElement>(&self) -> Result<T>

👎Deprecated since 0.26.0:

use try_item_cast or try_item_exact

Compatibility alias for Array::try_item_cast.

pub fn to_vec_exact<T: ArrayElement + Clone>( &self, ) -> Result<Vec<T>, ConversionError>

Copy contiguous row-major array values without dtype conversion.

This evaluates the array and allocates a Vec. It returns an error if T does not exactly match the array dtype or if the array is not contiguous row-major. Call Array::contiguous first to materialize a row-major array.

pub fn to_vec_cast<T: ArrayElement + Clone>( &self, ) -> Result<Vec<T>, ConversionError>

Copy contiguous row-major array values, converting them to T when necessary.

This evaluates the array, may allocate a converted MLX array, and allocates a Vec. It returns an error if evaluation or conversion fails or if the converted array is not contiguous row-major. Call Array::contiguous first to materialize a row-major array.

pub unsafe fn as_slice_unchecked<T: ArrayElement>(&self) -> &[T]

Returns a slice of the array data without validating the dtype.

Safety

This is unsafe because the underlying data ptr is not checked for null or if the desired dtype matches the actual dtype of the array.

Example

use mlx_rs::Array;

let data = [1i32, 2, 3, 4, 5];
let mut array = Array::from_slice(&data[..], &[5]);

unsafe {
   let slice = array.as_slice_unchecked::<i32>();
   assert_eq!(slice, &[1, 2, 3, 4, 5]);
}

pub fn try_as_slice<T: ArrayElement>(&self) -> Result<&[T], AsSliceError>

Returns a slice of contiguous row-major array data.

Returns an error if the dtype does not match or the array is a non-contiguous view. Call Array::contiguous first to materialize a row-major array.

Example

use mlx_rs::Array;

let data = [1i32, 2, 3, 4, 5];
let mut array = Array::from_slice(&data[..], &[5]);

let slice = array.try_as_slice::<i32>();
assert_eq!(slice, Ok(&data[..]));

pub fn as_slice<T: ArrayElement>(&self) -> &[T]

Returns a slice of contiguous row-major array data.

Panics

Panics if evaluation fails, the desired dtype does not match the actual dtype, or the array is not contiguous row-major. Call Array::contiguous first for non-contiguous views.

Example

use mlx_rs::Array;

let data = [1i32, 2, 3, 4, 5];
let mut array = Array::from_slice(&data[..], &[5]);

let slice = array.as_slice::<i32>();
assert_eq!(slice, &data[..]);

pub fn deep_clone(&self) -> Self

Clone the array by copying the data.

This is named deep_clone to avoid confusion with the Clone trait.

impl Array

pub fn diff(&self, n: i32, axis: i32) -> Result<Array>

Apply adjacent subtraction n times along axis.

n == 0 returns an identity result. MLX does not provide prepend or append operands for this operation.

use mlx_rs::array;

let output = array!([1, 4, 9]).diff(1, -1).unwrap();
assert_eq!(output.shape(), &[2]);

pub fn trunc(&self) -> Result<Array>

Round floating-point values toward zero.

Signed zero is preserved, integers are unchanged, and complex inputs are rejected.

use mlx_rs::array;

let output = array!([-1.75, 2.25]).trunc().unwrap();
assert_eq!(output.shape(), &[2]);

pub fn abs(&self) -> Result<Array>

Element-wise absolute value.

Example

use mlx_rs::Array;
let array = Array::from_slice(&[1i32, 2, -3, -4, -5], &[5]);
let mut result = array.abs().unwrap();

let data: &[i32] = result.as_slice();
// data == [1, 2, 3, 4, 5]

pub fn abs_device(&self, stream: impl AsRef<Stream>) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around abs

Compatibility shim for abs.

pub fn add(&self, other: impl AsRef<Array>) -> Result<Array>

Element-wise addition returning an error if arrays are not broadcastable.

Add two arrays with broadcasting.

Params

• other: array to add

Example

use mlx_rs::Array;
let a = Array::from_slice(&[1.0, 2.0, 3.0], &[3]);
let b = Array::from_slice(&[4.0, 5.0, 6.0], &[3]);
let mut c = a.add(&b).unwrap();

let c_data: &[f32] = c.as_slice();
// c_data == [5.0, 7.0, 9.0]

pub fn add_device( &self, other: impl AsRef<Array>, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around add

Compatibility shim for add.

pub fn subtract(&self, other: impl AsRef<Array>) -> Result<Array>

Element-wise subtraction returning an error if arrays are not broadcastable.

Subtract two arrays with broadcasting.

Params

• other: array to subtract

Example

use mlx_rs::Array;
let a = Array::from_slice(&[1.0, 2.0, 3.0], &[3]);
let b = Array::from_slice(&[4.0, 5.0, 6.0], &[3]);
let mut c = a.subtract(&b).unwrap();

let c_data: &[f32] = c.as_slice();
// c_data == [-3.0, -3.0, -3.0]

pub fn subtract_device( &self, other: impl AsRef<Array>, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around subtract

Compatibility shim for subtract.

pub fn negative(&self) -> Result<Array>

Unary element-wise negation. Returns an error if the array is of type bool.

Negate the values in the array.

Example

use mlx_rs::Array;
let a = Array::from_slice(&[1.0, 2.0, 3.0], &[3]);
let mut b = a.negative().unwrap();

let b_data: &[f32] = b.as_slice();
// b_data == [-1.0, -2.0, -3.0]

pub fn negative_device(&self, stream: impl AsRef<Stream>) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around negative

Compatibility shim for negative.

pub fn multiply(&self, other: impl AsRef<Array>) -> Result<Array>

Element-wise multiplication returning an error if arrays are not broadcastable.

Multiply two arrays with broadcasting.

Example

use mlx_rs::Array;
let a = Array::from_slice(&[1.0, 2.0, 3.0], &[3]);
let b = Array::from_slice(&[4.0, 5.0, 6.0], &[3]);
let mut c = a.multiply(&b).unwrap();

let c_data: &[f32] = c.as_slice();
// c_data == [4.0, 10.0, 18.0]

pub fn multiply_device( &self, other: impl AsRef<Array>, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around multiply

Compatibility shim for multiply.

pub fn nan_to_num( &self, nan: impl IntoOption<f32>, pos_inf: impl IntoOption<f32>, neg_inf: impl IntoOption<f32>, ) -> Result<Array>

Replace NaN and Inf values with finite numbers.

Params

• nan: value to replace NaN with
• posInf: value to replace positive inifinites with. If not specified will use the largest finite value for the given dtype.
• negInf: value to replace negative inifinites with. If not specified will use the negative of the largest finite value for the given dtype.
• stream: stream or device to evaluate on

pub fn nan_to_num_device( &self, nan: impl IntoOption<f32>, pos_inf: impl IntoOption<f32>, neg_inf: impl IntoOption<f32>, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around nan_to_num

Compatibility shim for [nan_to_num].

pub fn divide(&self, other: impl AsRef<Array>) -> Result<Array>

Element-wise division returning an error if arrays are not broadcastable.

Divide two arrays with broadcasting.

Params

• other: array to divide

Example

use mlx_rs::Array;
let a = Array::from_slice(&[1.0, 2.0, 3.0], &[3]);
let b = Array::from_slice(&[4.0, 5.0, 6.0], &[3]);
let mut c = a.divide(&b).unwrap();

let c_data: &[f32] = c.as_slice();
// c_data == [0.25, 0.4, 0.5]

pub fn divide_device( &self, other: impl AsRef<Array>, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around divide

Compatibility shim for divide.

pub fn power(&self, other: impl AsRef<Array>) -> Result<Array>

Element-wise power operation returning an error if arrays are not broadcastable if they have different shapes.

Raise the elements of the array to the power of the elements of another array.

Params

• other: array to raise to the power of

Example

use mlx_rs::Array;
let a = Array::from_slice(&[1.0, 2.0, 3.0], &[3]);
let b = Array::from_slice(&[2.0, 3.0, 4.0], &[3]);
let mut c = a.power(&b).unwrap();

let c_data: &[f32] = c.as_slice();
// c_data == [1.0, 8.0, 81.0]

pub fn power_device( &self, other: impl AsRef<Array>, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around power

Compatibility shim for power.

pub fn remainder(&self, other: impl AsRef<Array>) -> Result<Array>

Element-wise remainder of division returning an error if arrays are not broadcastable.

Computes the remainder of dividing lhs with rhs with broadcasting.

Params

• other: array to divide

Example

use mlx_rs::Array;
let a = Array::from_slice(&[10.0, 11.0, 12.0], &[3]);
let b = Array::from_slice(&[3.0, 4.0, 5.0], &[3]);
let mut c = a.remainder(&b).unwrap();

let c_data: &[f32] = c.as_slice();
// c_data == [1.0, 3.0, 2.0]

pub fn remainder_device( &self, other: impl AsRef<Array>, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around remainder

Compatibility shim for remainder.

pub fn sqrt(&self) -> Result<Array>

Element-wise square root

Example

use mlx_rs::Array;
let a = Array::from_slice(&[1.0, 4.0, 9.0], &[3]);
let mut b = a.sqrt().unwrap();

let b_data: &[f32] = b.as_slice();
// b_data == [1.0, 2.0, 3.0]

pub fn sqrt_device(&self, stream: impl AsRef<Stream>) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around sqrt

Compatibility shim for sqrt.

pub fn cos(&self) -> Result<Array>

Element-wise cosine

Example

use mlx_rs::Array;
let a = Array::from_slice(&[0.0, 1.0, 2.0], &[3]);
let mut b = a.cos().unwrap();

let b_data: &[f32] = b.as_slice();
// b_data == [1.0, 0.54030234, -0.41614687]

pub fn cos_device(&self, stream: impl AsRef<Stream>) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around cos

Compatibility shim for cos.

pub fn exp(&self) -> Result<Array>

Element-wise exponential.

Example

use mlx_rs::Array;

let a = Array::from_slice(&[0.0, 1.0, 2.0], &[3]);
let a = Array::from_slice(&[0.0, 1.0, 2.0], &[3]);
let mut b = a.exp().unwrap();

let b_data: &[f32] = b.as_slice();
// b_data == [1.0, 2.7182817, 7.389056]

pub fn exp_device(&self, stream: impl AsRef<Stream>) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around exp

Compatibility shim for exp.

pub fn floor(&self) -> Result<Array>

Element-wise floor returning an error if the array is of type complex64.

Example

use mlx_rs::Array;
let a = Array::from_slice(&[0.1, 1.9, 2.5], &[3]);
let mut b = a.floor().unwrap();

let b_data: &[f32] = b.as_slice();
// b_data == [0.0, 1.0, 2.0]

pub fn floor_device(&self, stream: impl AsRef<Stream>) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around floor

Compatibility shim for floor.

pub fn floor_divide(&self, other: impl AsRef<Array>) -> Result<Array>

Element-wise integer division returning an error if arrays are not broadcastable.

Divide two arrays with broadcasting.

If either array is a floating point type then it is equivalent to calling Array::floor() after /.

Params

• other: array to divide

Example

use mlx_rs::Array;
let a = Array::from_slice(&[1.0, 2.0, 3.0], &[3]);
let b = Array::from_slice(&[4.0, 5.0, 6.0], &[3]);
let mut c = a.floor_divide(&b).unwrap();

let c_data: &[f32] = c.as_slice();
// c_data == [0.25, 0.4, 0.5]

pub fn floor_divide_device( &self, other: impl AsRef<Array>, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around floor_divide

Compatibility shim for floor_divide.

pub fn is_nan(&self) -> Result<Array>

Return a boolean array indicating which elements are NaN.

Params

• stream: stream or device to evaluate on

pub fn is_nan_device(&self, stream: impl AsRef<Stream>) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around is_nan

Compatibility shim for [is_nan].

pub fn is_inf(&self) -> Result<Array>

Return a boolean array indicating which elements are infinity.

Params

• stream: stream or device to evaluate on

pub fn is_inf_device(&self, stream: impl AsRef<Stream>) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around is_inf

Compatibility shim for [is_inf].

pub fn is_finite(&self) -> Result<Array>

Return a boolean array indicating which elements are finite.

Params

• stream: stream or device to evaluate on

pub fn is_finite_device(&self, stream: impl AsRef<Stream>) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around is_finite

Compatibility shim for [is_finite].

pub fn is_neg_inf(&self) -> Result<Array>

Return a boolean array indicating which elements are negative infinity.

Params

• stream: stream or device to evaluate on

pub fn is_neg_inf_device(&self, stream: impl AsRef<Stream>) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around is_neg_inf

Compatibility shim for [is_neg_inf].

pub fn is_pos_inf(&self) -> Result<Array>

Return a boolean array indicating which elements are positive infinity.

Params

• stream: stream or device to evaluate on

pub fn is_pos_inf_device(&self, stream: impl AsRef<Stream>) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around is_pos_inf

Compatibility shim for [is_pos_inf].

pub fn log(&self) -> Result<Array>

Element-wise natural logarithm.

Example

use mlx_rs::Array;
let a = Array::from_slice(&[1.0, 2.0, 3.0], &[3]);
let mut b = a.log().unwrap();

let b_data: &[f32] = b.as_slice();
// b_data == [0.0, 0.6931472, 1.0986123]

pub fn log_device(&self, stream: impl AsRef<Stream>) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around log

Compatibility shim for log.

pub fn log2(&self) -> Result<Array>

Element-wise base-2 logarithm.

Example

use mlx_rs::Array;
let a = Array::from_slice(&[1.0, 2.0, 4.0, 8.0], &[4]);
let mut b = a.log2().unwrap();

let b_data: &[f32] = b.as_slice();
// b_data == [0.0, 1.0, 2.0, 3.0]

pub fn log2_device(&self, stream: impl AsRef<Stream>) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around log2

Compatibility shim for log2.

pub fn log10(&self) -> Result<Array>

Element-wise base-10 logarithm.

Example

use mlx_rs::Array;
let a = Array::from_slice(&[1.0, 10.0, 100.0], &[3]);
let mut b = a.log10().unwrap();

let b_data: &[f32] = b.as_slice();
// b_data == [0.0, 1.0, 2.0]

pub fn log10_device(&self, stream: impl AsRef<Stream>) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around log10

Compatibility shim for log10.

pub fn log1p(&self) -> Result<Array>

Element-wise natural log of one plus the array.

Example

use mlx_rs::Array;
let a = Array::from_slice(&[1.0, 2.0, 3.0], &[3]);
let mut b = a.log1p().unwrap();

let b_data: &[f32] = b.as_slice();
// b_data == [0.6931472, 1.0986123, 1.3862944]

pub fn log1p_device(&self, stream: impl AsRef<Stream>) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around log1p

Compatibility shim for log1p.

pub fn matmul(&self, other: impl AsRef<Array>) -> Result<Array>

Matrix multiplication returning an error if inputs are not valid.

Perform the (possibly batched) matrix multiplication of two arrays. This function supports broadcasting for arrays with more than two dimensions.

• If the first array is 1-D then a 1 is prepended to its shape to make it a matrix. Similarly, if the second array is 1-D then a 1 is appended to its shape to make it a matrix. In either case the singleton dimension is removed from the result.
• A batched matrix multiplication is performed if the arrays have more than 2 dimensions. The matrix dimensions for the matrix product are the last two dimensions of each input.
• All but the last two dimensions of each input are broadcast with one another using standard broadcasting.

Params

• other: array to multiply

Example

use mlx_rs::Array;
let a = Array::from_slice(&[1, 2, 3, 4], &[2, 2]);
let b = Array::from_slice(&[-5.0, 37.5, 4., 7., 1., 0.], &[2, 3]);

// produces a [2, 3] result
let mut c = a.matmul(&b);

pub fn matmul_device( &self, other: impl AsRef<Array>, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around matmul

Compatibility shim for matmul.

pub fn reciprocal(&self) -> Result<Array>

Element-wise reciprocal.

Example

use mlx_rs::Array;
let a = Array::from_slice(&[1.0, 2.0, 4.0], &[3]);
let mut b = a.reciprocal().unwrap();

let b_data: &[f32] = b.as_slice();
// b_data == [1.0, 0.5, 0.25]

pub fn reciprocal_device(&self, stream: impl AsRef<Stream>) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around reciprocal

Compatibility shim for reciprocal.

pub fn round(&self, decimals: impl Into<Option<i32>>) -> Result<Array>

Round to the given number of decimals.

Params

• decimals: number of decimals to round to - default is 0 if not provided

pub fn round_device( &self, decimals: impl Into<Option<i32>>, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around round

Compatibility shim for round.

pub fn rsqrt(&self) -> Result<Array>

Element-wise reciprocal and square root.

pub fn rsqrt_device(&self, stream: impl AsRef<Stream>) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around rsqrt

Compatibility shim for rsqrt.

pub fn sin(&self) -> Result<Array>

Element-wise sine.

pub fn sin_device(&self, stream: impl AsRef<Stream>) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around sin

Compatibility shim for sin.

pub fn square(&self) -> Result<Array>

Element-wise square.

pub fn square_device(&self, stream: impl AsRef<Stream>) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around square

Compatibility shim for square.

pub fn real(&self) -> Result<Array>

Element-wise real part from a complex array.

pub fn real_device(&self, stream: impl AsRef<Stream>) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around real

Compatibility shim for real.

pub fn imag(&self) -> Result<Array>

Element-wise imag part from a complex array.

pub fn imag_device(&self, stream: impl AsRef<Stream>) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around imag

Compatibility shim for imag.

impl Array

pub fn to_fp8(&self) -> Result<Array>

Convert an array to FP8 (E4M3) format.

The input array must be a floating point type (float32, float16, or bfloat16). Values outside the representable range of FP8 E4M3 (-448 to 448) will be clipped.

Returns

An array with dtype uint8 containing the FP8 E4M3 encoded values.

pub fn to_fp8_device(&self, stream: impl AsRef<Stream>) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around to_fp8

Compatibility shim for to_fp8.

pub fn from_fp8(&self, dtype: Dtype) -> Result<Array>

Convert an FP8 (E4M3) encoded array back to a floating point type.

The input array should be a uint8 array containing FP8 E4M3 encoded values.

Params

• dtype: The target floating point dtype (float32, float16, or bfloat16)

pub fn from_fp8_device( &self, dtype: Dtype, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around from_fp8

Compatibility shim for from_fp8.

pub fn as_type<T: ArrayElement>(&self) -> Result<Array>

Create a new array with the contents converted to the given ArrayElement type.

Example

use mlx_rs::{Array, Dtype};

let array = Array::from_slice(&[1i16,2,3], &[3]);
let mut new_array = array.as_type::<f32>().unwrap();

assert_eq!(new_array.dtype(), Dtype::Float32);
assert_eq!(new_array.shape(), &[3]);
assert_eq!(new_array.item_size(), 4);
assert_eq!(new_array.as_slice::<f32>(), &[1.0,2.0,3.0]);

pub fn as_type_device<T: ArrayElement>( &self, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around as_type

Compatibility shim for [as_type].

pub fn as_dtype(&self, dtype: Dtype) -> Result<Array>

Same as as_type but with a Dtype argument.

pub fn as_dtype_device( &self, dtype: Dtype, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around as_dtype

Compatibility shim for [as_dtype].

pub fn view<T: ArrayElement>(&self) -> Result<Array>

View the array as a different type.

The output array will change along the last axis if the input array’s type and the output array’s type do not have the same size.

Note: the view op does not imply that the input and output arrays share their underlying data. The view only guarantees that the binary representation of each element (or group of elements) is the same.

pub fn view_device<T: ArrayElement>( &self, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around view

Compatibility shim for [view].

pub fn view_dtype(&self, dtype: Dtype) -> Result<Array>

Same as view but with a Dtype argument.

pub fn view_dtype_device( &self, dtype: Dtype, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around view_dtype

Compatibility shim for [view_dtype].

impl Array

pub fn logcumsumexp(&self, options: LogCumsumExpOptions) -> Result<Array>

Compute a stable cumulative LogAddExp scan.

This does not form log(cumsum(exp(x))). Exclusive scans use negative infinity as the shifted seed.

use mlx_rs::{array, ops::LogCumsumExpOptions};

let output = array!([0.0, 1.0, 2.0])
    .logcumsumexp(LogCumsumExpOptions::default())
    .unwrap();
assert_eq!(output.shape(), &[3]);

pub fn cummax( &self, axis: impl Into<Option<i32>>, reverse: impl Into<Option<bool>>, inclusive: impl Into<Option<bool>>, ) -> Result<Array>

Return the cumulative maximum of the elements along the given axis returning an error if the inputs are invalid.

Params

• axis: Optional axis to compute the cumulative maximum over. If unspecified the cumulative maximum of the flattened array is returned.
• reverse: If true, the cumulative maximum is computed in reverse - defaults to false if unspecified.
• inclusive: If true, the i-th element of the output includes the i-th element of the input - defaults to true if unspecified.

Example

use mlx_rs::Array;
let array = Array::from_slice(&[5, 8, 4, 9], &[2, 2]);

// result is [[5, 8], [5, 9]] -- cumulative max along the columns
let result = array.cummax(0, None, None).unwrap();

pub fn cummax_device( &self, axis: impl Into<Option<i32>>, reverse: impl Into<Option<bool>>, inclusive: impl Into<Option<bool>>, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around cummax

Compatibility shim for cummax.

pub fn cummin( &self, axis: impl Into<Option<i32>>, reverse: impl Into<Option<bool>>, inclusive: impl Into<Option<bool>>, ) -> Result<Array>

Return the cumulative minimum of the elements along the given axis returning an error if the inputs are invalid.

Params

• axis: Optional axis to compute the cumulative minimum over. If unspecified the cumulative maximum of the flattened array is returned.
• reverse: If true, the cumulative minimum is computed in reverse - defaults to false if unspecified.
• inclusive: If true, the i-th element of the output includes the i-th element of the input - defaults to true if unspecified.

Example

use mlx_rs::Array;
let array = Array::from_slice(&[5, 8, 4, 9], &[2, 2]);

// result is [[5, 8], [4, 8]] -- cumulative min along the columns
let result = array.cummin(0, None, None).unwrap();

pub fn cummin_device( &self, axis: impl Into<Option<i32>>, reverse: impl Into<Option<bool>>, inclusive: impl Into<Option<bool>>, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around cummin

Compatibility shim for cummin.

pub fn cumprod( &self, axis: impl Into<Option<i32>>, reverse: impl Into<Option<bool>>, inclusive: impl Into<Option<bool>>, ) -> Result<Array>

Return the cumulative product of the elements along the given axis returning an error if the inputs are invalid.

Params

• axis: Optional axis to compute the cumulative product over. If unspecified the cumulative maximum of the flattened array is returned.
• reverse: If true, the cumulative product is computed in reverse - defaults to false if unspecified.
• inclusive: If true, the i-th element of the output includes the i-th element of the input - defaults to true if unspecified.

Example

use mlx_rs::Array;
let array = Array::from_slice(&[5, 8, 4, 9], &[2, 2]);

// result is [[5, 8], [20, 72]] -- cumulative min along the columns
let result = array.cumprod(0, None, None).unwrap();

pub fn cumprod_device( &self, axis: impl Into<Option<i32>>, reverse: impl Into<Option<bool>>, inclusive: impl Into<Option<bool>>, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around cumprod

Compatibility shim for cumprod.

pub fn cumsum( &self, axis: impl Into<Option<i32>>, reverse: impl Into<Option<bool>>, inclusive: impl Into<Option<bool>>, ) -> Result<Array>

Return the cumulative sum of the elements along the given axis returning an error if the inputs are invalid.

Params

• axis: Optional axis to compute the cumulative sum over. If unspecified the cumulative maximum of the flattened array is returned.
• reverse: If true, the cumulative sum is computed in reverse - defaults to false if unspecified.
• inclusive: If true, the i-th element of the output includes the i-th element of the input - defaults to true if unspecified.

Example

use mlx_rs::Array;
let array = Array::from_slice(&[5, 8, 4, 9], &[2, 2]);

// result is [[5, 8], [9, 17]] -- cumulative min along the columns
let result = array.cumsum(0, None, None).unwrap();

pub fn cumsum_device( &self, axis: impl Into<Option<i32>>, reverse: impl Into<Option<bool>>, inclusive: impl Into<Option<bool>>, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around cumsum

Compatibility shim for cumsum.

impl Array

pub fn zeros<T: ArrayElement>(shape: &[i32]) -> Result<Array>

Construct an array of zeros returning an error if shape is invalid.

Params

• shape: Desired shape

Example

use mlx_rs::Array;
Array::zeros::<f32>(&[5, 10]).unwrap();

pub fn zeros_device<T: ArrayElement>( shape: &[i32], stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around zeros

Compatibility shim for zeros.

pub fn ones<T: ArrayElement>(shape: &[i32]) -> Result<Array>

Construct an array of ones returning an error if shape is invalid.

Params

• shape: Desired shape

Example

use mlx_rs::Array;
Array::ones::<f32>(&[5, 10]).unwrap();

pub fn ones_device<T: ArrayElement>( shape: &[i32], stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around ones

Compatibility shim for ones.

pub fn eye<T: ArrayElement>( n: i32, m: Option<i32>, k: Option<i32>, ) -> Result<Array>

Create an identity matrix or a general diagonal matrix returning an error if params are invalid.

Params

• n: number of rows in the output
• m: number of columns in the output – equal to n if not specified
• k: index of the diagonal - defaults to 0 if not specified

Example

use mlx_rs::Array;
//  create [10, 10] array with 1's on the diagonal.
let r = Array::eye::<f32>(10, None, None).unwrap();

pub fn eye_device<T: ArrayElement>( n: i32, m: Option<i32>, k: Option<i32>, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around eye

Compatibility shim for eye.

pub fn full<T: ArrayElement>( shape: &[i32], values: impl AsRef<Array>, ) -> Result<Array>

Construct an array with the given value returning an error if shape is invalid.

Constructs an array of size shape filled with values. If values is an Array it must be broadcasting to the given shape.

Params

• shape: shape of the output array
• values: values to be broadcast into the array

Example

use mlx_rs::{Array, array};
//  create [5, 4] array filled with 7
let r = Array::full::<f32>(&[5, 4], array!(7.0f32)).unwrap();

pub fn full_device<T: ArrayElement>( shape: &[i32], values: impl AsRef<Array>, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around full

Compatibility shim for full.

pub fn identity<T: ArrayElement>(n: i32) -> Result<Array>

Create a square identity matrix returning an error if params are invalid.

Params

• n: number of rows and columns in the output

Example

use mlx_rs::Array;
//  create [10, 10] array with 1's on the diagonal.
let r = Array::identity::<f32>(10).unwrap();

pub fn identity_device<T: ArrayElement>( n: i32, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around identity

Compatibility shim for identity.

pub fn arange<U, T>( start: impl Into<Option<U>>, stop: U, step: impl Into<Option<U>>, ) -> Result<Array>

where U: NumCast, T: ArrayElement,

Generates ranges of numbers.

Generate numbers in the half-open interval [start, stop) in increments of step.

Params

• start: Starting value which defaults to 0.
• stop: Stopping value.
• step: Increment which defaults to 1.

Example

use mlx_rs::Array;

// Create a 1-D array with values from 0 to 50
let r = Array::arange::<_, f32>(None, 50, None);

pub fn arange_device<U, T>( start: impl Into<Option<U>>, stop: U, step: impl Into<Option<U>>, stream: impl AsRef<Stream>, ) -> Result<Array>

where U: NumCast, T: ArrayElement,

👎Deprecated since 0.26.0:

use with_stream or with_device around arange

Compatibility shim for arange.

pub fn linspace<U, T>( start: U, stop: U, count: impl Into<Option<i32>>, ) -> Result<Array>

where U: NumCast, T: ArrayElement,

👎Deprecated since 0.26.0:

use ops::linspace with LinspaceOptions

Compatibility shim for linspace with endpoint inclusion.

pub fn linspace_device<U, T>( start: U, stop: U, count: impl Into<Option<i32>>, stream: impl AsRef<Stream>, ) -> Result<Array>

where U: NumCast, T: ArrayElement,

👎Deprecated since 0.26.0:

use with_stream or with_device around ops::linspace

Compatibility shim for linspace.

pub fn repeat_axis<T: ArrayElement>( array: Array, count: i32, axis: i32, ) -> Result<Array>

Repeat an array along a specified axis returning an error if params are invalid.

Params

• array: array to repeat
• count: number of times to repeat
• axis: axis to repeat along

Example

use mlx_rs::Array;
// repeat a [2, 2] array 4 times along axis 1
let source = Array::from_slice(&[0, 1, 2, 3], &[2, 2]);
let r = Array::repeat_axis::<i32>(source, 4, 1).unwrap();

pub fn repeat_axis_device<T: ArrayElement>( array: Array, count: i32, axis: i32, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around repeat_axis

Compatibility shim for repeat_axis.

pub fn repeat<T: ArrayElement>(array: Array, count: i32) -> Result<Array>

Repeat a flattened array along axis 0 returning an error if params are invalid.

Params

• array: array to repeat
• count: number of times to repeat

Example

use mlx_rs::Array;
// repeat a 4 element array 4 times along axis 0
let source = Array::from_slice(&[0, 1, 2, 3], &[2, 2]);
let r = Array::repeat::<i32>(source, 4).unwrap();

pub fn repeat_device<T: ArrayElement>( array: Array, count: i32, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around repeat

Compatibility shim for repeat.

pub fn tri<T: ArrayElement>( n: i32, m: Option<i32>, k: Option<i32>, ) -> Result<Array>

An array with ones at and below the given diagonal and zeros elsewhere.

Params

• n: number of rows in the output
• m: number of columns in the output – equal to n if not specified
• k: index of the diagonal – defaults to 0 if not specified

Example

use mlx_rs::Array;
// [5, 5] array with the lower triangle filled with 1s
let r = Array::tri::<f32>(5, None, None);

pub fn tri_device<T: ArrayElement>( n: i32, m: Option<i32>, k: Option<i32>, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around tri

Compatibility shim for tri.

impl Array

pub fn load_numpy(path: impl AsRef<Path>) -> Result<Array, IoError>

Load array from a binary file in .npy format.

Params

• path: path of file to load
• stream: stream or device to evaluate on

pub fn load_numpy_device( path: impl AsRef<Path>, stream: impl AsRef<Stream>, ) -> Result<Array, IoError>

👎Deprecated since 0.26.0:

use with_stream or with_device around load_numpy

Compatibility shim for [load_numpy].

pub fn load_safetensors( path: impl AsRef<Path>, ) -> Result<HashMap<String, Array>, IoError>

Load dictionary of MLXArray from a safetensors file.

Params

• path: path of file to load
• stream: stream or device to evaluate on

pub fn load_safetensors_device( path: impl AsRef<Path>, stream: impl AsRef<Stream>, ) -> Result<HashMap<String, Array>, IoError>

👎Deprecated since 0.26.0:

use with_stream or with_device around load_safetensors

Compatibility shim for [load_safetensors].

pub fn load_safetensors_with_metadata( path: impl AsRef<Path>, ) -> Result<(HashMap<String, Array>, HashMap<String, String>), IoError>

Load dictionary of MLXArray and metadata [String:String] from a safetensors file.

Params

• path: path of file to load
• stream: stream or device to evaluate on

pub fn load_safetensors_with_metadata_device( path: impl AsRef<Path>, stream: impl AsRef<Stream>, ) -> Result<(HashMap<String, Array>, HashMap<String, String>), IoError>

👎Deprecated since 0.26.0:

use with_stream or with_device around load_safetensors_with_metadata

Compatibility shim for [load_safetensors_with_metadata].

pub fn save_numpy(&self, path: impl AsRef<Path>) -> Result<(), IoError>

Save array to a binary file in .npyformat.

Params

• array: array to save
• url: URL of file to load

pub fn save_safetensors<'a, I, S, V>( arrays: I, metadata: impl Into<Option<&'a HashMap<String, String>>>, path: impl AsRef<Path>, ) -> Result<(), IoError>

where I: IntoIterator<Item = (S, V)>, S: AsRef<str>, V: AsRef<Array>,

Save dictionary of arrays in safetensors format.

Params

• arrays: arrays to save
• metadata: metadata to save
• path: path of file to save
• stream: stream or device to evaluate on

impl Array

pub fn eq(&self, other: impl AsRef<Array>) -> Result<Array>

Element-wise equality returning an error if the arrays are not broadcastable.

Equality comparison on two arrays with broadcasting.

Params

• other: array to compare

Example

use mlx_rs::Array;
let a = Array::from_slice(&[1, 2, 3], &[3]);
let b = Array::from_slice(&[1, 2, 3], &[3]);
let mut c = a.eq(&b).unwrap();

let c_data: &[bool] = c.as_slice();
// c_data == [true, true, true]

pub fn eq_device( &self, other: impl AsRef<Array>, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around eq

Compatibility shim for eq.

pub fn le(&self, other: impl AsRef<Array>) -> Result<Array>

Element-wise less than or equal returning an error if the arrays are not broadcastable.

Less than or equal on two arrays with broadcasting.

Params

• other: array to compare

Example

use mlx_rs::Array;
let a = Array::from_slice(&[1, 2, 3], &[3]);
let b = Array::from_slice(&[1, 2, 3], &[3]);
let mut c = a.le(&b).unwrap();

let c_data: &[bool] = c.as_slice();
// c_data == [true, true, true]

pub fn le_device( &self, other: impl AsRef<Array>, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around le

Compatibility shim for le.

pub fn ge(&self, other: impl AsRef<Array>) -> Result<Array>

Element-wise greater than or equal returning an error if the arrays are not broadcastable.

Greater than or equal on two arrays with broadcasting.

Params

• other: array to compare

Example

use mlx_rs::Array;
let a = Array::from_slice(&[1, 2, 3], &[3]);
let b = Array::from_slice(&[1, 2, 3], &[3]);
let mut c = a.ge(&b).unwrap();

let c_data: &[bool] = c.as_slice();
// c_data == [true, true, true]

pub fn ge_device( &self, other: impl AsRef<Array>, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around ge

Compatibility shim for ge.

pub fn ne(&self, other: impl AsRef<Array>) -> Result<Array>

Element-wise not equal returning an error if the arrays are not broadcastable.

Not equal on two arrays with broadcasting.

Params

• other: array to compare

Example

use mlx_rs::Array;
let a = Array::from_slice(&[1, 2, 3], &[3]);
let b = Array::from_slice(&[1, 2, 3], &[3]);
let mut c = a.ne(&b).unwrap();

let c_data: &[bool] = c.as_slice();
// c_data == [false, false, false]

pub fn ne_device( &self, other: impl AsRef<Array>, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around ne

Compatibility shim for ne.

pub fn lt(&self, other: impl AsRef<Array>) -> Result<Array>

Element-wise less than returning an error if the arrays are not broadcastable.

Less than on two arrays with broadcasting.

Params

• other: array to compare

Example

use mlx_rs::Array;
let a = Array::from_slice(&[1, 2, 3], &[3]);
let b = Array::from_slice(&[1, 2, 3], &[3]);
let mut c = a.lt(&b).unwrap();

let c_data: &[bool] = c.as_slice();
// c_data == [false, false, false]

pub fn lt_device( &self, other: impl AsRef<Array>, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around lt

Compatibility shim for lt.

pub fn gt(&self, other: impl AsRef<Array>) -> Result<Array>

Element-wise greater than returning an error if the arrays are not broadcastable.

Greater than on two arrays with broadcasting.

Params

• other: array to compare

Example

use mlx_rs::Array;
let a = Array::from_slice(&[1, 2, 3], &[3]);
let b = Array::from_slice(&[1, 2, 3], &[3]);
let mut c = a.gt(&b).unwrap();

let c_data: &[bool] = c.as_slice();
// c_data == [false, false, false]

pub fn gt_device( &self, other: impl AsRef<Array>, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around gt

Compatibility shim for gt.

pub fn logical_and(&self, other: impl AsRef<Array>) -> Result<Array>

Element-wise logical and returning an error if the arrays are not broadcastable.

Logical and on two arrays with broadcasting.

Params

• other: array to compare

Example

use mlx_rs::Array;
let a = Array::from_slice(&[true, false, true], &[3]);
let b = Array::from_slice(&[true, true, false], &[3]);
let mut c = a.logical_and(&b).unwrap();

let c_data: &[bool] = c.as_slice();
// c_data == [true, false, false]

pub fn logical_and_device( &self, other: impl AsRef<Array>, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around logical_and

Compatibility shim for logical_and.

pub fn logical_or(&self, other: impl AsRef<Array>) -> Result<Array>

Element-wise logical or returning an error if the arrays are not broadcastable.

Logical or on two arrays with broadcasting.

Params

• other: array to compare

Example

use mlx_rs::Array;
let a = Array::from_slice(&[true, false, true], &[3]);
let b = Array::from_slice(&[true, true, false], &[3]);
let mut c = a.logical_or(&b).unwrap();

let c_data: &[bool] = c.as_slice();
// c_data == [true, true, true]

pub fn logical_or_device( &self, other: impl AsRef<Array>, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around logical_or

Compatibility shim for logical_or.

pub fn logical_not(&self) -> Result<Array>

Unary element-wise logical not.

Example

use mlx_rs::Array;
let a: Array = false.into();
let mut b = a.logical_not().unwrap();

let b_data: &[bool] = b.as_slice();
// b_data == [true]

pub fn logical_not_device(&self, stream: impl AsRef<Stream>) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around logical_not

Compatibility shim for logical_not.

pub fn all_close( &self, other: impl AsRef<Array>, rtol: impl Into<Option<f64>>, atol: impl Into<Option<f64>>, equal_nan: impl Into<Option<bool>>, ) -> Result<bool>

Approximate comparison of two arrays returning an error if the inputs aren’t valid.

This evaluates the comparison result before returning a Rust bool.

The arrays are considered equal if:

all(abs(a - b) <= (atol + rtol * abs(b)))

Params

• other: array to compare
• rtol: relative tolerance = defaults to 1e-5 when None
• atol: absolute tolerance - defaults to 1e-8 when None
• equal_nan: whether to consider NaNs equal – default is false when None

Example

use num_traits::Pow;
use mlx_rs::array;
let a = array!([0., 1., 2., 3.]).sqrt().unwrap();
let b = array!([0., 1., 2., 3.]).power(array!(0.5)).unwrap();
assert!(a.all_close(&b, None, None, None).unwrap());

pub fn all_close_device( &self, other: impl AsRef<Array>, rtol: impl Into<Option<f64>>, atol: impl Into<Option<f64>>, equal_nan: impl Into<Option<bool>>, stream: impl AsRef<Stream>, ) -> Result<bool>

👎Deprecated since 0.26.0:

use with_stream or with_device around all_close

Compatibility shim for all_close.

pub fn is_close( &self, other: impl AsRef<Array>, rtol: impl Into<Option<f64>>, atol: impl Into<Option<f64>>, equal_nan: impl Into<Option<bool>>, ) -> Result<Array>

Returns a boolean array where two arrays are element-wise equal within a tolerance returning an error if the arrays are not broadcastable.

Infinite values are considered equal if they have the same sign, NaN values are not equal unless equalNAN is true.

Two values are considered close if:

abs(a - b) <= (atol + rtol * abs(b))

Unlike [self.array_eq] this function supports broadcasting.

pub fn is_close_device( &self, other: impl AsRef<Array>, rtol: impl Into<Option<f64>>, atol: impl Into<Option<f64>>, equal_nan: impl Into<Option<bool>>, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around is_close

Compatibility shim for is_close.

pub fn array_eq( &self, other: impl AsRef<Array>, equal_nan: impl Into<Option<bool>>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use eq_values for a Rust boolean

Array equality check.

Compare two arrays for equality. Returns true iff the arrays have the same shape and their values are equal. The arrays need not have the same type to be considered equal.

Params

• other: array to compare
• equal_nan: whether to consider NaNs equal – default is false when None

Example

use mlx_rs::Array;
let a = Array::from_slice(&[0, 1, 2, 3], &[4]);
let b = Array::from_slice(&[0., 1., 2., 3.], &[4]);

assert!(a.eq_values(&b).unwrap());

pub fn eq_exact(&self, other: impl AsRef<Array>) -> Result<bool>

Compare shape, dtype, and values exactly.

A dtype or shape mismatch returns false without evaluating either array. Otherwise this evaluates the equality result before returning a Rust bool. NaNs compare unequal.

pub fn eq_values(&self, other: impl AsRef<Array>) -> Result<bool>

Compare shape and values exactly while allowing different dtypes.

This evaluates the equality result before returning a Rust bool. NaNs compare unequal.

pub fn array_eq_device( &self, other: impl AsRef<Array>, equal_nan: impl Into<Option<bool>>, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around array_eq

Compatibility shim for array_eq.

pub fn any_axes( &self, axes: &[i32], keep_dims: impl Into<Option<bool>>, ) -> Result<Array>

An or reduction over the given axes returning an error if the axes are invalid.

Params

• axes: axes to reduce over – defaults to all axes if not provided
• keep_dims: if true keep reduced axis as singleton dimension – defaults to false if not provided

Example

use mlx_rs::Array;

let array = Array::from_slice(&[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], &[3, 4]);

// will produce a scalar Array with true -- some of the values are non-zero
let all = array.any(None).unwrap();

// produces an Array([true, true, true, true]) -- all rows have non-zeros
let all_rows = array.any_axes(&[0], None).unwrap();

pub fn any_axes_device( &self, axes: &[i32], keep_dims: impl Into<Option<bool>>, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around any_axes

Compatibility shim for any_axes.

pub fn any_axis( &self, axis: i32, keep_dims: impl Into<Option<bool>>, ) -> Result<Array>

Similar to any_axes but defaults to all axes.

pub fn any_axis_device( &self, axis: i32, keep_dims: impl Into<Option<bool>>, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around any_axis

Compatibility shim for any_axis.

pub fn any(&self, keep_dims: impl Into<Option<bool>>) -> Result<Array>

Similar to any_axes but defaults to all axes.

pub fn any_device( &self, keep_dims: impl Into<Option<bool>>, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around any

Compatibility shim for any.

impl Array

pub fn trace(&self, options: TraceOptions) -> Result<Array>

Sum a selected diagonal.

The diagonal is cast to the requested dtype before reduction. Reduction promotion can therefore produce a different final dtype.

use mlx_rs::{array, ops::TraceOptions, Dtype};

let result = array!([[1.0, 2.0], [3.0, 4.0]])
    .trace(TraceOptions {
        dtype: Some(Dtype::Int32),
        ..TraceOptions::default()
    })
    .unwrap();
assert!(result.shape().is_empty());

pub fn diag(&self, k: impl Into<Option<i32>>) -> Result<Array>

Extract a diagonal or construct a diagonal matrix.

If self is 1-D then a diagonal matrix is constructed with self on the k-th diagonal. If self is 2-D then the k-th diagonal is returned.

Params:

• k: the diagonal to extract or construct
• stream: stream or device to evaluate on

pub fn diag_device( &self, k: impl Into<Option<i32>>, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around diag

Compatibility shim for diag.

pub fn diagonal( &self, offset: impl Into<Option<i32>>, axis1: impl Into<Option<i32>>, axis2: impl Into<Option<i32>>, ) -> Result<Array>

Return specified diagonals.

If self is 2-D, then a 1-D array containing the diagonal at the given offset is returned.

If self has more than two dimensions, then axis1 and axis2 determine the 2D subarrays from which diagonals are extracted. The new shape is the original shape with axis1 and axis2 removed and a new dimension inserted at the end corresponding to the diagonal.

Params:

• offset: offset of the diagonal. Can be positive or negative
• axis1: first axis of the 2-D sub-array from which the diagonals should be taken
• axis2: second axis of the 2-D sub-array from which the diagonals should be taken
• stream: stream or device to evaluate on

pub fn diagonal_device( &self, offset: impl Into<Option<i32>>, axis1: impl Into<Option<i32>>, axis2: impl Into<Option<i32>>, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around diagonal

Compatibility shim for diagonal.

pub fn hadamard_transform(&self, scale: impl Into<Option<f32>>) -> Result<Array>

Perform the Walsh-Hadamard transform along the final axis.

Supports sizes n = m*2^k for m in (1, 12, 20, 28) and 2^k <= 8192 for DType/float32 and 2^k <= 16384 for DType/float16 and DType/bfloat16.

Params

• scale: scale the output by this factor – default is 1.0/sqrt(array.dim(-1))
• stream: stream to evaluate on.

pub fn hadamard_transform_device( &self, scale: impl Into<Option<f32>>, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around hadamard_transform

Compatibility shim for [hadamard_transform].

impl Array

pub fn count_nonzero(&self, options: CountNonzeroOptions) -> Result<Array>

Count values that compare unequal to zero.

The result is the sum of an i32 nonzero mask. An explicitly empty axis list returns that elementwise mask instead of reducing it.

use mlx_rs::{array, ops::CountNonzeroOptions, Axes, Dtype};

let input = array!([[0, 2], [3, 0]]);
let output = input
    .count_nonzero(CountNonzeroOptions {
        axes: Axes::Axis(0),
        keep_dims: false,
    })
    .unwrap();
assert_eq!(output.dtype(), Dtype::Int32);

pub fn all_axes( &self, axes: &[i32], keep_dims: impl Into<Option<bool>>, ) -> Result<Array>

An and reduction over the given axes returning an error if the axes are invalid.

Params

• axes: The axes to reduce over – defaults to all axes if not provided
• keep_dims: Whether to keep the reduced dimensions – defaults to false if not provided

Example

use mlx_rs::Array;
let a = Array::from_slice(&[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], &[3, 4]);
let mut b = a.all_axes(&[0], None).unwrap();

let results: &[bool] = b.as_slice();
// results == [false, true, true, true]

pub fn all_axes_device( &self, axes: &[i32], keep_dims: impl Into<Option<bool>>, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around all_axes

Compatibility shim for all_axes.

pub fn all_axis( &self, axis: i32, keep_dims: impl Into<Option<bool>>, ) -> Result<Array>

Similar to Array::all_axes but only reduces over a single axis.

pub fn all_axis_device( &self, axis: i32, keep_dims: impl Into<Option<bool>>, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around all_axis

Compatibility shim for all_axis.

pub fn all(&self, keep_dims: impl Into<Option<bool>>) -> Result<Array>

Similar to Array::all_axes but reduces over all axes.

pub fn all_device( &self, keep_dims: impl Into<Option<bool>>, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around all

Compatibility shim for all.

pub fn prod_axes( &self, axes: &[i32], keep_dims: impl Into<Option<bool>>, ) -> Result<Array>

A product reduction over the given axes returning an error if the axes are invalid.

Params

• axes: axes to reduce over
• keep_dims: Whether to keep the reduced dimensions – defaults to false if not provided

Example

use mlx_rs::Array;
let array = Array::from_slice(&[5, 8, 4, 9], &[2, 2]);

// result is [20, 72]
let result = array.prod_axes(&[0], None).unwrap();

pub fn prod_axes_device( &self, axes: &[i32], keep_dims: impl Into<Option<bool>>, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around prod_axes

Compatibility shim for prod_axes.

pub fn prod_axis( &self, axis: i32, keep_dims: impl Into<Option<bool>>, ) -> Result<Array>

Similar to Array::prod_axes but only reduces over a single axis.

pub fn prod_axis_device( &self, axis: i32, keep_dims: impl Into<Option<bool>>, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around prod_axis

Compatibility shim for prod_axis.

pub fn prod(&self, keep_dims: impl Into<Option<bool>>) -> Result<Array>

Similar to Array::prod_axes but reduces over all axes.

pub fn prod_device( &self, keep_dims: impl Into<Option<bool>>, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around prod

Compatibility shim for prod.

pub fn max_axes( &self, axes: &[i32], keep_dims: impl Into<Option<bool>>, ) -> Result<Array>

A max reduction over the given axes returning an error if the axes are invalid.

Params

• axes: axes to reduce over
• keep_dims: Whether to keep the reduced dimensions – defaults to false if not provided

Example

use mlx_rs::Array;
let array = Array::from_slice(&[5, 8, 4, 9], &[2, 2]);

// result is [5, 9]
let result = array.max_axes(&[0], None).unwrap();

pub fn max_axes_device( &self, axes: &[i32], keep_dims: impl Into<Option<bool>>, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around max_axes

Compatibility shim for max_axes.

pub fn max_axis( &self, axis: i32, keep_dims: impl Into<Option<bool>>, ) -> Result<Array>

Similar to Array::max_axes but only reduces over a single axis.

pub fn max_axis_device( &self, axis: i32, keep_dims: impl Into<Option<bool>>, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around max_axis

Compatibility shim for max_axis.

pub fn max(&self, keep_dims: impl Into<Option<bool>>) -> Result<Array>

Similar to Array::max_axes but reduces over all axes.

pub fn max_device( &self, keep_dims: impl Into<Option<bool>>, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around max

Compatibility shim for max.

pub fn sum_axes( &self, axes: &[i32], keep_dims: impl Into<Option<bool>>, ) -> Result<Array>

Sum reduce the array over the given axes returning an error if the axes are invalid.

Params

• axes: axes to reduce over
• keep_dims: if true, keep the reduces axes as singleton dimensions

Example

use mlx_rs::Array;
let array = Array::from_slice(&[5, 8, 4, 9], &[2, 2]);

// result is [9, 17]
let result = array.sum_axes(&[0], None).unwrap();

pub fn sum_axes_device( &self, axes: &[i32], keep_dims: impl Into<Option<bool>>, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around sum_axes

Compatibility shim for sum_axes.

pub fn sum_axis( &self, axis: i32, keep_dims: impl Into<Option<bool>>, ) -> Result<Array>

Similar to Array::sum_axes but only reduces over a single axis.

pub fn sum_axis_device( &self, axis: i32, keep_dims: impl Into<Option<bool>>, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around sum_axis

Compatibility shim for sum_axis.

pub fn sum(&self, keep_dims: impl Into<Option<bool>>) -> Result<Array>

Similar to Array::sum_axes but reduces over all axes.

pub fn sum_device( &self, keep_dims: impl Into<Option<bool>>, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around sum

Compatibility shim for sum.

pub fn mean_axes( &self, axes: &[i32], keep_dims: impl Into<Option<bool>>, ) -> Result<Array>

A mean reduction over the given axes returning an error if the axes are invalid.

Params

• axes: axes to reduce over
• keep_dims: Whether to keep the reduced dimensions – defaults to false if not provided

Example

use mlx_rs::Array;
let array = Array::from_slice(&[5, 8, 4, 9], &[2, 2]);

// result is [4.5, 8.5]
let result = array.mean_axes(&[0], None).unwrap();

pub fn mean_axes_device( &self, axes: &[i32], keep_dims: impl Into<Option<bool>>, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around mean_axes

Compatibility shim for mean_axes.

pub fn mean_axis( &self, axis: i32, keep_dims: impl Into<Option<bool>>, ) -> Result<Array>

Similar to Array::mean_axes but only reduces over a single axis.

pub fn mean_axis_device( &self, axis: i32, keep_dims: impl Into<Option<bool>>, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around mean_axis

Compatibility shim for mean_axis.

pub fn mean(&self, keep_dims: impl Into<Option<bool>>) -> Result<Array>

Similar to Array::mean_axes but reduces over all axes.

pub fn mean_device( &self, keep_dims: impl Into<Option<bool>>, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around mean

Compatibility shim for mean.

pub fn min_axes( &self, axes: &[i32], keep_dims: impl Into<Option<bool>>, ) -> Result<Array>

A min reduction over the given axes returning an error if the axes are invalid.

Params

• axes: axes to reduce over
• keep_dims: Whether to keep the reduced dimensions – defaults to false if not provided

Example

use mlx_rs::Array;
let array = Array::from_slice(&[5, 8, 4, 9], &[2, 2]);

// result is [4, 8]
let result = array.min_axes(&[0], None).unwrap();

pub fn min_axes_device( &self, axes: &[i32], keep_dims: impl Into<Option<bool>>, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around min_axes

Compatibility shim for min_axes.

pub fn min_axis( &self, axis: i32, keep_dims: impl Into<Option<bool>>, ) -> Result<Array>

Similar to Array::min_axes but only reduces over a single axis.

pub fn min_axis_device( &self, axis: i32, keep_dims: impl Into<Option<bool>>, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around min_axis

Compatibility shim for min_axis.

pub fn min(&self, keep_dims: impl Into<Option<bool>>) -> Result<Array>

Similar to Array::min_axes but reduces over all axes.

pub fn min_device( &self, keep_dims: impl Into<Option<bool>>, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around min

Compatibility shim for min.

pub fn var_axes( &self, axes: &[i32], keep_dims: impl Into<Option<bool>>, ddof: impl Into<Option<i32>>, ) -> Result<Array>

Compute the variance(s) over the given axes returning an error if the axes are invalid.

Params

• axes: axes to reduce over
• keep_dims: if true, keep the reduces axes as singleton dimensions
• ddof: the divisor to compute the variance is N - ddof

pub fn var_axes_device( &self, axes: &[i32], keep_dims: impl Into<Option<bool>>, ddof: impl Into<Option<i32>>, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around var_axes

Compatibility shim for var_axes.

pub fn var_axis( &self, axis: i32, keep_dims: impl Into<Option<bool>>, ddof: impl Into<Option<i32>>, ) -> Result<Array>

Similar to Array::var_axes but only reduces over a single axis.

pub fn var_axis_device( &self, axis: i32, keep_dims: impl Into<Option<bool>>, ddof: impl Into<Option<i32>>, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around var_axis

Compatibility shim for var_axis.

pub fn var( &self, keep_dims: impl Into<Option<bool>>, ddof: impl Into<Option<i32>>, ) -> Result<Array>

Similar to Array::var_axes but reduces over all axes.

pub fn var_device( &self, keep_dims: impl Into<Option<bool>>, ddof: impl Into<Option<i32>>, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around var

Compatibility shim for var.

pub fn median_axes( &self, axes: &[i32], keep_dims: impl Into<Option<bool>>, ) -> Result<Array>

Compute the median over the given axes.

Params

• axes: axes to reduce over
• keep_dims: Whether to keep the reduced dimensions – defaults to false if not provided

pub fn median_axes_device( &self, axes: &[i32], keep_dims: impl Into<Option<bool>>, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around median_axes

Compatibility shim for median_axes.

pub fn median_axis( &self, axis: i32, keep_dims: impl Into<Option<bool>>, ) -> Result<Array>

Similar to Array::median_axes but only reduces over a single axis.

pub fn median_axis_device( &self, axis: i32, keep_dims: impl Into<Option<bool>>, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around median_axis

Compatibility shim for median_axis.

pub fn median(&self, keep_dims: impl Into<Option<bool>>) -> Result<Array>

Compute the median over all axes.

pub fn median_device( &self, keep_dims: impl Into<Option<bool>>, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around median

Compatibility shim for median.

pub fn logsumexp_axes( &self, axes: &[i32], keep_dims: impl Into<Option<bool>>, ) -> Result<Array>

A log-sum-exp reduction over the given axes returning an error if the axes are invalid.

The log-sum-exp reduction is a numerically stable version of using the individual operations.

Params

• axes: axes to reduce over
• keep_dims: Whether to keep the reduced dimensions – defaults to false if not provided

pub fn logsumexp_axes_device( &self, axes: &[i32], keep_dims: impl Into<Option<bool>>, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around logsumexp_axes

Compatibility shim for logsumexp_axes.

pub fn logsumexp_axis( &self, axis: i32, keep_dims: impl Into<Option<bool>>, ) -> Result<Array>

Similar to Array::logsumexp_axes but only reduces over a single axis.

pub fn logsumexp_axis_device( &self, axis: i32, keep_dims: impl Into<Option<bool>>, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around logsumexp_axis

Compatibility shim for logsumexp_axis.

pub fn logsumexp(&self, keep_dims: impl Into<Option<bool>>) -> Result<Array>

Similar to Array::logsumexp_axes but reduces over all axes.

pub fn logsumexp_device( &self, keep_dims: impl Into<Option<bool>>, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around logsumexp

Compatibility shim for logsumexp.

impl Array

pub fn contiguous(&self) -> Result<Array>

Return an array that is row-major contiguous after evaluation.

MLX may share the input buffer when it is already suitable.

pub fn contiguous_with_options( &self, options: ContiguousOptions, ) -> Result<Array>

Materialize a contiguous array according to options.

Allowing column-major layout does not force it and does not guarantee that the result can be borrowed with Array::try_as_slice.

pub fn flip(&self, axes: Axes) -> Result<Array>

Reverse elements along selected axes.

Axes::All reverses every axis, while an explicitly empty axis list is an identity.

use mlx_rs::{array, Axes};

let output = array!([[1, 2], [3, 4]]).flip(Axes::Axis(-1)).unwrap();
assert_eq!(output.shape(), &[2, 2]);

pub fn unstack(&self, axis: i32) -> Result<Vec<Array>>

Split an array along axis and squeeze that axis from every output.

A zero-length selected axis returns an empty vector.

use mlx_rs::array;

let parts = array!([[1, 2], [3, 4]]).unstack(0).unwrap();
assert_eq!(parts.len(), 2);
assert_eq!(parts[0].shape(), &[2]);

pub fn expand_dims(&self, axis: i32) -> Result<Array>

See expand_dims().

pub fn expand_dims_device( &self, axis: i32, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around expand_dims

Compatibility shim for expand_dims.

pub fn expand_dims_axes(&self, axes: &[i32]) -> Result<Array>

See expand_dims_axes().

pub fn expand_dims_axes_device( &self, axes: &[i32], stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around expand_dims_axes

Compatibility shim for expand_dims_axes.

pub fn flatten( &self, start_axis: impl Into<Option<i32>>, end_axis: impl Into<Option<i32>>, ) -> Result<Array>

See flatten.

pub fn flatten_device( &self, start_axis: impl Into<Option<i32>>, end_axis: impl Into<Option<i32>>, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around flatten

Compatibility shim for flatten.

pub fn reshape(&self, shape: &[i32]) -> Result<Array>

See reshape.

pub fn reshape_device( &self, shape: &[i32], stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around reshape

Compatibility shim for reshape.

pub fn squeeze_axes(&self, axes: &[i32]) -> Result<Array>

See squeeze_axes().

pub fn squeeze_axes_device( &self, axes: &[i32], stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around squeeze_axes

Compatibility shim for squeeze_axes.

pub fn squeeze(&self) -> Result<Array>

See squeeze().

pub fn squeeze_device(&self, stream: impl AsRef<Stream>) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around squeeze

Compatibility shim for squeeze.

pub fn as_strided<'a>( &'a self, shape: impl IntoOption<&'a [i32]>, strides: impl IntoOption<&'a [i64]>, offset: impl Into<Option<usize>>, ) -> Result<Array>

See as_strided

pub fn as_strided_device<'a>( &'a self, shape: impl IntoOption<&'a [i32]>, strides: impl IntoOption<&'a [i64]>, offset: impl Into<Option<usize>>, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around as_strided

Compatibility shim for as_strided.

pub fn at_least_1d(&self) -> Result<Array>

See at_least_1d

pub fn at_least_1d_device(&self, stream: impl AsRef<Stream>) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around at_least_1d

Compatibility shim for at_least_1d.

pub fn at_least_2d(&self) -> Result<Array>

See at_least_2d

pub fn at_least_2d_device(&self, stream: impl AsRef<Stream>) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around at_least_2d

Compatibility shim for at_least_2d.

pub fn at_least_3d(&self) -> Result<Array>

See at_least_3d

pub fn at_least_3d_device(&self, stream: impl AsRef<Stream>) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around at_least_3d

Compatibility shim for at_least_3d.

pub fn move_axis(&self, src: i32, dst: i32) -> Result<Array>

See move_axis

pub fn move_axis_device( &self, src: i32, dst: i32, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around move_axis

Compatibility shim for move_axis.

pub fn split_at_indices( &self, indices: &[i32], axis: impl Into<Option<i32>>, ) -> Result<Vec<Array>>

See split_at_indices.

pub fn split_axis( &self, indices: &[i32], axis: impl Into<Option<i32>>, ) -> Result<Vec<Array>>

👎Deprecated since 0.26.0:

renamed to split_at_indices

Compatibility alias for Array::split_at_indices.

pub fn split_axis_device( &self, indices: &[i32], axis: impl Into<Option<i32>>, stream: impl AsRef<Stream>, ) -> Result<Vec<Array>>

👎Deprecated since 0.26.0:

use with_stream or with_device around split_at_indices

Compatibility shim for [split_axis].

pub fn split_equal( &self, num_parts: i32, axis: impl Into<Option<i32>>, ) -> Result<Vec<Array>>

See split_equal.

pub fn split( &self, num_parts: i32, axis: impl Into<Option<i32>>, ) -> Result<Vec<Array>>

👎Deprecated since 0.26.0:

renamed to split_equal

Compatibility alias for Array::split_equal.

pub fn split_device( &self, num_parts: i32, axis: impl Into<Option<i32>>, stream: impl AsRef<Stream>, ) -> Result<Vec<Array>>

👎Deprecated since 0.26.0:

use with_stream or with_device around split_equal

Compatibility shim for split.

pub fn swap_axes(&self, axis1: i32, axis2: i32) -> Result<Array>

See swap_axes

pub fn swap_axes_device( &self, axis1: i32, axis2: i32, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around swap_axes

Compatibility shim for swap_axes.

pub fn transpose_axes(&self, axes: &[i32]) -> Result<Array>

See transpose_axes

pub fn transpose_axes_device( &self, axes: &[i32], stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around transpose_axes

Compatibility shim for transpose_axes.

pub fn transpose(&self) -> Result<Array>

See transpose

pub fn transpose_device(&self, stream: impl AsRef<Stream>) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around transpose

Compatibility shim for transpose.

pub fn t(&self) -> Array

transpose_axes and unwrap the result.

impl Array

pub fn search_sorted( &self, values: impl AsRef<Array>, side: SearchSide, ) -> Result<Array>

Find insertion indices for values in this one-dimensional sequence.

The result has the values’ shape and u32 dtype. Sortedness is not validated; results for unsorted sequences are unspecified.

use mlx_rs::{array, ops::SearchSide, Dtype};

let result = array!([1, 2, 2, 3])
    .search_sorted(array!([2]), SearchSide::Right)
    .unwrap();
assert_eq!(result.dtype(), Dtype::Uint32);

impl Array

pub fn take_axis(&self, indices: impl AsRef<Array>, axis: i32) -> Result<Array>

Take elements along an axis.

The elements are taken from indices along the specified axis. If the axis is not specified the array is treated as a flattened 1-D array prior to performing the take.

See [Array::take_all] for the flattened array.

Params

• indices: The indices to take from the array.
• axis: The axis along which to take the elements.

pub fn take_axis_device( &self, indices: impl AsRef<Array>, axis: i32, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around take_axis

Compatibility shim for take_axis.

pub fn take(&self, indices: impl AsRef<Array>) -> Result<Array>

Take elements from flattened 1-D array.

Params

• indices: The indices to take from the array.

pub fn take_device( &self, indices: impl AsRef<Array>, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around take

Compatibility shim for take.

pub fn take_along_axis( &self, indices: impl AsRef<Array>, axis: impl Into<Option<i32>>, ) -> Result<Array>

Take values along an axis at the specified indices.

If no axis is specified, the array is flattened to 1D prior to the indexing operation.

Params

• indices: The indices to take from the array.
• axis: Axis in the input to take the values from.

pub fn take_along_axis_device( &self, indices: impl AsRef<Array>, axis: impl Into<Option<i32>>, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around take_along_axis

Compatibility shim for take_along_axis.

pub fn put_along_axis( &self, indices: impl AsRef<Array>, values: impl AsRef<Array>, axis: impl Into<Option<i32>>, ) -> Result<Array>

Put values along an axis at the specified indices.

If no axis is specified, the array is flattened to 1D prior to the indexing operation.

Params

• indices: Indices array. These should be broadcastable with the input array excluding the axis dimension.
• values: Values array. These should be broadcastable with the indices.
• axis: Axis in the destination to put the values to.
• stream: stream or device to evaluate on.

pub fn put_along_axis_device( &self, indices: impl AsRef<Array>, values: impl AsRef<Array>, axis: impl Into<Option<i32>>, stream: impl AsRef<Stream>, ) -> Result<Array>

👎Deprecated since 0.26.0:

use with_stream or with_device around put_along_axis

Compatibility shim for put_along_axis.

Trait Implementations

impl<'a, T> Add<T> for Array

where T: ScalarOrArray<'a>,

type Output = Array

The resulting type after applying the + operator.

fn add(self, rhs: T) -> Self::Output

Performs the + operation.

impl<'a, 't: 'a, T> Add<T> for &'a Array

where T: ScalarOrArray<'t>,

type Output = Array

The resulting type after applying the + operator.

fn add(self, rhs: T) -> Self::Output

Performs the + operation.

impl AddAssign<&Array> for Array

fn add_assign(&mut self, rhs: &Self)

Performs the += operation.

impl<T: Into<Array>> AddAssign<T> for Array

fn add_assign(&mut self, rhs: T)

Performs the += operation.

impl<'a> ArrayIndex<'a> for Array

fn index_op(self) -> ArrayIndexOp<'a>

mlx allows out of bounds indexing.

impl<'a> ArrayIndex<'a> for &'a Array

fn index_op(self) -> ArrayIndexOp<'a>

mlx allows out of bounds indexing.

impl AsRef<Array> for Array

fn as_ref(&self) -> &Array

Converts this type into a shared reference of the (usually inferred) input type.

impl<'a, F, G> CallMut<&'a Array, Array, ()> for Compiled<F, G>

where F: FnMut(&Array) -> Array + 'a, G: FnMut(&[Array]) -> Vec<Array> + 'a,

fn call_mut(&mut self, args: &Array) -> Result<Array, Exception>

Calls the compiled function with the given arguments.

impl<'a, F, G> CallMut<&'a Array, Array, Exception> for Compiled<F, G>

where F: FnMut(&Array) -> Result<Array, Exception> + 'a, G: FnMut(&[Array]) -> Result<Vec<Array>, Exception> + 'a,

fn call_mut(&mut self, args: &Array) -> Result<Array, Exception>

Calls the compiled function with the given arguments.

impl<'a, F, G> CallMut<(&'a Array, &'a Array), Array, ()> for Compiled<F, G>

where F: FnMut((&Array, &Array)) -> Array + 'a, G: FnMut(&[Array]) -> Vec<Array> + 'a,

fn call_mut(&mut self, args: (&Array, &Array)) -> Result<Array, Exception>

Calls the compiled function with the given arguments.

impl<'a, F, G> CallMut<(&'a Array, &'a Array), Array, Exception> for Compiled<F, G>

where F: FnMut((&Array, &Array)) -> Result<Array, Exception> + 'a, G: FnMut(&[Array]) -> Result<Vec<Array>, Exception> + 'a,

fn call_mut(&mut self, args: (&Array, &Array)) -> Result<Array, Exception>

Calls the compiled function with the given arguments.

impl<'a, F, G> CallMut<(&'a Array, &'a Array, &'a Array), Array, ()> for Compiled<F, G>

where F: FnMut((&Array, &Array, &Array)) -> Array + 'a, G: FnMut(&[Array]) -> Vec<Array> + 'a,

fn call_mut( &mut self, args: (&Array, &Array, &Array), ) -> Result<Array, Exception>

Calls the compiled function with the given arguments.

impl<'a, F, G> CallMut<(&'a Array, &'a Array, &'a Array), Array, Exception> for Compiled<F, G>

where F: FnMut((&Array, &Array, &Array)) -> Result<Array, Exception> + 'a, G: FnMut(&[Array]) -> Result<Vec<Array>, Exception> + 'a,

fn call_mut( &mut self, args: (&Array, &Array, &Array), ) -> Result<Array, Exception>

Calls the compiled function with the given arguments.

impl<U, F, G> CallMutWithState<U, &Array, Array, ()> for Compiled<F, G>

where F: FnMut(&mut U, &Array) -> Array, G: FnMut(&mut U, &[Array]) -> Vec<Array>, U: Updatable,

fn call_mut(&mut self, state: &mut U, args: &Array) -> Result<Array, Exception>

Call the function with the given state and arguments.

impl<U, F, G> CallMutWithState<U, &Array, Array, Exception> for Compiled<F, G>

where F: FnMut(&mut U, &Array) -> Result<Array, Exception>, G: FnMut(&mut U, &[Array]) -> Result<Vec<Array>, Exception>, U: Updatable,

fn call_mut(&mut self, state: &mut U, args: &Array) -> Result<Array, Exception>

Call the function with the given state and arguments.

impl<U, F, G> CallMutWithState<U, (&Array, &Array), Array, ()> for Compiled<F, G>

where F: FnMut(&mut U, (&Array, &Array)) -> Array, G: FnMut(&mut U, &[Array]) -> Vec<Array>, U: Updatable,

fn call_mut( &mut self, state: &mut U, args: (&Array, &Array), ) -> Result<Array, Exception>

Call the function with the given state and arguments.

impl<U, F, G> CallMutWithState<U, (&Array, &Array), Array, Exception> for Compiled<F, G>

where F: FnMut(&mut U, (&Array, &Array)) -> Result<Array, Exception>, G: FnMut(&mut U, &[Array]) -> Result<Vec<Array>, Exception>, U: Updatable,

fn call_mut( &mut self, state: &mut U, args: (&Array, &Array), ) -> Result<Array, Exception>

Call the function with the given state and arguments.

impl<U, F, G> CallMutWithState<U, (&Array, &Array, &Array), Array, ()> for Compiled<F, G>

where F: FnMut(&mut U, (&Array, &Array, &Array)) -> Array, G: FnMut(&mut U, &[Array]) -> Vec<Array>, U: Updatable,

fn call_mut( &mut self, state: &mut U, args: (&Array, &Array, &Array), ) -> Result<Array, Exception>

Call the function with the given state and arguments.

impl<U, F, G> CallMutWithState<U, (&Array, &Array, &Array), Array, Exception> for Compiled<F, G>

where F: FnMut(&mut U, (&Array, &Array, &Array)) -> Result<Array, Exception>, G: FnMut(&mut U, &[Array]) -> Result<Vec<Array>, Exception>, U: Updatable,

fn call_mut( &mut self, state: &mut U, args: (&Array, &Array, &Array), ) -> Result<Array, Exception>

Call the function with the given state and arguments.

impl Clone for Array

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<F> Compile<&Array, Array, ()> for F

where F: FnMut(&Array) -> Array + 'static,

type Args<'a> = &'a Array

The type of the arguments that the returned closure takes.

fn compile( self, shapeless: bool, ) -> impl for<'args> CallMut<Self::Args<'args>, Array, ()>

Compiles the function.

impl<F> Compile<&Array, Array, Exception> for F

where F: FnMut(&Array) -> Result<Array, Exception> + 'static,

type Args<'a> = &'a Array

The type of the arguments that the returned closure takes.

fn compile( self, shapeless: bool, ) -> impl for<'args> CallMut<Self::Args<'args>, Array, Exception>

Compiles the function.

impl<F> Compile<(&Array, &Array), Array, ()> for F

where F: FnMut((&Array, &Array)) -> Array + 'static,

type Args<'a> = (&'a Array, &'a Array)

The type of the arguments that the returned closure takes.

fn compile( self, shapeless: bool, ) -> impl for<'args> CallMut<Self::Args<'args>, Array, ()>

Compiles the function.

impl<F> Compile<(&Array, &Array), Array, Exception> for F

where F: FnMut((&Array, &Array)) -> Result<Array, Exception> + 'static,

type Args<'a> = (&'a Array, &'a Array)

The type of the arguments that the returned closure takes.

fn compile( self, shapeless: bool, ) -> impl for<'args> CallMut<Self::Args<'args>, Array, Exception>

Compiles the function.

impl<F> Compile<(&Array, &Array, &Array), Array, ()> for F

where F: FnMut((&Array, &Array, &Array)) -> Array + 'static,

type Args<'a> = (&'a Array, &'a Array, &'a Array)

The type of the arguments that the returned closure takes.

fn compile( self, shapeless: bool, ) -> impl for<'args> CallMut<Self::Args<'args>, Array, ()>

Compiles the function.

impl<F> Compile<(&Array, &Array, &Array), Array, Exception> for F

where F: FnMut((&Array, &Array, &Array)) -> Result<Array, Exception> + 'static,

type Args<'a> = (&'a Array, &'a Array, &'a Array)

The type of the arguments that the returned closure takes.

fn compile( self, shapeless: bool, ) -> impl for<'args> CallMut<Self::Args<'args>, Array, Exception>

Compiles the function.

impl<F, U> CompileWithState<U, &Array, Array, ()> for F

where F: FnMut(&mut U, &Array) -> Array + 'static, U: Updatable,

type Args<'a> = &'a Array

The type of the arguments that the returned closure takes.

fn compile( self, shapeless: bool, ) -> impl for<'args> CallMutWithState<U, Self::Args<'args>, Array, ()>

Compile the function.

impl<F, U> CompileWithState<U, &Array, Array, Exception> for F

where F: FnMut(&mut U, &Array) -> Result<Array, Exception> + 'static, U: Updatable,

type Args<'a> = &'a Array

The type of the arguments that the returned closure takes.

fn compile( self, shapeless: bool, ) -> impl for<'args> CallMutWithState<U, Self::Args<'args>, Array, Exception>

Compile the function.

impl<F, U> CompileWithState<U, (&Array, &Array), Array, ()> for F

where F: FnMut(&mut U, (&Array, &Array)) -> Array + 'static, U: Updatable,

type Args<'a> = (&'a Array, &'a Array)

The type of the arguments that the returned closure takes.

fn compile( self, shapeless: bool, ) -> impl for<'args> CallMutWithState<U, Self::Args<'args>, Array, ()>

Compile the function.

impl<F, U> CompileWithState<U, (&Array, &Array), Array, Exception> for F

where F: FnMut(&mut U, (&Array, &Array)) -> Result<Array, Exception> + 'static, U: Updatable,

type Args<'a> = (&'a Array, &'a Array)

The type of the arguments that the returned closure takes.

fn compile( self, shapeless: bool, ) -> impl for<'args> CallMutWithState<U, Self::Args<'args>, Array, Exception>

Compile the function.

impl<F, U> CompileWithState<U, (&Array, &Array, &Array), Array, ()> for F

where F: FnMut(&mut U, (&Array, &Array, &Array)) -> Array + 'static, U: Updatable,

type Args<'a> = (&'a Array, &'a Array, &'a Array)

The type of the arguments that the returned closure takes.

fn compile( self, shapeless: bool, ) -> impl for<'args> CallMutWithState<U, Self::Args<'args>, Array, ()>

Compile the function.

impl<F, U> CompileWithState<U, (&Array, &Array, &Array), Array, Exception> for F

where F: FnMut(&mut U, (&Array, &Array, &Array)) -> Result<Array, Exception> + 'static, U: Updatable,

type Args<'a> = (&'a Array, &'a Array, &'a Array)

The type of the arguments that the returned closure takes.

fn compile( self, shapeless: bool, ) -> impl for<'args> CallMutWithState<U, Self::Args<'args>, Array, Exception>

Compile the function.

impl Debug for Array

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

Formats the value using the given formatter.

impl Display for Array

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

Formats the value using the given formatter.

impl<'a, T> Div<T> for Array

where T: ScalarOrArray<'a>,

type Output = Array

The resulting type after applying the / operator.

fn div(self, rhs: T) -> Self::Output

Performs the / operation.

impl<'a, 't: 'a, T> Div<T> for &'a Array

where T: ScalarOrArray<'t>,

type Output = Array

The resulting type after applying the / operator.

fn div(self, rhs: T) -> Self::Output

Performs the / operation.

impl DivAssign<&Array> for Array

fn div_assign(&mut self, rhs: &Self)

Performs the /= operation.

impl<T: Into<Array>> DivAssign<T> for Array

fn div_assign(&mut self, rhs: T)

Performs the /= operation.

impl Drop for Array

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl<'a> From<&'a Array> for ScaledDotProductAttentionMask<'a>

fn from(mask: &'a Array) -> Self

Converts to this type from the input type.

impl<'a> From<&'a Array> for RopeInput<'a>

fn from(x: &'a Array) -> Self

Converts to this type from the input type.

impl<'a> From<&'a Array> for AlibiInput<'a>

fn from(attention_scores: &'a Array) -> Self

Converts to this type from the input type.

impl<'a> From<&'a Array> for RnnInput<'a>

fn from(x: &'a Array) -> Self

Converts to this type from the input type.

impl<'a> From<&'a Array> for LstmInput<'a>

fn from(x: &'a Array) -> Self

Converts to this type from the input type.

impl From<&Array> for GgufMetadataValue

fn from(value: &Array) -> Self

Converts to this type from the input type.

impl From<Array> for GgufMetadataValue

fn from(value: Array) -> Self

Converts to this type from the input type.

impl From<Complex<f32>> for Array

fn from(value: complex64) -> Self

Converts to this type from the input type.

impl<T> From<T> for Array

where Array: FromNested<T>,

fn from(value: T) -> Self

Converts to this type from the input type.

impl From<bool> for Array

fn from(value: bool) -> Self

Converts to this type from the input type.

impl From<f32> for Array

fn from(value: f32) -> Self

Converts to this type from the input type.

impl From<i32> for Array

fn from(value: i32) -> Self

Converts to this type from the input type.

impl<T: FromSliceElement + Copy, const N: usize, const M: usize, const O: usize> FromNested<&[&[&[T; N]; M]; O]> for Array

fn from_nested(data: &[&[&[T; N]; M]; O]) -> Self

Create an array from nested arrays or slices.

impl<T: FromSliceElement + Copy> FromNested<&[&[&[T]]]> for Array

fn from_nested(data: &[&[&[T]]]) -> Self

Create an array from nested arrays or slices.

impl<T: FromSliceElement + Copy, const N: usize, const M: usize> FromNested<&[&[T; N]; M]> for Array

fn from_nested(data: &[&[T; N]; M]) -> Self

Create an array from nested arrays or slices.

impl<T: FromSliceElement + Copy, const N: usize> FromNested<&[&[T; N]]> for Array

fn from_nested(data: &[&[T; N]]) -> Self

Create an array from nested arrays or slices.

impl<T: FromSliceElement + Copy> FromNested<&[&[T]]> for Array

fn from_nested(data: &[&[T]]) -> Self

Create an array from nested arrays or slices.

impl<T: FromSliceElement + Copy, const N: usize, const M: usize, const O: usize> FromNested<&[&[[T; N]; M]; O]> for Array

fn from_nested(data: &[&[[T; N]; M]; O]) -> Self

Create an array from nested arrays or slices.

impl<T: FromSliceElement + Copy, const N: usize, const M: usize> FromNested<&[&[[T; N]]; M]> for Array

fn from_nested(data: &[&[[T; N]]; M]) -> Self

Create an array from nested arrays or slices.

impl<T: FromSliceElement + Copy, const N: usize> FromNested<&[&[[T; N]]]> for Array

fn from_nested(data: &[&[[T; N]]]) -> Self

Create an array from nested arrays or slices.

impl<T: FromSliceElement, const N: usize> FromNested<&[T; N]> for Array

fn from_nested(data: &[T; N]) -> Self

Create an array from nested arrays or slices.

impl<T: FromSliceElement> FromNested<&[T]> for Array

fn from_nested(data: &[T]) -> Self

Create an array from nested arrays or slices.

impl<T: FromSliceElement + Copy, const N: usize, const M: usize, const O: usize> FromNested<&[[&[T; N]; M]; O]> for Array

fn from_nested(data: &[[&[T; N]; M]; O]) -> Self

Create an array from nested arrays or slices.

impl<T: FromSliceElement + Copy, const N: usize, const M: usize> FromNested<&[[&[T]; N]; M]> for Array

fn from_nested(data: &[[&[T]; N]; M]) -> Self

Create an array from nested arrays or slices.

impl<T: FromSliceElement + Copy, const N: usize> FromNested<&[[&[T]; N]]> for Array

fn from_nested(data: &[[&[T]; N]]) -> Self

Create an array from nested arrays or slices.

impl<T: FromSliceElement + Copy, const N: usize, const M: usize> FromNested<&[[T; N]; M]> for Array

fn from_nested(data: &[[T; N]; M]) -> Self

Create an array from nested arrays or slices.

impl<T: FromSliceElement + Copy, const N: usize> FromNested<&[[T; N]]> for Array

fn from_nested(data: &[[T; N]]) -> Self

Create an array from nested arrays or slices.

impl<T: FromSliceElement + Copy, const N: usize, const M: usize, const O: usize> FromNested<&[[[T; N]; M]; O]> for Array

fn from_nested(data: &[[[T; N]; M]; O]) -> Self

Create an array from nested arrays or slices.

impl<T: FromSliceElement + Copy, const N: usize> FromNested<[&[&[T]]; N]> for Array

fn from_nested(data: [&[&[T]]; N]) -> Self

Create an array from nested arrays or slices.

impl<T: FromSliceElement + Copy, const N: usize> FromNested<[&[T]; N]> for Array

fn from_nested(data: [&[T]; N]) -> Self

Create an array from nested arrays or slices.

impl<T: FromSliceElement, const N: usize> FromNested<[T; N]> for Array

fn from_nested(data: [T; N]) -> Self

Create an array from nested arrays or slices.

impl<T: FromSliceElement + Copy, const N: usize, const M: usize> FromNested<[[&[T]; N]; M]> for Array

fn from_nested(data: [[&[T]; N]; M]) -> Self

Create an array from nested arrays or slices.

impl<T: FromSliceElement + Copy, const N: usize, const M: usize> FromNested<[[T; N]; M]> for Array

fn from_nested(data: [[T; N]; M]) -> Self

Create an array from nested arrays or slices.

impl<T: FromSliceElement + Copy, const N: usize, const M: usize, const O: usize> FromNested<[[[T; N]; M]; O]> for Array

fn from_nested(data: [[[T; N]; M]; O]) -> Self

Create an array from nested arrays or slices.

impl FromScalar<Complex<f32>> for Array

fn from_scalar(val: complex64) -> Array

Create an array from a scalar value.

impl FromScalar<bool> for Array

fn from_scalar(val: bool) -> Array

Create an array from a scalar value.

impl FromScalar<f32> for Array

fn from_scalar(val: f32) -> Array

Create an array from a scalar value.

impl FromScalar<i32> for Array

fn from_scalar(val: i32) -> Array

Create an array from a scalar value.

impl<'a, F> IntoGrad<'a, &Array, Array, ()> for F

where F: FnMut(&Array) -> Array + 'a,

fn into_grad( self, argnums: impl IntoOption<&'a [i32]>, ) -> impl FnMut(&Array) -> Result<Array> + 'a

Convert the function/closure into a closure that computes the gradient.

impl<'a, F> IntoGrad<'a, &Array, Array, Exception> for F

where F: FnMut(&Array) -> Result<Array> + 'a,

fn into_grad( self, argnums: impl IntoOption<&'a [i32]>, ) -> impl FnMut(&Array) -> Result<Array> + 'a

Convert the function/closure into a closure that computes the gradient.

impl<'a, F> IntoGrad<'a, &Array, Vec<Array>, ()> for F

where F: FnMut(&Array) -> Vec<Array> + 'a,

fn into_grad( self, argnums: impl IntoOption<&'a [i32]>, ) -> impl FnMut(&Array) -> Result<Vec<Array>> + 'a

Convert the function/closure into a closure that computes the gradient.

impl<'a, F> IntoGrad<'a, &Array, Vec<Array>, Exception> for F

where F: FnMut(&Array) -> Result<Vec<Array>> + 'a,

fn into_grad( self, argnums: impl IntoOption<&'a [i32]>, ) -> impl FnMut(&Array) -> Result<Vec<Array>> + 'a

Convert the function/closure into a closure that computes the gradient.

impl<'a, F> IntoGrad<'a, &[Array], Array, ()> for F

where F: FnMut(&[Array]) -> Array + 'a,

fn into_grad( self, argnums: impl IntoOption<&'a [i32]>, ) -> impl FnMut(&[Array]) -> Result<Array> + 'a

Convert the function/closure into a closure that computes the gradient.

impl<'a, F> IntoGrad<'a, &[Array], Array, Exception> for F

where F: FnMut(&[Array]) -> Result<Array> + 'a,

fn into_grad( self, argnums: impl IntoOption<&'a [i32]>, ) -> impl FnMut(&[Array]) -> Result<Array> + 'a

Convert the function/closure into a closure that computes the gradient.

impl<'a, F, M, Args> IntoModuleValueAndGrad<'a, M, Args, Array, ()> for F

where M: ModuleParameters + 'a, F: FnMut(&mut M, Args) -> Array + 'a, Args: Clone,

fn into_module_value_and_grad( self, ) -> impl FnMut(&mut M, Args) -> Result<(Array, FlattenedModuleParam), Exception> + 'a

Computes the valud and gradient of the passed function f(model, args) with regard to the model’s trainable parameters.

impl<'a, F, M, Args> IntoModuleValueAndGrad<'a, M, Args, Array, Exception> for F

where M: ModuleParameters + 'a, F: FnMut(&mut M, Args) -> Result<Array, Exception> + 'a, Args: Clone,

fn into_module_value_and_grad( self, ) -> impl FnMut(&mut M, Args) -> Result<(Array, FlattenedModuleParam), Exception> + 'a

Computes the valud and gradient of the passed function f(model, args) with regard to the model’s trainable parameters.

impl<'a> IntoOption<ScaledDotProductAttentionMask<'a>> for &'a Array

fn into_option(self) -> Option<ScaledDotProductAttentionMask<'a>>

Convert into an Option.

impl Module<&Array> for Glu

type Error = Exception

Error type for the module.

type Output = Array

Output type of the module.

fn forward(&mut self, x: &Array) -> Result<Array>

Forward pass of the module.

fn training_mode(&mut self, _: bool)

Set whether the module is in training mode.

impl Module<&Array> for Sigmoid

type Error = Exception

Error type for the module.

type Output = Array

Output type of the module.

fn forward(&mut self, x: &Array) -> Result<Array>

Forward pass of the module.

fn training_mode(&mut self, _: bool)

Set whether the module is in training mode.

impl Module<&Array> for Mish

type Error = Exception

Error type for the module.

type Output = Array

Output type of the module.

fn forward(&mut self, x: &Array) -> Result<Array>

Forward pass of the module.

fn training_mode(&mut self, _: bool)

Set whether the module is in training mode.

impl Module<&Array> for Relu

type Error = Exception

Error type for the module.

type Output = Array

Output type of the module.

fn forward(&mut self, x: &Array) -> Result<Array>

Forward pass of the module.

fn training_mode(&mut self, _: bool)

Set whether the module is in training mode.

impl Module<&Array> for LeakyRelu

type Error = Exception

Error type for the module.

type Output = Array

Output type of the module.

fn forward(&mut self, x: &Array) -> Result<Array>

Forward pass of the module.

fn training_mode(&mut self, _: bool)

Set whether the module is in training mode.

impl Module<&Array> for Relu6

type Error = Exception

Error type for the module.

type Output = Array

Output type of the module.

fn forward(&mut self, x: &Array) -> Result<Array>

Forward pass of the module.

fn training_mode(&mut self, _: bool)

Set whether the module is in training mode.

impl Module<&Array> for Softmax

type Error = Exception

Error type for the module.

type Output = Array

Output type of the module.

fn forward(&mut self, x: &Array) -> Result<Array>

Forward pass of the module.

fn training_mode(&mut self, _: bool)

Set whether the module is in training mode.

impl Module<&Array> for Softplus

type Error = Exception

Error type for the module.

type Output = Array

Output type of the module.

fn forward(&mut self, x: &Array) -> Result<Array>

Forward pass of the module.

fn training_mode(&mut self, _: bool)

Set whether the module is in training mode.

impl Module<&Array> for Softsign

type Error = Exception

Error type for the module.

type Output = Array

Output type of the module.

fn forward(&mut self, x: &Array) -> Result<Array>

Forward pass of the module.

fn training_mode(&mut self, _: bool)

Set whether the module is in training mode.

impl Module<&Array> for Celu

type Error = Exception

Error type for the module.

type Output = Array

Output type of the module.

fn forward(&mut self, x: &Array) -> Result<Array>

Forward pass of the module.

fn training_mode(&mut self, _: bool)

Set whether the module is in training mode.

impl Module<&Array> for Silu

type Error = Exception

Error type for the module.

type Output = Array

Output type of the module.

fn forward(&mut self, x: &Array) -> Result<Array>

Forward pass of the module.

fn training_mode(&mut self, _: bool)

Set whether the module is in training mode.

impl Module<&Array> for LogSoftmax

type Error = Exception

Error type for the module.

type Output = Array

Output type of the module.

fn forward(&mut self, x: &Array) -> Result<Array>

Forward pass of the module.

fn training_mode(&mut self, _: bool)

Set whether the module is in training mode.

impl Module<&Array> for LogSigmoid

type Error = Exception

Error type for the module.

type Output = Array

Output type of the module.

fn forward(&mut self, x: &Array) -> Result<Array>

Forward pass of the module.

fn training_mode(&mut self, _: bool)

Set whether the module is in training mode.

impl Module<&Array> for Prelu

type Error = Exception

Error type for the module.

type Output = Array

Output type of the module.

fn forward(&mut self, x: &Array) -> Result<Array>

Forward pass of the module.

fn training_mode(&mut self, _: bool)

Set whether the module is in training mode.

impl Module<&Array> for Gelu

type Error = Exception

Error type for the module.

type Output = Array

Output type of the module.

fn forward(&mut self, x: &Array) -> Result<Array>

Forward pass of the module.

fn training_mode(&mut self, _: bool)

Set whether the module is in training mode.

impl Module<&Array> for Tanh

type Error = Exception

Error type for the module.

type Output = Array

Output type of the module.

fn forward(&mut self, x: &Array) -> Result<Array>

Forward pass of the module.

fn training_mode(&mut self, _: bool)

Set whether the module is in training mode.

impl Module<&Array> for HardSwish

type Error = Exception

Error type for the module.

type Output = Array

Output type of the module.

fn forward(&mut self, x: &Array) -> Result<Array>

Forward pass of the module.

fn training_mode(&mut self, _: bool)

Set whether the module is in training mode.

impl Module<&Array> for Step

type Error = Exception

Error type for the module.

type Output = Array

Output type of the module.

fn forward(&mut self, x: &Array) -> Result<Array>

Forward pass of the module.

fn training_mode(&mut self, _: bool)

Set whether the module is in training mode.

impl Module<&Array> for Selu

type Error = Exception

Error type for the module.

type Output = Array

Output type of the module.

fn forward(&mut self, x: &Array) -> Result<Array>

Forward pass of the module.

fn training_mode(&mut self, _: bool)

Set whether the module is in training mode.

impl Module<&Array> for Sequential

type Error = Exception

Error type for the module.

type Output = Array

Output type of the module.

fn forward(&mut self, x: &Array) -> Result<Array, Self::Error>

Forward pass of the module.

fn training_mode(&mut self, mode: bool)

Set whether the module is in training mode.

impl Module<&Array> for Conv1d

type Error = Exception

Error type for the module.

type Output = Array

Output type of the module.

fn forward(&mut self, x: &Array) -> Result<Array, Self::Error>

Forward pass of the module.

fn training_mode(&mut self, _: bool)

Set whether the module is in training mode.

impl Module<&Array> for Conv2d

type Error = Exception

Error type for the module.

type Output = Array

Output type of the module.

fn forward(&mut self, x: &Array) -> Result<Array, Self::Error>

Forward pass of the module.

fn training_mode(&mut self, _: bool)

Set whether the module is in training mode.

impl Module<&Array> for Conv3d

type Error = Exception

Error type for the module.

type Output = Array

Output type of the module.

fn forward(&mut self, x: &Array) -> Result<Array, Self::Error>

Forward pass of the module.

fn training_mode(&mut self, _: bool)

Set whether the module is in training mode.

impl Module<&Array> for ConvTranspose1d

type Error = Exception

Error type for the module.

type Output = Array

Output type of the module.

fn forward(&mut self, x: &Array) -> Result<Array, Self::Error>

Forward pass of the module.

fn training_mode(&mut self, _: bool)

Set whether the module is in training mode.

impl Module<&Array> for ConvTranspose2d

type Error = Exception

Error type for the module.

type Output = Array

Output type of the module.

fn forward(&mut self, x: &Array) -> Result<Array, Self::Error>

Forward pass of the module.

fn training_mode(&mut self, _: bool)

Set whether the module is in training mode.

impl Module<&Array> for ConvTranspose3d

type Error = Exception

Error type for the module.

type Output = Array

Output type of the module.

fn forward(&mut self, x: &Array) -> Result<Array, Self::Error>

Forward pass of the module.

fn training_mode(&mut self, _: bool)

Set whether the module is in training mode.

impl Module<&Array> for Dropout

type Error = Exception

Error type for the module.

type Output = Array

Output type of the module.

fn forward(&mut self, x: &Array) -> Result<Array, Self::Error>

Forward pass of the module.

fn training_mode(&mut self, mode: bool)

Set whether the module is in training mode.

impl Module<&Array> for Dropout2d

type Error = Exception

Error type for the module.

type Output = Array

Output type of the module.

fn forward(&mut self, x: &Array) -> Result<Array, Self::Error>

Forward pass of the module.

fn training_mode(&mut self, mode: bool)

Set whether the module is in training mode.

impl Module<&Array> for Dropout3d

type Error = Exception

Error type for the module.

type Output = Array

Output type of the module.

fn forward(&mut self, x: &Array) -> Result<Array, Self::Error>

Forward pass of the module.

fn training_mode(&mut self, mode: bool)

Set whether the module is in training mode.

impl Module<&Array> for Embedding

type Error = Exception

Error type for the module.

type Output = Array

Output type of the module.

fn forward(&mut self, x: &Array) -> Result<Array, Self::Error>

Forward pass of the module.

fn training_mode(&mut self, _mode: bool)

Set whether the module is in training mode.

impl Module<&Array> for Linear

type Error = Exception

Error type for the module.

type Output = Array

Output type of the module.

fn forward(&mut self, x: &Array) -> Result<Array, Self::Error>

Forward pass of the module.

fn training_mode(&mut self, _: bool)

Set whether the module is in training mode.

impl Module<&Array> for Bilinear

type Error = Exception

Error type for the module.

type Output = Array

Output type of the module.

fn forward(&mut self, x: &Array) -> Result<Array, Self::Error>

Forward pass of the module.

fn training_mode(&mut self, _: bool)

Set whether the module is in training mode.

impl Module<&Array> for InstanceNorm

type Error = Exception

Error type for the module.

type Output = Array

Output type of the module.

fn forward(&mut self, x: &Array) -> Result<Array, Self::Error>

Forward pass of the module.

fn training_mode(&mut self, _mode: bool)

Set whether the module is in training mode.

impl Module<&Array> for LayerNorm

type Error = Exception

Error type for the module.

type Output = Array

Output type of the module.

fn forward(&mut self, x: &Array) -> Result<Array, Self::Error>

Forward pass of the module.

fn training_mode(&mut self, _mode: bool)

Set whether the module is in training mode.

impl Module<&Array> for RmsNorm

type Error = Exception

Error type for the module.

type Output = Array

Output type of the module.

fn forward(&mut self, x: &Array) -> Result<Array, Self::Error>

Forward pass of the module.

fn training_mode(&mut self, _mode: bool)

Set whether the module is in training mode.

impl Module<&Array> for GroupNorm

type Error = Exception

Error type for the module.

type Output = Array

Output type of the module.

fn forward(&mut self, x: &Array) -> Result<Array, Self::Error>

Forward pass of the module.

fn training_mode(&mut self, _mode: bool)

Set whether the module is in training mode.

impl Module<&Array> for BatchNorm

type Error = Exception

Error type for the module.

type Output = Array

Output type of the module.

fn forward(&mut self, x: &Array) -> Result<Array, Self::Error>

Forward pass of the module.

fn training_mode(&mut self, mode: bool)

Set whether the module is in training mode.

impl Module<&Array> for Pool

type Error = Exception

Error type for the module.

type Output = Array

Output type of the module.

fn forward(&mut self, x: &Array) -> Result<Array, Self::Error>

Forward pass of the module.

fn training_mode(&mut self, _mode: bool)

Set whether the module is in training mode.

impl Module<&Array> for MaxPool1d

type Output = Array

Output type of the module.

type Error = Exception

Error type for the module.

fn forward(&mut self, x: &Array) -> Result<Array, Self::Error>

Forward pass of the module.

fn training_mode(&mut self, mode: bool)

Set whether the module is in training mode.

impl Module<&Array> for MaxPool2d

type Output = Array

Output type of the module.

type Error = Exception

Error type for the module.

fn forward(&mut self, x: &Array) -> Result<Array, Self::Error>

Forward pass of the module.

fn training_mode(&mut self, mode: bool)

Set whether the module is in training mode.

impl Module<&Array> for AvgPool1d

type Output = Array

Output type of the module.

type Error = Exception

Error type for the module.

fn forward(&mut self, x: &Array) -> Result<Array, Self::Error>

Forward pass of the module.

fn training_mode(&mut self, mode: bool)

Set whether the module is in training mode.

impl Module<&Array> for AvgPool2d

type Output = Array

Output type of the module.

type Error = Exception

Error type for the module.

fn forward(&mut self, x: &Array) -> Result<Array, Self::Error>

Forward pass of the module.

fn training_mode(&mut self, mode: bool)

Set whether the module is in training mode.

impl Module<&Array> for Sinpe

type Error = Exception

Error type for the module.

type Output = Array

Output type of the module.

fn forward(&mut self, x: &Array) -> Result<Self::Output, Self::Error>

Forward pass of the module.

fn training_mode(&mut self, _mode: bool)

Set whether the module is in training mode.

impl Module<&Array> for QuantizedEmbedding

type Error = Exception

Error type for the module.

type Output = Array

Output type of the module.

fn forward(&mut self, x: &Array) -> Result<Array, Self::Error>

Forward pass of the module.

fn training_mode(&mut self, mode: bool)

Set whether the module is in training mode.

impl Module<&Array> for QuantizedLinear

type Error = Exception

Error type for the module.

type Output = Array

Output type of the module.

fn forward(&mut self, x: &Array) -> Result<Array, Self::Error>

Forward pass of the module.

fn training_mode(&mut self, mode: bool)

Set whether the module is in training mode.

impl Module<&Array> for Upsample

type Error = Exception

Error type for the module.

type Output = Array

Output type of the module.

fn forward(&mut self, x: &Array) -> Result<Self::Output, Self::Error>

Forward pass of the module.

fn training_mode(&mut self, _mode: bool)

Set whether the module is in training mode.

impl<'a, T> Mul<T> for Array

where T: ScalarOrArray<'a>,

type Output = Array

The resulting type after applying the * operator.

fn mul(self, rhs: T) -> Self::Output

Performs the * operation.

impl<'a, 't: 'a, T> Mul<T> for &'a Array

where T: ScalarOrArray<'t>,

type Output = Array

The resulting type after applying the * operator.

fn mul(self, rhs: T) -> Self::Output

Performs the * operation.

impl MulAssign<&Array> for Array

fn mul_assign(&mut self, rhs: &Self)

Performs the *= operation.

impl<T: Into<Array>> MulAssign<T> for Array

fn mul_assign(&mut self, rhs: T)

Performs the *= operation.

impl Neg for &Array

type Output = Array

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Neg for Array

type Output = Array

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Not for &Array

type Output = Array

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl Not for Array

type Output = Array

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<'a, T> Pow<T> for Array

where T: ScalarOrArray<'a>,

type Output = Array

The result after applying the operator.

fn pow(self, rhs: T) -> Self::Output

Returns self to the power rhs.

impl<'a, 't: 'a, T> Pow<T> for &'a Array

where T: ScalarOrArray<'t>,

type Output = Array

The result after applying the operator.

fn pow(self, rhs: T) -> Self::Output

Returns self to the power rhs.

impl Product for Array

fn product<I: Iterator<Item = Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by multiplying the items.

impl<'a> Product<&'a Array> for Array

fn product<I: Iterator<Item = &'a Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by multiplying the items.

impl<'a, T> Rem<T> for Array

where T: ScalarOrArray<'a>,

type Output = Array

The resulting type after applying the % operator.

fn rem(self, rhs: T) -> Self::Output

Performs the % operation.

impl<'a, 't: 'a, T> Rem<T> for &'a Array

where T: ScalarOrArray<'t>,

type Output = Array

The resulting type after applying the % operator.

fn rem(self, rhs: T) -> Self::Output

Performs the % operation.

impl RemAssign<&Array> for Array

fn rem_assign(&mut self, rhs: &Self)

Performs the %= operation.

impl<T: Into<Array>> RemAssign<T> for Array

fn rem_assign(&mut self, rhs: T)

Performs the %= operation.

impl ScalarOrArray<'_> for Array

type Array = Array

The reference type of the array.

fn into_owned_or_ref_array(self) -> Array

Convert to an owned or reference array.

impl<'a> ScalarOrArray<'a> for &'a Array

type Array = &'a Array

The reference type of the array.

fn into_owned_or_ref_array(self) -> &'a Array

Convert to an owned or reference array.

impl Send for Array

impl<'a, T> Sub<T> for Array

where T: ScalarOrArray<'a>,

type Output = Array

The resulting type after applying the - operator.

fn sub(self, rhs: T) -> Self::Output

Performs the - operation.

impl<'a, 't: 'a, T> Sub<T> for &'a Array

where T: ScalarOrArray<'t>,

type Output = Array

The resulting type after applying the - operator.

fn sub(self, rhs: T) -> Self::Output

Performs the - operation.

impl SubAssign<&Array> for Array

fn sub_assign(&mut self, rhs: &Self)

Performs the -= operation.

impl<T: Into<Array>> SubAssign<T> for Array

fn sub_assign(&mut self, rhs: T)

Performs the -= operation.

impl Sum for Array

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.

impl<'a, Val> TryIndexMutOp<&'a [ArrayIndexOp<'a>], Val> for Array

where Val: AsRef<Array>,

fn try_index_mut_device( &mut self, i: &'a [ArrayIndexOp<'a>], val: Val, stream: impl AsRef<Stream>, ) -> Result<()>

Try to index the array with the given index and set the value.

fn try_index_mut(&mut self, i: Idx, val: Val) -> Result<()>

Try to index the array with the given index and set the value.

impl<'a, 'b, A, B, Val> TryIndexMutOp<(A, B), Val> for Array

where A: ArrayIndex<'a>, B: ArrayIndex<'b>, Val: AsRef<Array>,

fn try_index_mut_device( &mut self, i: (A, B), val: Val, stream: impl AsRef<Stream>, ) -> Result<()>

Try to index the array with the given index and set the value.

fn try_index_mut(&mut self, i: Idx, val: Val) -> Result<()>

Try to index the array with the given index and set the value.

impl<'a, 'b, 'c, A, B, C, Val> TryIndexMutOp<(A, B, C), Val> for Array

where A: ArrayIndex<'a>, B: ArrayIndex<'b>, C: ArrayIndex<'c>, Val: AsRef<Array>,

fn try_index_mut_device( &mut self, i: (A, B, C), val: Val, stream: impl AsRef<Stream>, ) -> Result<()>

Try to index the array with the given index and set the value.

fn try_index_mut(&mut self, i: Idx, val: Val) -> Result<()>

Try to index the array with the given index and set the value.

impl<'a, 'b, 'c, 'd, A, B, C, D, Val> TryIndexMutOp<(A, B, C, D), Val> for Array

where A: ArrayIndex<'a>, B: ArrayIndex<'b>, C: ArrayIndex<'c>, D: ArrayIndex<'d>, Val: AsRef<Array>,

fn try_index_mut_device( &mut self, i: (A, B, C, D), val: Val, stream: impl AsRef<Stream>, ) -> Result<()>

Try to index the array with the given index and set the value.

fn try_index_mut(&mut self, i: Idx, val: Val) -> Result<()>

Try to index the array with the given index and set the value.

impl<'a, 'b, 'c, 'd, 'e, A, B, C, D, E, Val> TryIndexMutOp<(A, B, C, D, E), Val> for Array

where A: ArrayIndex<'a>, B: ArrayIndex<'b>, C: ArrayIndex<'c>, D: ArrayIndex<'d>, E: ArrayIndex<'e>, Val: AsRef<Array>,

fn try_index_mut_device( &mut self, i: (A, B, C, D, E), val: Val, stream: impl AsRef<Stream>, ) -> Result<()>

Try to index the array with the given index and set the value.

fn try_index_mut(&mut self, i: Idx, val: Val) -> Result<()>

Try to index the array with the given index and set the value.

impl<'a, 'b, 'c, 'd, 'e, 'f, A, B, C, D, E, F, Val> TryIndexMutOp<(A, B, C, D, E, F), Val> for Array

where A: ArrayIndex<'a>, B: ArrayIndex<'b>, C: ArrayIndex<'c>, D: ArrayIndex<'d>, E: ArrayIndex<'e>, F: ArrayIndex<'f>, Val: AsRef<Array>,

fn try_index_mut_device( &mut self, i: (A, B, C, D, E, F), val: Val, stream: impl AsRef<Stream>, ) -> Result<()>

Try to index the array with the given index and set the value.

fn try_index_mut(&mut self, i: Idx, val: Val) -> Result<()>

Try to index the array with the given index and set the value.

impl<'a, 'b, 'c, 'd, 'e, 'f, 'g, A, B, C, D, E, F, G, Val> TryIndexMutOp<(A, B, C, D, E, F, G), Val> for Array

where A: ArrayIndex<'a>, B: ArrayIndex<'b>, C: ArrayIndex<'c>, D: ArrayIndex<'d>, E: ArrayIndex<'e>, F: ArrayIndex<'f>, G: ArrayIndex<'g>, Val: AsRef<Array>,

fn try_index_mut_device( &mut self, i: (A, B, C, D, E, F, G), val: Val, stream: impl AsRef<Stream>, ) -> Result<()>

Try to index the array with the given index and set the value.

fn try_index_mut(&mut self, i: Idx, val: Val) -> Result<()>

Try to index the array with the given index and set the value.

impl<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, A, B, C, D, E, F, G, H, Val> TryIndexMutOp<(A, B, C, D, E, F, G, H), Val> for Array

where A: ArrayIndex<'a>, B: ArrayIndex<'b>, C: ArrayIndex<'c>, D: ArrayIndex<'d>, E: ArrayIndex<'e>, F: ArrayIndex<'f>, G: ArrayIndex<'g>, H: ArrayIndex<'h>, Val: AsRef<Array>,

fn try_index_mut_device( &mut self, i: (A, B, C, D, E, F, G, H), val: Val, stream: impl AsRef<Stream>, ) -> Result<()>

Try to index the array with the given index and set the value.

fn try_index_mut(&mut self, i: Idx, val: Val) -> Result<()>

Try to index the array with the given index and set the value.

impl<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i, A, B, C, D, E, F, G, H, I, Val> TryIndexMutOp<(A, B, C, D, E, F, G, H, I), Val> for Array

where A: ArrayIndex<'a>, B: ArrayIndex<'b>, C: ArrayIndex<'c>, D: ArrayIndex<'d>, E: ArrayIndex<'e>, F: ArrayIndex<'f>, G: ArrayIndex<'g>, H: ArrayIndex<'h>, I: ArrayIndex<'i>, Val: AsRef<Array>,

fn try_index_mut_device( &mut self, i: (A, B, C, D, E, F, G, H, I), val: Val, stream: impl AsRef<Stream>, ) -> Result<()>

Try to index the array with the given index and set the value.

fn try_index_mut(&mut self, i: Idx, val: Val) -> Result<()>

Try to index the array with the given index and set the value.

impl<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i, 'j, A, B, C, D, E, F, G, H, I, J, Val> TryIndexMutOp<(A, B, C, D, E, F, G, H, I, J), Val> for Array

where A: ArrayIndex<'a>, B: ArrayIndex<'b>, C: ArrayIndex<'c>, D: ArrayIndex<'d>, E: ArrayIndex<'e>, F: ArrayIndex<'f>, G: ArrayIndex<'g>, H: ArrayIndex<'h>, I: ArrayIndex<'i>, J: ArrayIndex<'j>, Val: AsRef<Array>,

fn try_index_mut_device( &mut self, i: (A, B, C, D, E, F, G, H, I, J), val: Val, stream: impl AsRef<Stream>, ) -> Result<()>

Try to index the array with the given index and set the value.

fn try_index_mut(&mut self, i: Idx, val: Val) -> Result<()>

Try to index the array with the given index and set the value.

impl<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i, 'j, 'k, A, B, C, D, E, F, G, H, I, J, K, Val> TryIndexMutOp<(A, B, C, D, E, F, G, H, I, J, K), Val> for Array

where A: ArrayIndex<'a>, B: ArrayIndex<'b>, C: ArrayIndex<'c>, D: ArrayIndex<'d>, E: ArrayIndex<'e>, F: ArrayIndex<'f>, G: ArrayIndex<'g>, H: ArrayIndex<'h>, I: ArrayIndex<'i>, J: ArrayIndex<'j>, K: ArrayIndex<'k>, Val: AsRef<Array>,

fn try_index_mut_device( &mut self, i: (A, B, C, D, E, F, G, H, I, J, K), val: Val, stream: impl AsRef<Stream>, ) -> Result<()>

Try to index the array with the given index and set the value.

fn try_index_mut(&mut self, i: Idx, val: Val) -> Result<()>

Try to index the array with the given index and set the value.

impl<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i, 'j, 'k, 'l, A, B, C, D, E, F, G, H, I, J, K, L, Val> TryIndexMutOp<(A, B, C, D, E, F, G, H, I, J, K, L), Val> for Array

where A: ArrayIndex<'a>, B: ArrayIndex<'b>, C: ArrayIndex<'c>, D: ArrayIndex<'d>, E: ArrayIndex<'e>, F: ArrayIndex<'f>, G: ArrayIndex<'g>, H: ArrayIndex<'h>, I: ArrayIndex<'i>, J: ArrayIndex<'j>, K: ArrayIndex<'k>, L: ArrayIndex<'l>, Val: AsRef<Array>,

fn try_index_mut_device( &mut self, i: (A, B, C, D, E, F, G, H, I, J, K, L), val: Val, stream: impl AsRef<Stream>, ) -> Result<()>

Try to index the array with the given index and set the value.

fn try_index_mut(&mut self, i: Idx, val: Val) -> Result<()>

Try to index the array with the given index and set the value.

impl<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i, 'j, 'k, 'l, 'm, A, B, C, D, E, F, G, H, I, J, K, L, M, Val> TryIndexMutOp<(A, B, C, D, E, F, G, H, I, J, K, L, M), Val> for Array

where A: ArrayIndex<'a>, B: ArrayIndex<'b>, C: ArrayIndex<'c>, D: ArrayIndex<'d>, E: ArrayIndex<'e>, F: ArrayIndex<'f>, G: ArrayIndex<'g>, H: ArrayIndex<'h>, I: ArrayIndex<'i>, J: ArrayIndex<'j>, K: ArrayIndex<'k>, L: ArrayIndex<'l>, M: ArrayIndex<'m>, Val: AsRef<Array>,

fn try_index_mut_device( &mut self, i: (A, B, C, D, E, F, G, H, I, J, K, L, M), val: Val, stream: impl AsRef<Stream>, ) -> Result<()>

Try to index the array with the given index and set the value.

fn try_index_mut(&mut self, i: Idx, val: Val) -> Result<()>

Try to index the array with the given index and set the value.

impl<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i, 'j, 'k, 'l, 'm, 'n, A, B, C, D, E, F, G, H, I, J, K, L, M, N, Val> TryIndexMutOp<(A, B, C, D, E, F, G, H, I, J, K, L, M, N), Val> for Array

where A: ArrayIndex<'a>, B: ArrayIndex<'b>, C: ArrayIndex<'c>, D: ArrayIndex<'d>, E: ArrayIndex<'e>, F: ArrayIndex<'f>, G: ArrayIndex<'g>, H: ArrayIndex<'h>, I: ArrayIndex<'i>, J: ArrayIndex<'j>, K: ArrayIndex<'k>, L: ArrayIndex<'l>, M: ArrayIndex<'m>, N: ArrayIndex<'n>, Val: AsRef<Array>,

fn try_index_mut_device( &mut self, i: (A, B, C, D, E, F, G, H, I, J, K, L, M, N), val: Val, stream: impl AsRef<Stream>, ) -> Result<()>

Try to index the array with the given index and set the value.

fn try_index_mut(&mut self, i: Idx, val: Val) -> Result<()>

Try to index the array with the given index and set the value.

impl<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i, 'j, 'k, 'l, 'm, 'n, 'o, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, Val> TryIndexMutOp<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O), Val> for Array

where A: ArrayIndex<'a>, B: ArrayIndex<'b>, C: ArrayIndex<'c>, D: ArrayIndex<'d>, E: ArrayIndex<'e>, F: ArrayIndex<'f>, G: ArrayIndex<'g>, H: ArrayIndex<'h>, I: ArrayIndex<'i>, J: ArrayIndex<'j>, K: ArrayIndex<'k>, L: ArrayIndex<'l>, M: ArrayIndex<'m>, N: ArrayIndex<'n>, O: ArrayIndex<'o>, Val: AsRef<Array>,

fn try_index_mut_device( &mut self, i: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O), val: Val, stream: impl AsRef<Stream>, ) -> Result<()>

Try to index the array with the given index and set the value.

fn try_index_mut(&mut self, i: Idx, val: Val) -> Result<()>

Try to index the array with the given index and set the value.

impl<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i, 'j, 'k, 'l, 'm, 'n, 'o, 'p, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Val> TryIndexMutOp<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), Val> for Array

where A: ArrayIndex<'a>, B: ArrayIndex<'b>, C: ArrayIndex<'c>, D: ArrayIndex<'d>, E: ArrayIndex<'e>, F: ArrayIndex<'f>, G: ArrayIndex<'g>, H: ArrayIndex<'h>, I: ArrayIndex<'i>, J: ArrayIndex<'j>, K: ArrayIndex<'k>, L: ArrayIndex<'l>, M: ArrayIndex<'m>, N: ArrayIndex<'n>, O: ArrayIndex<'o>, P: ArrayIndex<'p>, Val: AsRef<Array>,

fn try_index_mut_device( &mut self, i: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), val: Val, stream: impl AsRef<Stream>, ) -> Result<()>

Try to index the array with the given index and set the value.

fn try_index_mut(&mut self, i: Idx, val: Val) -> Result<()>

Try to index the array with the given index and set the value.

impl<'a, A, Val> TryIndexMutOp<(A,), Val> for Array

where A: ArrayIndex<'a>, Val: AsRef<Array>,

fn try_index_mut_device( &mut self, (i): (A,), val: Val, stream: impl AsRef<Stream>, ) -> Result<()>

Try to index the array with the given index and set the value.

fn try_index_mut(&mut self, i: Idx, val: Val) -> Result<()>

Try to index the array with the given index and set the value.

impl<A, Val> TryIndexMutOp<A, Val> for Array

where for<'a> A: ArrayIndex<'a>, Val: AsRef<Array>,

fn try_index_mut_device( &mut self, i: A, val: Val, stream: impl AsRef<Stream>, ) -> Result<()>

Try to index the array with the given index and set the value.

fn try_index_mut(&mut self, i: Idx, val: Val) -> Result<()>

Try to index the array with the given index and set the value.

impl<'a> TryIndexOp<&'a [ArrayIndexOp<'a>]> for Array

fn try_index_device( &self, i: &'a [ArrayIndexOp<'a>], stream: impl AsRef<Stream>, ) -> Result<Array>

Try to index the array with the given index.

fn try_index(&self, i: Idx) -> Result<Array>

Try to index the array with the given index.

impl<'a, 'b, A, B> TryIndexOp<(A, B)> for Array

where A: ArrayIndex<'a>, B: ArrayIndex<'b>,

fn try_index_device( &self, i: (A, B), stream: impl AsRef<Stream>, ) -> Result<Array>

Try to index the array with the given index.

fn try_index(&self, i: Idx) -> Result<Array>

Try to index the array with the given index.

impl<'a, 'b, 'c, A, B, C> TryIndexOp<(A, B, C)> for Array

where A: ArrayIndex<'a>, B: ArrayIndex<'b>, C: ArrayIndex<'c>,

fn try_index_device( &self, i: (A, B, C), stream: impl AsRef<Stream>, ) -> Result<Array>

Try to index the array with the given index.

fn try_index(&self, i: Idx) -> Result<Array>

Try to index the array with the given index.

impl<'a, 'b, 'c, 'd, A, B, C, D> TryIndexOp<(A, B, C, D)> for Array

where A: ArrayIndex<'a>, B: ArrayIndex<'b>, C: ArrayIndex<'c>, D: ArrayIndex<'d>,

fn try_index_device( &self, i: (A, B, C, D), stream: impl AsRef<Stream>, ) -> Result<Array>

Try to index the array with the given index.

fn try_index(&self, i: Idx) -> Result<Array>

Try to index the array with the given index.

impl<'a, 'b, 'c, 'd, 'e, A, B, C, D, E> TryIndexOp<(A, B, C, D, E)> for Array

where A: ArrayIndex<'a>, B: ArrayIndex<'b>, C: ArrayIndex<'c>, D: ArrayIndex<'d>, E: ArrayIndex<'e>,

fn try_index_device( &self, i: (A, B, C, D, E), stream: impl AsRef<Stream>, ) -> Result<Array>

Try to index the array with the given index.

fn try_index(&self, i: Idx) -> Result<Array>

Try to index the array with the given index.

impl<'a, 'b, 'c, 'd, 'e, 'f, A, B, C, D, E, F> TryIndexOp<(A, B, C, D, E, F)> for Array

where A: ArrayIndex<'a>, B: ArrayIndex<'b>, C: ArrayIndex<'c>, D: ArrayIndex<'d>, E: ArrayIndex<'e>, F: ArrayIndex<'f>,

fn try_index_device( &self, i: (A, B, C, D, E, F), stream: impl AsRef<Stream>, ) -> Result<Array>

Try to index the array with the given index.

fn try_index(&self, i: Idx) -> Result<Array>

Try to index the array with the given index.

impl<'a, 'b, 'c, 'd, 'e, 'f, 'g, A, B, C, D, E, F, G> TryIndexOp<(A, B, C, D, E, F, G)> for Array

where A: ArrayIndex<'a>, B: ArrayIndex<'b>, C: ArrayIndex<'c>, D: ArrayIndex<'d>, E: ArrayIndex<'e>, F: ArrayIndex<'f>, G: ArrayIndex<'g>,

fn try_index_device( &self, i: (A, B, C, D, E, F, G), stream: impl AsRef<Stream>, ) -> Result<Array>

Try to index the array with the given index.

fn try_index(&self, i: Idx) -> Result<Array>

Try to index the array with the given index.

impl<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, A, B, C, D, E, F, G, H> TryIndexOp<(A, B, C, D, E, F, G, H)> for Array

where A: ArrayIndex<'a>, B: ArrayIndex<'b>, C: ArrayIndex<'c>, D: ArrayIndex<'d>, E: ArrayIndex<'e>, F: ArrayIndex<'f>, G: ArrayIndex<'g>, H: ArrayIndex<'h>,

fn try_index_device( &self, i: (A, B, C, D, E, F, G, H), stream: impl AsRef<Stream>, ) -> Result<Array>

Try to index the array with the given index.

fn try_index(&self, i: Idx) -> Result<Array>

Try to index the array with the given index.

impl<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i, A, B, C, D, E, F, G, H, I> TryIndexOp<(A, B, C, D, E, F, G, H, I)> for Array

where A: ArrayIndex<'a>, B: ArrayIndex<'b>, C: ArrayIndex<'c>, D: ArrayIndex<'d>, E: ArrayIndex<'e>, F: ArrayIndex<'f>, G: ArrayIndex<'g>, H: ArrayIndex<'h>, I: ArrayIndex<'i>,

fn try_index_device( &self, i: (A, B, C, D, E, F, G, H, I), stream: impl AsRef<Stream>, ) -> Result<Array>

Try to index the array with the given index.

fn try_index(&self, i: Idx) -> Result<Array>

Try to index the array with the given index.

impl<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i, 'j, A, B, C, D, E, F, G, H, I, J> TryIndexOp<(A, B, C, D, E, F, G, H, I, J)> for Array

where A: ArrayIndex<'a>, B: ArrayIndex<'b>, C: ArrayIndex<'c>, D: ArrayIndex<'d>, E: ArrayIndex<'e>, F: ArrayIndex<'f>, G: ArrayIndex<'g>, H: ArrayIndex<'h>, I: ArrayIndex<'i>, J: ArrayIndex<'j>,

fn try_index_device( &self, i: (A, B, C, D, E, F, G, H, I, J), stream: impl AsRef<Stream>, ) -> Result<Array>

Try to index the array with the given index.

fn try_index(&self, i: Idx) -> Result<Array>

Try to index the array with the given index.

impl<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i, 'j, 'k, A, B, C, D, E, F, G, H, I, J, K> TryIndexOp<(A, B, C, D, E, F, G, H, I, J, K)> for Array

where A: ArrayIndex<'a>, B: ArrayIndex<'b>, C: ArrayIndex<'c>, D: ArrayIndex<'d>, E: ArrayIndex<'e>, F: ArrayIndex<'f>, G: ArrayIndex<'g>, H: ArrayIndex<'h>, I: ArrayIndex<'i>, J: ArrayIndex<'j>, K: ArrayIndex<'k>,

fn try_index_device( &self, i: (A, B, C, D, E, F, G, H, I, J, K), stream: impl AsRef<Stream>, ) -> Result<Array>

Try to index the array with the given index.

fn try_index(&self, i: Idx) -> Result<Array>

Try to index the array with the given index.

impl<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i, 'j, 'k, 'l, A, B, C, D, E, F, G, H, I, J, K, L> TryIndexOp<(A, B, C, D, E, F, G, H, I, J, K, L)> for Array

where A: ArrayIndex<'a>, B: ArrayIndex<'b>, C: ArrayIndex<'c>, D: ArrayIndex<'d>, E: ArrayIndex<'e>, F: ArrayIndex<'f>, G: ArrayIndex<'g>, H: ArrayIndex<'h>, I: ArrayIndex<'i>, J: ArrayIndex<'j>, K: ArrayIndex<'k>, L: ArrayIndex<'l>,

fn try_index_device( &self, i: (A, B, C, D, E, F, G, H, I, J, K, L), stream: impl AsRef<Stream>, ) -> Result<Array>

Try to index the array with the given index.

fn try_index(&self, i: Idx) -> Result<Array>

Try to index the array with the given index.

impl<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i, 'j, 'k, 'l, 'm, A, B, C, D, E, F, G, H, I, J, K, L, M> TryIndexOp<(A, B, C, D, E, F, G, H, I, J, K, L, M)> for Array

where A: ArrayIndex<'a>, B: ArrayIndex<'b>, C: ArrayIndex<'c>, D: ArrayIndex<'d>, E: ArrayIndex<'e>, F: ArrayIndex<'f>, G: ArrayIndex<'g>, H: ArrayIndex<'h>, I: ArrayIndex<'i>, J: ArrayIndex<'j>, K: ArrayIndex<'k>, L: ArrayIndex<'l>, M: ArrayIndex<'m>,

fn try_index_device( &self, i: (A, B, C, D, E, F, G, H, I, J, K, L, M), stream: impl AsRef<Stream>, ) -> Result<Array>

Try to index the array with the given index.

fn try_index(&self, i: Idx) -> Result<Array>

Try to index the array with the given index.

impl<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i, 'j, 'k, 'l, 'm, 'n, A, B, C, D, E, F, G, H, I, J, K, L, M, N> TryIndexOp<(A, B, C, D, E, F, G, H, I, J, K, L, M, N)> for Array

where A: ArrayIndex<'a>, B: ArrayIndex<'b>, C: ArrayIndex<'c>, D: ArrayIndex<'d>, E: ArrayIndex<'e>, F: ArrayIndex<'f>, G: ArrayIndex<'g>, H: ArrayIndex<'h>, I: ArrayIndex<'i>, J: ArrayIndex<'j>, K: ArrayIndex<'k>, L: ArrayIndex<'l>, M: ArrayIndex<'m>, N: ArrayIndex<'n>,

fn try_index_device( &self, i: (A, B, C, D, E, F, G, H, I, J, K, L, M, N), stream: impl AsRef<Stream>, ) -> Result<Array>

Try to index the array with the given index.

fn try_index(&self, i: Idx) -> Result<Array>

Try to index the array with the given index.

impl<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i, 'j, 'k, 'l, 'm, 'n, 'o, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> TryIndexOp<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)> for Array

where A: ArrayIndex<'a>, B: ArrayIndex<'b>, C: ArrayIndex<'c>, D: ArrayIndex<'d>, E: ArrayIndex<'e>, F: ArrayIndex<'f>, G: ArrayIndex<'g>, H: ArrayIndex<'h>, I: ArrayIndex<'i>, J: ArrayIndex<'j>, K: ArrayIndex<'k>, L: ArrayIndex<'l>, M: ArrayIndex<'m>, N: ArrayIndex<'n>, O: ArrayIndex<'o>,

fn try_index_device( &self, i: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O), stream: impl AsRef<Stream>, ) -> Result<Array>

Try to index the array with the given index.

fn try_index(&self, i: Idx) -> Result<Array>

Try to index the array with the given index.

impl<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i, 'j, 'k, 'l, 'm, 'n, 'o, 'p, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> TryIndexOp<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)> for Array

where A: ArrayIndex<'a>, B: ArrayIndex<'b>, C: ArrayIndex<'c>, D: ArrayIndex<'d>, E: ArrayIndex<'e>, F: ArrayIndex<'f>, G: ArrayIndex<'g>, H: ArrayIndex<'h>, I: ArrayIndex<'i>, J: ArrayIndex<'j>, K: ArrayIndex<'k>, L: ArrayIndex<'l>, M: ArrayIndex<'m>, N: ArrayIndex<'n>, O: ArrayIndex<'o>, P: ArrayIndex<'p>,

fn try_index_device( &self, i: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), stream: impl AsRef<Stream>, ) -> Result<Array>

Try to index the array with the given index.

fn try_index(&self, i: Idx) -> Result<Array>

Try to index the array with the given index.

impl<'a, A> TryIndexOp<(A,)> for Array

where A: ArrayIndex<'a>,

fn try_index_device(&self, i: (A,), stream: impl AsRef<Stream>) -> Result<Array>

Try to index the array with the given index.

fn try_index(&self, i: Idx) -> Result<Array>

Try to index the array with the given index.

impl<'a, T> TryIndexOp<T> for Array

where T: ArrayIndex<'a>,

fn try_index_device(&self, i: T, stream: impl AsRef<Stream>) -> Result<Array>

Try to index the array with the given index.

fn try_index(&self, i: Idx) -> Result<Array>

Try to index the array with the given index.

impl<'a, Value> TryIndexUpdateOp<&'a [ArrayIndexOp<'a>], Value> for Array

where Value: AsRef<Array>,

fn try_index_update( &self, index: &'a [ArrayIndexOp<'a>], update: Value, mode: UpdateMode, ) -> Result<Array, IndexUpdateError>

Return a new array with update applied at index according to mode.

impl<'a, 'b, A, B, Value> TryIndexUpdateOp<(A, B), Value> for Array

where A: ArrayIndex<'a>, B: ArrayIndex<'b>, Value: AsRef<Array>,

fn try_index_update( &self, index: (A, B), update: Value, mode: UpdateMode, ) -> Result<Array, IndexUpdateError>

Return a new array with update applied at index according to mode.

impl<'a, 'b, 'c, A, B, C, Value> TryIndexUpdateOp<(A, B, C), Value> for Array

where A: ArrayIndex<'a>, B: ArrayIndex<'b>, C: ArrayIndex<'c>, Value: AsRef<Array>,

fn try_index_update( &self, index: (A, B, C), update: Value, mode: UpdateMode, ) -> Result<Array, IndexUpdateError>

Return a new array with update applied at index according to mode.

impl<'a, 'b, 'c, 'd, A, B, C, D, Value> TryIndexUpdateOp<(A, B, C, D), Value> for Array

where A: ArrayIndex<'a>, B: ArrayIndex<'b>, C: ArrayIndex<'c>, D: ArrayIndex<'d>, Value: AsRef<Array>,

fn try_index_update( &self, index: (A, B, C, D), update: Value, mode: UpdateMode, ) -> Result<Array, IndexUpdateError>

Return a new array with update applied at index according to mode.

impl<'a, 'b, 'c, 'd, 'e, A, B, C, D, E, Value> TryIndexUpdateOp<(A, B, C, D, E), Value> for Array

where A: ArrayIndex<'a>, B: ArrayIndex<'b>, C: ArrayIndex<'c>, D: ArrayIndex<'d>, E: ArrayIndex<'e>, Value: AsRef<Array>,

fn try_index_update( &self, index: (A, B, C, D, E), update: Value, mode: UpdateMode, ) -> Result<Array, IndexUpdateError>

Return a new array with update applied at index according to mode.

impl<'a, 'b, 'c, 'd, 'e, 'f, A, B, C, D, E, F, Value> TryIndexUpdateOp<(A, B, C, D, E, F), Value> for Array

where A: ArrayIndex<'a>, B: ArrayIndex<'b>, C: ArrayIndex<'c>, D: ArrayIndex<'d>, E: ArrayIndex<'e>, F: ArrayIndex<'f>, Value: AsRef<Array>,

fn try_index_update( &self, index: (A, B, C, D, E, F), update: Value, mode: UpdateMode, ) -> Result<Array, IndexUpdateError>

Return a new array with update applied at index according to mode.

impl<'a, 'b, 'c, 'd, 'e, 'f, 'g, A, B, C, D, E, F, G, Value> TryIndexUpdateOp<(A, B, C, D, E, F, G), Value> for Array

where A: ArrayIndex<'a>, B: ArrayIndex<'b>, C: ArrayIndex<'c>, D: ArrayIndex<'d>, E: ArrayIndex<'e>, F: ArrayIndex<'f>, G: ArrayIndex<'g>, Value: AsRef<Array>,

fn try_index_update( &self, index: (A, B, C, D, E, F, G), update: Value, mode: UpdateMode, ) -> Result<Array, IndexUpdateError>

Return a new array with update applied at index according to mode.

impl<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, A, B, C, D, E, F, G, H, Value> TryIndexUpdateOp<(A, B, C, D, E, F, G, H), Value> for Array

where A: ArrayIndex<'a>, B: ArrayIndex<'b>, C: ArrayIndex<'c>, D: ArrayIndex<'d>, E: ArrayIndex<'e>, F: ArrayIndex<'f>, G: ArrayIndex<'g>, H: ArrayIndex<'h>, Value: AsRef<Array>,

fn try_index_update( &self, index: (A, B, C, D, E, F, G, H), update: Value, mode: UpdateMode, ) -> Result<Array, IndexUpdateError>

Return a new array with update applied at index according to mode.

impl<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i, A, B, C, D, E, F, G, H, I, Value> TryIndexUpdateOp<(A, B, C, D, E, F, G, H, I), Value> for Array

where A: ArrayIndex<'a>, B: ArrayIndex<'b>, C: ArrayIndex<'c>, D: ArrayIndex<'d>, E: ArrayIndex<'e>, F: ArrayIndex<'f>, G: ArrayIndex<'g>, H: ArrayIndex<'h>, I: ArrayIndex<'i>, Value: AsRef<Array>,

fn try_index_update( &self, index: (A, B, C, D, E, F, G, H, I), update: Value, mode: UpdateMode, ) -> Result<Array, IndexUpdateError>

Return a new array with update applied at index according to mode.

impl<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i, 'j, A, B, C, D, E, F, G, H, I, J, Value> TryIndexUpdateOp<(A, B, C, D, E, F, G, H, I, J), Value> for Array

where A: ArrayIndex<'a>, B: ArrayIndex<'b>, C: ArrayIndex<'c>, D: ArrayIndex<'d>, E: ArrayIndex<'e>, F: ArrayIndex<'f>, G: ArrayIndex<'g>, H: ArrayIndex<'h>, I: ArrayIndex<'i>, J: ArrayIndex<'j>, Value: AsRef<Array>,

fn try_index_update( &self, index: (A, B, C, D, E, F, G, H, I, J), update: Value, mode: UpdateMode, ) -> Result<Array, IndexUpdateError>

Return a new array with update applied at index according to mode.

impl<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i, 'j, 'k, A, B, C, D, E, F, G, H, I, J, K, Value> TryIndexUpdateOp<(A, B, C, D, E, F, G, H, I, J, K), Value> for Array

where A: ArrayIndex<'a>, B: ArrayIndex<'b>, C: ArrayIndex<'c>, D: ArrayIndex<'d>, E: ArrayIndex<'e>, F: ArrayIndex<'f>, G: ArrayIndex<'g>, H: ArrayIndex<'h>, I: ArrayIndex<'i>, J: ArrayIndex<'j>, K: ArrayIndex<'k>, Value: AsRef<Array>,

fn try_index_update( &self, index: (A, B, C, D, E, F, G, H, I, J, K), update: Value, mode: UpdateMode, ) -> Result<Array, IndexUpdateError>

Return a new array with update applied at index according to mode.

impl<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i, 'j, 'k, 'l, A, B, C, D, E, F, G, H, I, J, K, L, Value> TryIndexUpdateOp<(A, B, C, D, E, F, G, H, I, J, K, L), Value> for Array

where A: ArrayIndex<'a>, B: ArrayIndex<'b>, C: ArrayIndex<'c>, D: ArrayIndex<'d>, E: ArrayIndex<'e>, F: ArrayIndex<'f>, G: ArrayIndex<'g>, H: ArrayIndex<'h>, I: ArrayIndex<'i>, J: ArrayIndex<'j>, K: ArrayIndex<'k>, L: ArrayIndex<'l>, Value: AsRef<Array>,

fn try_index_update( &self, index: (A, B, C, D, E, F, G, H, I, J, K, L), update: Value, mode: UpdateMode, ) -> Result<Array, IndexUpdateError>

Return a new array with update applied at index according to mode.

impl<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i, 'j, 'k, 'l, 'm, A, B, C, D, E, F, G, H, I, J, K, L, M, Value> TryIndexUpdateOp<(A, B, C, D, E, F, G, H, I, J, K, L, M), Value> for Array

where A: ArrayIndex<'a>, B: ArrayIndex<'b>, C: ArrayIndex<'c>, D: ArrayIndex<'d>, E: ArrayIndex<'e>, F: ArrayIndex<'f>, G: ArrayIndex<'g>, H: ArrayIndex<'h>, I: ArrayIndex<'i>, J: ArrayIndex<'j>, K: ArrayIndex<'k>, L: ArrayIndex<'l>, M: ArrayIndex<'m>, Value: AsRef<Array>,

fn try_index_update( &self, index: (A, B, C, D, E, F, G, H, I, J, K, L, M), update: Value, mode: UpdateMode, ) -> Result<Array, IndexUpdateError>

Return a new array with update applied at index according to mode.

impl<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i, 'j, 'k, 'l, 'm, 'n, A, B, C, D, E, F, G, H, I, J, K, L, M, N, Value> TryIndexUpdateOp<(A, B, C, D, E, F, G, H, I, J, K, L, M, N), Value> for Array

where A: ArrayIndex<'a>, B: ArrayIndex<'b>, C: ArrayIndex<'c>, D: ArrayIndex<'d>, E: ArrayIndex<'e>, F: ArrayIndex<'f>, G: ArrayIndex<'g>, H: ArrayIndex<'h>, I: ArrayIndex<'i>, J: ArrayIndex<'j>, K: ArrayIndex<'k>, L: ArrayIndex<'l>, M: ArrayIndex<'m>, N: ArrayIndex<'n>, Value: AsRef<Array>,

fn try_index_update( &self, index: (A, B, C, D, E, F, G, H, I, J, K, L, M, N), update: Value, mode: UpdateMode, ) -> Result<Array, IndexUpdateError>

Return a new array with update applied at index according to mode.

impl<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i, 'j, 'k, 'l, 'm, 'n, 'o, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, Value> TryIndexUpdateOp<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O), Value> for Array

where A: ArrayIndex<'a>, B: ArrayIndex<'b>, C: ArrayIndex<'c>, D: ArrayIndex<'d>, E: ArrayIndex<'e>, F: ArrayIndex<'f>, G: ArrayIndex<'g>, H: ArrayIndex<'h>, I: ArrayIndex<'i>, J: ArrayIndex<'j>, K: ArrayIndex<'k>, L: ArrayIndex<'l>, M: ArrayIndex<'m>, N: ArrayIndex<'n>, O: ArrayIndex<'o>, Value: AsRef<Array>,

fn try_index_update( &self, index: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O), update: Value, mode: UpdateMode, ) -> Result<Array, IndexUpdateError>

Return a new array with update applied at index according to mode.

impl<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i, 'j, 'k, 'l, 'm, 'n, 'o, 'p, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Value> TryIndexUpdateOp<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), Value> for Array

where A: ArrayIndex<'a>, B: ArrayIndex<'b>, C: ArrayIndex<'c>, D: ArrayIndex<'d>, E: ArrayIndex<'e>, F: ArrayIndex<'f>, G: ArrayIndex<'g>, H: ArrayIndex<'h>, I: ArrayIndex<'i>, J: ArrayIndex<'j>, K: ArrayIndex<'k>, L: ArrayIndex<'l>, M: ArrayIndex<'m>, N: ArrayIndex<'n>, O: ArrayIndex<'o>, P: ArrayIndex<'p>, Value: AsRef<Array>,

fn try_index_update( &self, index: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), update: Value, mode: UpdateMode, ) -> Result<Array, IndexUpdateError>

Return a new array with update applied at index according to mode.

impl<'a, A, Value> TryIndexUpdateOp<(A,), Value> for Array

where A: ArrayIndex<'a>, Value: AsRef<Array>,

fn try_index_update( &self, index: (A,), update: Value, mode: UpdateMode, ) -> Result<Array, IndexUpdateError>

Return a new array with update applied at index according to mode.

impl<'a, Index, Value> TryIndexUpdateOp<Index, Value> for Array

where Index: ArrayIndex<'a>, Value: AsRef<Array>,

fn try_index_update( &self, index: Index, update: Value, mode: UpdateMode, ) -> Result<Array, IndexUpdateError>

Return a new array with update applied at index according to mode.