Struct arrayfire::Array

pub struct Array<T: HasAfEnum> { /* fields omitted */ }

A multidimensional data container

Currently, Array objects can store only data until four dimensions

NOTE

All operators(traits) from std::ops module implemented for Array object carry out element wise operations. For example, * does multiplication of elements at corresponding locations in two different Arrays.

Methods

impl<T> Array<T> where
    T: HasAfEnum, 

pub fn new(slice: &[T], dims: Dim4) -> Self

Constructs a new Array object

Examples

use arrayfire::{Array, Dim4, print};
let values: [f32; 3] = [1.0, 2.0, 3.0];
let indices = Array::new(&values, Dim4::new(&[3, 1, 1, 1]));
print(&indices);

pub fn new_strided(slice: &[T], offset: i64, dims: Dim4, strides: Dim4) -> Self

Constructs a new Array object from strided data

The data pointed by the slice passed to this function can possibily be offseted using an additional offset parameter.

pub fn new_empty(dims: Dim4) -> Self

Constructs a new Array object of specified dimensions and type

Examples

use arrayfire::{Array, Dim4};
let garbageVals = Array::<f32>::new_empty(Dim4::new(&[3, 1, 1, 1]));

pub fn get_backend(&self) -> Backend

Returns the backend of the Array

Return Values

Returns an value of type Backend which indicates which backend was active when Array was created.

pub fn get_device_id(&self) -> i32

Returns the device identifier(integer) on which the Array was created

Return Values

Return the device id on which Array was created.

pub fn elements(&self) -> usize

Returns the number of elements in the Array

pub fn get_type(&self) -> DType

Returns the Array data type

pub fn dims(&self) -> Dim4

Returns the dimensions of the Array

pub fn strides(&self) -> Dim4

Returns the strides of the Array

pub fn numdims(&self) -> u32

Returns the number of dimensions of the Array

pub fn offset(&self) -> i64

Returns the offset to the pointer from where data begins

pub fn get(&self) -> i64

Returns the native FFI handle for Rust object Array

pub fn host<O: HasAfEnum>(&self, data: &mut [O])

Copies the data from the Array to the mutable slice data

pub fn eval(&self)

Evaluates any pending lazy expressions that represent the data in the Array object

pub fn copy(&self) -> Self

Makes an copy of the Array

This does a deep copy of the data into a new Array

pub fn is_empty(&self) -> bool

Check if Array is empty

pub fn is_scalar(&self) -> bool

Check if Array is scalar

pub fn is_row(&self) -> bool

Check if Array is a row

pub fn is_column(&self) -> bool

Check if Array is a column

pub fn is_vector(&self) -> bool

Check if Array is a vector

pub fn is_complex(&self) -> bool

Check if Array is of complex type

pub fn is_double(&self) -> bool

Check if Array's numerical type is of double precision

pub fn is_single(&self) -> bool

Check if Array's numerical type is of single precision

pub fn is_real(&self) -> bool

Check if Array is of real type

pub fn is_floating(&self) -> bool

Check if Array is of single precision

pub fn is_integer(&self) -> bool

Check if Array is of integral type

pub fn is_bool(&self) -> bool

Check if Array is of boolean type

pub fn is_linear(&self) -> bool

Check if Array's memory layout is continuous and one dimensional

pub fn is_owner(&self) -> bool

Check if Array's memory is owned by it and not a view of another Array

pub fn cast<O: HasAfEnum>(&self) -> Array<O>

Cast the Array data type to target_type

pub fn is_sparse(&self) -> bool

Find if the current array is sparse

pub fn lock(&self)

Lock the device buffer in the memory manager

Locked buffers are not freed by memory manager until unlock is called.

pub fn unlock(&self)

Unlock the device buffer in the memory manager

This function will give back the control over the device pointer to the memory manager.

pub fn device_ptr(&self) -> u64

Get the device pointer and lock the buffer in memory manager

The device pointer is not freed by memory manager until unlock is called.

pub fn get_allocated_bytes(&self) -> usize

Get the size of physical allocated bytes.

This function will return the size of the parent/owner if the current Array object is an indexed Array.

Trait Implementations

impl<T: HasAfEnum> Convertable for Array<T>

type OutType = T

This type alias always points to Self which is the type of Array returned by the trait method convert.

fn convert(&self) -> Array<Self::OutType>

Get an Array of implementors type

impl<T: HasAfEnum> Indexable for Array<T>

Enables Array to be used to index another Array

This is used in functions index_gen and assign_gen

fn set(&self, idxr: &mut Indexer, dim: u32, is_batch: Option<bool>)

Set indexing object for a given dimension

impl<T: HasAfEnum> Into<Array<T>> for i64

Used for creating Array object from native resource id, an 64 bit integer

fn into(self) -> Array<T>

Performs the conversion.

impl<T> Drop for Array<T> where
    T: HasAfEnum, 

To free resources when Array goes out of scope

fn drop(&mut self)

Executes the destructor for this type.

impl<T> Clone for Array<T> where
    T: HasAfEnum, 

Returns a new Array object after incrementing the reference count of native resource

Cloning an Array does not do a deep copy of the underlying array data. It increments the reference count of native resource and returns you the new reference in the form a new Array object.

To create a deep copy use copy()

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'f, T> Sub<Complex<f64>> for &'f Array<T> where
    T: HasAfEnum + ImplicitPromote<Complex<f64>>,
    Complex<f64>: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<Complex<f64>>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<Complex<f64>>>::Output>

The resulting type after applying the - operator.

fn sub(self, rhs: Complex<f64>) -> Self::Output

Performs the - operation.

impl<T: HasAfEnum> Sub<Complex<f64>> for Array<T> where
    T: HasAfEnum + ImplicitPromote<Complex<f64>>,
    Complex<f64>: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<Complex<f64>>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<Complex<f64>>>::Output>

The resulting type after applying the - operator.

fn sub(self, rhs: Complex<f64>) -> Self::Output

Performs the - operation.

impl<'f, T> Sub<Complex<f32>> for &'f Array<T> where
    T: HasAfEnum + ImplicitPromote<Complex<f32>>,
    Complex<f32>: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<Complex<f32>>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<Complex<f32>>>::Output>

The resulting type after applying the - operator.

fn sub(self, rhs: Complex<f32>) -> Self::Output

Performs the - operation.

impl<T: HasAfEnum> Sub<Complex<f32>> for Array<T> where
    T: HasAfEnum + ImplicitPromote<Complex<f32>>,
    Complex<f32>: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<Complex<f32>>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<Complex<f32>>>::Output>

The resulting type after applying the - operator.

fn sub(self, rhs: Complex<f32>) -> Self::Output

Performs the - operation.

impl<'f, T> Sub<f64> for &'f Array<T> where
    T: HasAfEnum + ImplicitPromote<f64>,
    f64: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<f64>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<f64>>::Output>

The resulting type after applying the - operator.

fn sub(self, rhs: f64) -> Self::Output

Performs the - operation.

impl<T: HasAfEnum> Sub<f64> for Array<T> where
    T: HasAfEnum + ImplicitPromote<f64>,
    f64: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<f64>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<f64>>::Output>

The resulting type after applying the - operator.

fn sub(self, rhs: f64) -> Self::Output

Performs the - operation.

impl<'f, T> Sub<f32> for &'f Array<T> where
    T: HasAfEnum + ImplicitPromote<f32>,
    f32: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<f32>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<f32>>::Output>

The resulting type after applying the - operator.

fn sub(self, rhs: f32) -> Self::Output

Performs the - operation.

impl<T: HasAfEnum> Sub<f32> for Array<T> where
    T: HasAfEnum + ImplicitPromote<f32>,
    f32: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<f32>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<f32>>::Output>

The resulting type after applying the - operator.

fn sub(self, rhs: f32) -> Self::Output

Performs the - operation.

impl<'f, T> Sub<u64> for &'f Array<T> where
    T: HasAfEnum + ImplicitPromote<u64>,
    u64: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<u64>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<u64>>::Output>

The resulting type after applying the - operator.

fn sub(self, rhs: u64) -> Self::Output

Performs the - operation.

impl<T: HasAfEnum> Sub<u64> for Array<T> where
    T: HasAfEnum + ImplicitPromote<u64>,
    u64: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<u64>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<u64>>::Output>

The resulting type after applying the - operator.

fn sub(self, rhs: u64) -> Self::Output

Performs the - operation.

impl<'f, T> Sub<i64> for &'f Array<T> where
    T: HasAfEnum + ImplicitPromote<i64>,
    i64: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<i64>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<i64>>::Output>

The resulting type after applying the - operator.

fn sub(self, rhs: i64) -> Self::Output

Performs the - operation.

impl<T: HasAfEnum> Sub<i64> for Array<T> where
    T: HasAfEnum + ImplicitPromote<i64>,
    i64: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<i64>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<i64>>::Output>

The resulting type after applying the - operator.

fn sub(self, rhs: i64) -> Self::Output

Performs the - operation.

impl<'f, T> Sub<u32> for &'f Array<T> where
    T: HasAfEnum + ImplicitPromote<u32>,
    u32: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<u32>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<u32>>::Output>

The resulting type after applying the - operator.

fn sub(self, rhs: u32) -> Self::Output

Performs the - operation.

impl<T: HasAfEnum> Sub<u32> for Array<T> where
    T: HasAfEnum + ImplicitPromote<u32>,
    u32: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<u32>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<u32>>::Output>

The resulting type after applying the - operator.

fn sub(self, rhs: u32) -> Self::Output

Performs the - operation.

impl<'f, T> Sub<i32> for &'f Array<T> where
    T: HasAfEnum + ImplicitPromote<i32>,
    i32: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<i32>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<i32>>::Output>

The resulting type after applying the - operator.

fn sub(self, rhs: i32) -> Self::Output

Performs the - operation.

impl<T: HasAfEnum> Sub<i32> for Array<T> where
    T: HasAfEnum + ImplicitPromote<i32>,
    i32: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<i32>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<i32>>::Output>

The resulting type after applying the - operator.

fn sub(self, rhs: i32) -> Self::Output

Performs the - operation.

impl<'f, T> Sub<u8> for &'f Array<T> where
    T: HasAfEnum + ImplicitPromote<u8>,
    u8: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<u8>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<u8>>::Output>

The resulting type after applying the - operator.

fn sub(self, rhs: u8) -> Self::Output

Performs the - operation.

impl<T: HasAfEnum> Sub<u8> for Array<T> where
    T: HasAfEnum + ImplicitPromote<u8>,
    u8: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<u8>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<u8>>::Output>

The resulting type after applying the - operator.

fn sub(self, rhs: u8) -> Self::Output

Performs the - operation.

impl<A, B> Sub<Array<B>> for Array<A> where
    A: HasAfEnum + ImplicitPromote<B>,
    B: HasAfEnum + ImplicitPromote<A>,
    <A as ImplicitPromote<B>>::Output: HasAfEnum, 

type Output = Array<<A as ImplicitPromote<B>>::Output>

The resulting type after applying the - operator.

fn sub(self, rhs: Array<B>) -> Self::Output

Performs the - operation.

impl<'a, A, B> Sub<&'a Array<B>> for Array<A> where
    A: HasAfEnum + ImplicitPromote<B>,
    B: HasAfEnum + ImplicitPromote<A>,
    <A as ImplicitPromote<B>>::Output: HasAfEnum, 

type Output = Array<<A as ImplicitPromote<B>>::Output>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Array<B>) -> Self::Output

Performs the - operation.

impl<'a, A, B> Sub<Array<B>> for &'a Array<A> where
    A: HasAfEnum + ImplicitPromote<B>,
    B: HasAfEnum + ImplicitPromote<A>,
    <A as ImplicitPromote<B>>::Output: HasAfEnum, 

type Output = Array<<A as ImplicitPromote<B>>::Output>

The resulting type after applying the - operator.

fn sub(self, rhs: Array<B>) -> Self::Output

Performs the - operation.

impl<'a, 'b, A, B> Sub<&'a Array<B>> for &'b Array<A> where
    A: HasAfEnum + ImplicitPromote<B>,
    B: HasAfEnum + ImplicitPromote<A>,
    <A as ImplicitPromote<B>>::Output: HasAfEnum, 

type Output = Array<<A as ImplicitPromote<B>>::Output>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Array<B>) -> Self::Output

Performs the - operation.

impl<'f, T> Add<Complex<f64>> for &'f Array<T> where
    T: HasAfEnum + ImplicitPromote<Complex<f64>>,
    Complex<f64>: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<Complex<f64>>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<Complex<f64>>>::Output>

The resulting type after applying the + operator.

fn add(self, rhs: Complex<f64>) -> Self::Output

Performs the + operation.

impl<T: HasAfEnum> Add<Complex<f64>> for Array<T> where
    T: HasAfEnum + ImplicitPromote<Complex<f64>>,
    Complex<f64>: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<Complex<f64>>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<Complex<f64>>>::Output>

The resulting type after applying the + operator.

fn add(self, rhs: Complex<f64>) -> Self::Output

Performs the + operation.

impl<'f, T> Add<Complex<f32>> for &'f Array<T> where
    T: HasAfEnum + ImplicitPromote<Complex<f32>>,
    Complex<f32>: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<Complex<f32>>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<Complex<f32>>>::Output>

The resulting type after applying the + operator.

fn add(self, rhs: Complex<f32>) -> Self::Output

Performs the + operation.

impl<T: HasAfEnum> Add<Complex<f32>> for Array<T> where
    T: HasAfEnum + ImplicitPromote<Complex<f32>>,
    Complex<f32>: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<Complex<f32>>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<Complex<f32>>>::Output>

The resulting type after applying the + operator.

fn add(self, rhs: Complex<f32>) -> Self::Output

Performs the + operation.

impl<'f, T> Add<f64> for &'f Array<T> where
    T: HasAfEnum + ImplicitPromote<f64>,
    f64: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<f64>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<f64>>::Output>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: HasAfEnum> Add<f64> for Array<T> where
    T: HasAfEnum + ImplicitPromote<f64>,
    f64: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<f64>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<f64>>::Output>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'f, T> Add<f32> for &'f Array<T> where
    T: HasAfEnum + ImplicitPromote<f32>,
    f32: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<f32>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<f32>>::Output>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: HasAfEnum> Add<f32> for Array<T> where
    T: HasAfEnum + ImplicitPromote<f32>,
    f32: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<f32>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<f32>>::Output>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'f, T> Add<u64> for &'f Array<T> where
    T: HasAfEnum + ImplicitPromote<u64>,
    u64: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<u64>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<u64>>::Output>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: HasAfEnum> Add<u64> for Array<T> where
    T: HasAfEnum + ImplicitPromote<u64>,
    u64: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<u64>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<u64>>::Output>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'f, T> Add<i64> for &'f Array<T> where
    T: HasAfEnum + ImplicitPromote<i64>,
    i64: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<i64>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<i64>>::Output>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: HasAfEnum> Add<i64> for Array<T> where
    T: HasAfEnum + ImplicitPromote<i64>,
    i64: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<i64>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<i64>>::Output>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'f, T> Add<u32> for &'f Array<T> where
    T: HasAfEnum + ImplicitPromote<u32>,
    u32: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<u32>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<u32>>::Output>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: HasAfEnum> Add<u32> for Array<T> where
    T: HasAfEnum + ImplicitPromote<u32>,
    u32: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<u32>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<u32>>::Output>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'f, T> Add<i32> for &'f Array<T> where
    T: HasAfEnum + ImplicitPromote<i32>,
    i32: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<i32>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<i32>>::Output>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: HasAfEnum> Add<i32> for Array<T> where
    T: HasAfEnum + ImplicitPromote<i32>,
    i32: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<i32>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<i32>>::Output>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'f, T> Add<u8> for &'f Array<T> where
    T: HasAfEnum + ImplicitPromote<u8>,
    u8: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<u8>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<u8>>::Output>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: HasAfEnum> Add<u8> for Array<T> where
    T: HasAfEnum + ImplicitPromote<u8>,
    u8: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<u8>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<u8>>::Output>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<A, B> Add<Array<B>> for Array<A> where
    A: HasAfEnum + ImplicitPromote<B>,
    B: HasAfEnum + ImplicitPromote<A>,
    <A as ImplicitPromote<B>>::Output: HasAfEnum, 

type Output = Array<<A as ImplicitPromote<B>>::Output>

The resulting type after applying the + operator.

fn add(self, rhs: Array<B>) -> Self::Output

Performs the + operation.

impl<'a, A, B> Add<&'a Array<B>> for Array<A> where
    A: HasAfEnum + ImplicitPromote<B>,
    B: HasAfEnum + ImplicitPromote<A>,
    <A as ImplicitPromote<B>>::Output: HasAfEnum, 

type Output = Array<<A as ImplicitPromote<B>>::Output>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Array<B>) -> Self::Output

Performs the + operation.

impl<'a, A, B> Add<Array<B>> for &'a Array<A> where
    A: HasAfEnum + ImplicitPromote<B>,
    B: HasAfEnum + ImplicitPromote<A>,
    <A as ImplicitPromote<B>>::Output: HasAfEnum, 

type Output = Array<<A as ImplicitPromote<B>>::Output>

The resulting type after applying the + operator.

fn add(self, rhs: Array<B>) -> Self::Output

Performs the + operation.

impl<'a, 'b, A, B> Add<&'a Array<B>> for &'b Array<A> where
    A: HasAfEnum + ImplicitPromote<B>,
    B: HasAfEnum + ImplicitPromote<A>,
    <A as ImplicitPromote<B>>::Output: HasAfEnum, 

type Output = Array<<A as ImplicitPromote<B>>::Output>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Array<B>) -> Self::Output

Performs the + operation.

impl<'f, T> Mul<Complex<f64>> for &'f Array<T> where
    T: HasAfEnum + ImplicitPromote<Complex<f64>>,
    Complex<f64>: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<Complex<f64>>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<Complex<f64>>>::Output>

The resulting type after applying the * operator.

fn mul(self, rhs: Complex<f64>) -> Self::Output

Performs the * operation.

impl<T: HasAfEnum> Mul<Complex<f64>> for Array<T> where
    T: HasAfEnum + ImplicitPromote<Complex<f64>>,
    Complex<f64>: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<Complex<f64>>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<Complex<f64>>>::Output>

The resulting type after applying the * operator.

fn mul(self, rhs: Complex<f64>) -> Self::Output

Performs the * operation.

impl<'f, T> Mul<Complex<f32>> for &'f Array<T> where
    T: HasAfEnum + ImplicitPromote<Complex<f32>>,
    Complex<f32>: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<Complex<f32>>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<Complex<f32>>>::Output>

The resulting type after applying the * operator.

fn mul(self, rhs: Complex<f32>) -> Self::Output

Performs the * operation.

impl<T: HasAfEnum> Mul<Complex<f32>> for Array<T> where
    T: HasAfEnum + ImplicitPromote<Complex<f32>>,
    Complex<f32>: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<Complex<f32>>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<Complex<f32>>>::Output>

The resulting type after applying the * operator.

fn mul(self, rhs: Complex<f32>) -> Self::Output

Performs the * operation.

impl<'f, T> Mul<f64> for &'f Array<T> where
    T: HasAfEnum + ImplicitPromote<f64>,
    f64: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<f64>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<f64>>::Output>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: HasAfEnum> Mul<f64> for Array<T> where
    T: HasAfEnum + ImplicitPromote<f64>,
    f64: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<f64>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<f64>>::Output>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'f, T> Mul<f32> for &'f Array<T> where
    T: HasAfEnum + ImplicitPromote<f32>,
    f32: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<f32>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<f32>>::Output>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: HasAfEnum> Mul<f32> for Array<T> where
    T: HasAfEnum + ImplicitPromote<f32>,
    f32: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<f32>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<f32>>::Output>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'f, T> Mul<u64> for &'f Array<T> where
    T: HasAfEnum + ImplicitPromote<u64>,
    u64: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<u64>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<u64>>::Output>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: HasAfEnum> Mul<u64> for Array<T> where
    T: HasAfEnum + ImplicitPromote<u64>,
    u64: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<u64>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<u64>>::Output>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'f, T> Mul<i64> for &'f Array<T> where
    T: HasAfEnum + ImplicitPromote<i64>,
    i64: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<i64>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<i64>>::Output>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: HasAfEnum> Mul<i64> for Array<T> where
    T: HasAfEnum + ImplicitPromote<i64>,
    i64: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<i64>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<i64>>::Output>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'f, T> Mul<u32> for &'f Array<T> where
    T: HasAfEnum + ImplicitPromote<u32>,
    u32: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<u32>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<u32>>::Output>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: HasAfEnum> Mul<u32> for Array<T> where
    T: HasAfEnum + ImplicitPromote<u32>,
    u32: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<u32>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<u32>>::Output>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'f, T> Mul<i32> for &'f Array<T> where
    T: HasAfEnum + ImplicitPromote<i32>,
    i32: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<i32>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<i32>>::Output>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: HasAfEnum> Mul<i32> for Array<T> where
    T: HasAfEnum + ImplicitPromote<i32>,
    i32: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<i32>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<i32>>::Output>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'f, T> Mul<u8> for &'f Array<T> where
    T: HasAfEnum + ImplicitPromote<u8>,
    u8: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<u8>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<u8>>::Output>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: HasAfEnum> Mul<u8> for Array<T> where
    T: HasAfEnum + ImplicitPromote<u8>,
    u8: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<u8>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<u8>>::Output>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<A, B> Mul<Array<B>> for Array<A> where
    A: HasAfEnum + ImplicitPromote<B>,
    B: HasAfEnum + ImplicitPromote<A>,
    <A as ImplicitPromote<B>>::Output: HasAfEnum, 

type Output = Array<<A as ImplicitPromote<B>>::Output>

The resulting type after applying the * operator.

fn mul(self, rhs: Array<B>) -> Self::Output

Performs the * operation.

impl<'a, A, B> Mul<&'a Array<B>> for Array<A> where
    A: HasAfEnum + ImplicitPromote<B>,
    B: HasAfEnum + ImplicitPromote<A>,
    <A as ImplicitPromote<B>>::Output: HasAfEnum, 

type Output = Array<<A as ImplicitPromote<B>>::Output>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Array<B>) -> Self::Output

Performs the * operation.

impl<'a, A, B> Mul<Array<B>> for &'a Array<A> where
    A: HasAfEnum + ImplicitPromote<B>,
    B: HasAfEnum + ImplicitPromote<A>,
    <A as ImplicitPromote<B>>::Output: HasAfEnum, 

type Output = Array<<A as ImplicitPromote<B>>::Output>

The resulting type after applying the * operator.

fn mul(self, rhs: Array<B>) -> Self::Output

Performs the * operation.

impl<'a, 'b, A, B> Mul<&'a Array<B>> for &'b Array<A> where
    A: HasAfEnum + ImplicitPromote<B>,
    B: HasAfEnum + ImplicitPromote<A>,
    <A as ImplicitPromote<B>>::Output: HasAfEnum, 

type Output = Array<<A as ImplicitPromote<B>>::Output>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Array<B>) -> Self::Output

Performs the * operation.

impl<'f, T> Div<Complex<f64>> for &'f Array<T> where
    T: HasAfEnum + ImplicitPromote<Complex<f64>>,
    Complex<f64>: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<Complex<f64>>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<Complex<f64>>>::Output>

The resulting type after applying the / operator.

fn div(self, rhs: Complex<f64>) -> Self::Output

Performs the / operation.

impl<T: HasAfEnum> Div<Complex<f64>> for Array<T> where
    T: HasAfEnum + ImplicitPromote<Complex<f64>>,
    Complex<f64>: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<Complex<f64>>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<Complex<f64>>>::Output>

The resulting type after applying the / operator.

fn div(self, rhs: Complex<f64>) -> Self::Output

Performs the / operation.

impl<'f, T> Div<Complex<f32>> for &'f Array<T> where
    T: HasAfEnum + ImplicitPromote<Complex<f32>>,
    Complex<f32>: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<Complex<f32>>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<Complex<f32>>>::Output>

The resulting type after applying the / operator.

fn div(self, rhs: Complex<f32>) -> Self::Output

Performs the / operation.

impl<T: HasAfEnum> Div<Complex<f32>> for Array<T> where
    T: HasAfEnum + ImplicitPromote<Complex<f32>>,
    Complex<f32>: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<Complex<f32>>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<Complex<f32>>>::Output>

The resulting type after applying the / operator.

fn div(self, rhs: Complex<f32>) -> Self::Output

Performs the / operation.

impl<'f, T> Div<f64> for &'f Array<T> where
    T: HasAfEnum + ImplicitPromote<f64>,
    f64: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<f64>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<f64>>::Output>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: HasAfEnum> Div<f64> for Array<T> where
    T: HasAfEnum + ImplicitPromote<f64>,
    f64: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<f64>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<f64>>::Output>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'f, T> Div<f32> for &'f Array<T> where
    T: HasAfEnum + ImplicitPromote<f32>,
    f32: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<f32>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<f32>>::Output>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: HasAfEnum> Div<f32> for Array<T> where
    T: HasAfEnum + ImplicitPromote<f32>,
    f32: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<f32>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<f32>>::Output>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'f, T> Div<u64> for &'f Array<T> where
    T: HasAfEnum + ImplicitPromote<u64>,
    u64: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<u64>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<u64>>::Output>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: HasAfEnum> Div<u64> for Array<T> where
    T: HasAfEnum + ImplicitPromote<u64>,
    u64: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<u64>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<u64>>::Output>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'f, T> Div<i64> for &'f Array<T> where
    T: HasAfEnum + ImplicitPromote<i64>,
    i64: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<i64>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<i64>>::Output>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: HasAfEnum> Div<i64> for Array<T> where
    T: HasAfEnum + ImplicitPromote<i64>,
    i64: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<i64>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<i64>>::Output>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'f, T> Div<u32> for &'f Array<T> where
    T: HasAfEnum + ImplicitPromote<u32>,
    u32: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<u32>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<u32>>::Output>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: HasAfEnum> Div<u32> for Array<T> where
    T: HasAfEnum + ImplicitPromote<u32>,
    u32: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<u32>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<u32>>::Output>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'f, T> Div<i32> for &'f Array<T> where
    T: HasAfEnum + ImplicitPromote<i32>,
    i32: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<i32>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<i32>>::Output>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: HasAfEnum> Div<i32> for Array<T> where
    T: HasAfEnum + ImplicitPromote<i32>,
    i32: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<i32>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<i32>>::Output>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'f, T> Div<u8> for &'f Array<T> where
    T: HasAfEnum + ImplicitPromote<u8>,
    u8: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<u8>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<u8>>::Output>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: HasAfEnum> Div<u8> for Array<T> where
    T: HasAfEnum + ImplicitPromote<u8>,
    u8: HasAfEnum + ImplicitPromote<T>,
    <T as ImplicitPromote<u8>>::Output: HasAfEnum, 

type Output = Array<<T as ImplicitPromote<u8>>::Output>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<A, B> Div<Array<B>> for Array<A> where
    A: HasAfEnum + ImplicitPromote<B>,
    B: HasAfEnum + ImplicitPromote<A>,
    <A as ImplicitPromote<B>>::Output: HasAfEnum, 

type Output = Array<<A as ImplicitPromote<B>>::Output>

The resulting type after applying the / operator.

fn div(self, rhs: Array<B>) -> Self::Output

Performs the / operation.

impl<'a, A, B> Div<&'a Array<B>> for Array<A> where
    A: HasAfEnum + ImplicitPromote<B>,
    B: HasAfEnum + ImplicitPromote<A>,
    <A as ImplicitPromote<B>>::Output: HasAfEnum, 

type Output = Array<<A as ImplicitPromote<B>>::Output>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Array<B>) -> Self::Output

Performs the / operation.

impl<'a, A, B> Div<Array<B>> for &'a Array<A> where
    A: HasAfEnum + ImplicitPromote<B>,
    B: HasAfEnum + ImplicitPromote<A>,
    <A as ImplicitPromote<B>>::Output: HasAfEnum, 

type Output = Array<<A as ImplicitPromote<B>>::Output>

The resulting type after applying the / operator.

fn div(self, rhs: Array<B>) -> Self::Output

Performs the / operation.

impl<'a, 'b, A, B> Div<&'a Array<B>> for &'b Array<A> where
    A: HasAfEnum + ImplicitPromote<B>,
    B: HasAfEnum + ImplicitPromote<A>,
    <A as ImplicitPromote<B>>::Output: HasAfEnum, 

type Output = Array<<A as ImplicitPromote<B>>::Output>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Array<B>) -> Self::Output

Performs the / operation.

impl<A, B> Rem<Array<B>> for Array<A> where
    A: HasAfEnum + ImplicitPromote<B>,
    B: HasAfEnum + ImplicitPromote<A>,
    <A as ImplicitPromote<B>>::Output: HasAfEnum, 

type Output = Array<<A as ImplicitPromote<B>>::Output>

The resulting type after applying the % operator.

fn rem(self, rhs: Array<B>) -> Self::Output

Performs the % operation.

impl<'a, A, B> Rem<&'a Array<B>> for Array<A> where
    A: HasAfEnum + ImplicitPromote<B>,
    B: HasAfEnum + ImplicitPromote<A>,
    <A as ImplicitPromote<B>>::Output: HasAfEnum, 

type Output = Array<<A as ImplicitPromote<B>>::Output>

The resulting type after applying the % operator.

fn rem(self, rhs: &'a Array<B>) -> Self::Output

Performs the % operation.

impl<'a, A, B> Rem<Array<B>> for &'a Array<A> where
    A: HasAfEnum + ImplicitPromote<B>,
    B: HasAfEnum + ImplicitPromote<A>,
    <A as ImplicitPromote<B>>::Output: HasAfEnum, 

type Output = Array<<A as ImplicitPromote<B>>::Output>

The resulting type after applying the % operator.

fn rem(self, rhs: Array<B>) -> Self::Output

Performs the % operation.

impl<'a, 'b, A, B> Rem<&'a Array<B>> for &'b Array<A> where
    A: HasAfEnum + ImplicitPromote<B>,
    B: HasAfEnum + ImplicitPromote<A>,
    <A as ImplicitPromote<B>>::Output: HasAfEnum, 

type Output = Array<<A as ImplicitPromote<B>>::Output>

The resulting type after applying the % operator.

fn rem(self, rhs: &'a Array<B>) -> Self::Output

Performs the % operation.

impl<T> Neg for Array<T> where
    T: HasAfEnum + Zero + ConstGenerator,
    <T as ConstGenerator>::OutType: HasAfEnum,
    <T as ConstGenerator>::OutType: ImplicitPromote<T>,
    T: ImplicitPromote<<T as ConstGenerator>::OutType>,
    <<T as ConstGenerator>::OutType as ImplicitPromote<T>>::Output: HasAfEnum, 

Implement negation trait for Array

type Output = Array<<<T as ConstGenerator>::OutType as ImplicitPromote<T>>::Output>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<A, B> AddAssign<Array<B>> for Array<A> where
    A: HasAfEnum + ImplicitPromote<B>,
    B: HasAfEnum + ImplicitPromote<A>,
    <A as ImplicitPromote<B>>::Output: HasAfEnum,
    <B as ImplicitPromote<A>>::Output: HasAfEnum, 

fn add_assign(&mut self, rhs: Array<B>)

Performs the += operation.

impl<A, B> SubAssign<Array<B>> for Array<A> where
    A: HasAfEnum + ImplicitPromote<B>,
    B: HasAfEnum + ImplicitPromote<A>,
    <A as ImplicitPromote<B>>::Output: HasAfEnum,
    <B as ImplicitPromote<A>>::Output: HasAfEnum, 

fn sub_assign(&mut self, rhs: Array<B>)

Performs the -= operation.

impl<A, B> MulAssign<Array<B>> for Array<A> where
    A: HasAfEnum + ImplicitPromote<B>,
    B: HasAfEnum + ImplicitPromote<A>,
    <A as ImplicitPromote<B>>::Output: HasAfEnum,
    <B as ImplicitPromote<A>>::Output: HasAfEnum, 

fn mul_assign(&mut self, rhs: Array<B>)

Performs the *= operation.

impl<A, B> DivAssign<Array<B>> for Array<A> where
    A: HasAfEnum + ImplicitPromote<B>,
    B: HasAfEnum + ImplicitPromote<A>,
    <A as ImplicitPromote<B>>::Output: HasAfEnum,
    <B as ImplicitPromote<A>>::Output: HasAfEnum, 

fn div_assign(&mut self, rhs: Array<B>)

Performs the /= operation.

impl<A, B> RemAssign<Array<B>> for Array<A> where
    A: HasAfEnum + ImplicitPromote<B>,
    B: HasAfEnum + ImplicitPromote<A>,
    <A as ImplicitPromote<B>>::Output: HasAfEnum,
    <B as ImplicitPromote<A>>::Output: HasAfEnum, 

fn rem_assign(&mut self, rhs: Array<B>)

Performs the %= operation.

impl<'f, T> Not for &'f Array<T> where
    T: HasAfEnum, 

Enables use of ! on objects of type Array

type Output = Array<T>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<A, B> BitAnd<Array<B>> for Array<A> where
    A: HasAfEnum + ImplicitPromote<B>,
    B: HasAfEnum + ImplicitPromote<A>,
    <A as ImplicitPromote<B>>::Output: HasAfEnum, 

type Output = Array<<A as ImplicitPromote<B>>::Output>

The resulting type after applying the & operator.

fn bitand(self, rhs: Array<B>) -> Self::Output

Performs the & operation.

impl<'a, A, B> BitAnd<&'a Array<B>> for Array<A> where
    A: HasAfEnum + ImplicitPromote<B>,
    B: HasAfEnum + ImplicitPromote<A>,
    <A as ImplicitPromote<B>>::Output: HasAfEnum, 

type Output = Array<<A as ImplicitPromote<B>>::Output>

The resulting type after applying the & operator.

fn bitand(self, rhs: &'a Array<B>) -> Self::Output

Performs the & operation.

impl<'a, A, B> BitAnd<Array<B>> for &'a Array<A> where
    A: HasAfEnum + ImplicitPromote<B>,
    B: HasAfEnum + ImplicitPromote<A>,
    <A as ImplicitPromote<B>>::Output: HasAfEnum, 

type Output = Array<<A as ImplicitPromote<B>>::Output>

The resulting type after applying the & operator.

fn bitand(self, rhs: Array<B>) -> Self::Output

Performs the & operation.

impl<'a, 'b, A, B> BitAnd<&'a Array<B>> for &'b Array<A> where
    A: HasAfEnum + ImplicitPromote<B>,
    B: HasAfEnum + ImplicitPromote<A>,
    <A as ImplicitPromote<B>>::Output: HasAfEnum, 

type Output = Array<<A as ImplicitPromote<B>>::Output>

The resulting type after applying the & operator.

fn bitand(self, rhs: &'a Array<B>) -> Self::Output

Performs the & operation.

impl<A, B> BitOr<Array<B>> for Array<A> where
    A: HasAfEnum + ImplicitPromote<B>,
    B: HasAfEnum + ImplicitPromote<A>,
    <A as ImplicitPromote<B>>::Output: HasAfEnum, 

type Output = Array<<A as ImplicitPromote<B>>::Output>

The resulting type after applying the | operator.

fn bitor(self, rhs: Array<B>) -> Self::Output

Performs the | operation.

impl<'a, A, B> BitOr<&'a Array<B>> for Array<A> where
    A: HasAfEnum + ImplicitPromote<B>,
    B: HasAfEnum + ImplicitPromote<A>,
    <A as ImplicitPromote<B>>::Output: HasAfEnum, 

type Output = Array<<A as ImplicitPromote<B>>::Output>

The resulting type after applying the | operator.

fn bitor(self, rhs: &'a Array<B>) -> Self::Output

Performs the | operation.

impl<'a, A, B> BitOr<Array<B>> for &'a Array<A> where
    A: HasAfEnum + ImplicitPromote<B>,
    B: HasAfEnum + ImplicitPromote<A>,
    <A as ImplicitPromote<B>>::Output: HasAfEnum, 

type Output = Array<<A as ImplicitPromote<B>>::Output>

The resulting type after applying the | operator.

fn bitor(self, rhs: Array<B>) -> Self::Output

Performs the | operation.

impl<'a, 'b, A, B> BitOr<&'a Array<B>> for &'b Array<A> where
    A: HasAfEnum + ImplicitPromote<B>,
    B: HasAfEnum + ImplicitPromote<A>,
    <A as ImplicitPromote<B>>::Output: HasAfEnum, 

type Output = Array<<A as ImplicitPromote<B>>::Output>

The resulting type after applying the | operator.

fn bitor(self, rhs: &'a Array<B>) -> Self::Output

Performs the | operation.

impl<A, B> BitXor<Array<B>> for Array<A> where
    A: HasAfEnum + ImplicitPromote<B>,
    B: HasAfEnum + ImplicitPromote<A>,
    <A as ImplicitPromote<B>>::Output: HasAfEnum, 

type Output = Array<<A as ImplicitPromote<B>>::Output>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Array<B>) -> Self::Output

Performs the ^ operation.

impl<'a, A, B> BitXor<&'a Array<B>> for Array<A> where
    A: HasAfEnum + ImplicitPromote<B>,
    B: HasAfEnum + ImplicitPromote<A>,
    <A as ImplicitPromote<B>>::Output: HasAfEnum, 

type Output = Array<<A as ImplicitPromote<B>>::Output>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &'a Array<B>) -> Self::Output

Performs the ^ operation.

impl<'a, A, B> BitXor<Array<B>> for &'a Array<A> where
    A: HasAfEnum + ImplicitPromote<B>,
    B: HasAfEnum + ImplicitPromote<A>,
    <A as ImplicitPromote<B>>::Output: HasAfEnum, 

type Output = Array<<A as ImplicitPromote<B>>::Output>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Array<B>) -> Self::Output

Performs the ^ operation.

impl<'a, 'b, A, B> BitXor<&'a Array<B>> for &'b Array<A> where
    A: HasAfEnum + ImplicitPromote<B>,
    B: HasAfEnum + ImplicitPromote<A>,
    <A as ImplicitPromote<B>>::Output: HasAfEnum, 

type Output = Array<<A as ImplicitPromote<B>>::Output>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &'a Array<B>) -> Self::Output

Performs the ^ operation.

impl<A, B> Shl<Array<B>> for Array<A> where
    A: HasAfEnum + ImplicitPromote<B>,
    B: HasAfEnum + ImplicitPromote<A>,
    <A as ImplicitPromote<B>>::Output: HasAfEnum, 

type Output = Array<<A as ImplicitPromote<B>>::Output>

The resulting type after applying the << operator.

fn shl(self, rhs: Array<B>) -> Self::Output

Performs the << operation.

impl<'a, A, B> Shl<&'a Array<B>> for Array<A> where
    A: HasAfEnum + ImplicitPromote<B>,
    B: HasAfEnum + ImplicitPromote<A>,
    <A as ImplicitPromote<B>>::Output: HasAfEnum, 

type Output = Array<<A as ImplicitPromote<B>>::Output>

The resulting type after applying the << operator.

fn shl(self, rhs: &'a Array<B>) -> Self::Output

Performs the << operation.

impl<'a, A, B> Shl<Array<B>> for &'a Array<A> where
    A: HasAfEnum + ImplicitPromote<B>,
    B: HasAfEnum + ImplicitPromote<A>,
    <A as ImplicitPromote<B>>::Output: HasAfEnum, 

type Output = Array<<A as ImplicitPromote<B>>::Output>

The resulting type after applying the << operator.

fn shl(self, rhs: Array<B>) -> Self::Output

Performs the << operation.

impl<'a, 'b, A, B> Shl<&'a Array<B>> for &'b Array<A> where
    A: HasAfEnum + ImplicitPromote<B>,
    B: HasAfEnum + ImplicitPromote<A>,
    <A as ImplicitPromote<B>>::Output: HasAfEnum, 

type Output = Array<<A as ImplicitPromote<B>>::Output>

The resulting type after applying the << operator.

fn shl(self, rhs: &'a Array<B>) -> Self::Output

Performs the << operation.

impl<A, B> Shr<Array<B>> for Array<A> where
    A: HasAfEnum + ImplicitPromote<B>,
    B: HasAfEnum + ImplicitPromote<A>,
    <A as ImplicitPromote<B>>::Output: HasAfEnum, 

type Output = Array<<A as ImplicitPromote<B>>::Output>

The resulting type after applying the >> operator.

fn shr(self, rhs: Array<B>) -> Self::Output

Performs the >> operation.

impl<'a, A, B> Shr<&'a Array<B>> for Array<A> where
    A: HasAfEnum + ImplicitPromote<B>,
    B: HasAfEnum + ImplicitPromote<A>,
    <A as ImplicitPromote<B>>::Output: HasAfEnum, 

type Output = Array<<A as ImplicitPromote<B>>::Output>

The resulting type after applying the >> operator.

fn shr(self, rhs: &'a Array<B>) -> Self::Output

Performs the >> operation.

impl<'a, A, B> Shr<Array<B>> for &'a Array<A> where
    A: HasAfEnum + ImplicitPromote<B>,
    B: HasAfEnum + ImplicitPromote<A>,
    <A as ImplicitPromote<B>>::Output: HasAfEnum, 

type Output = Array<<A as ImplicitPromote<B>>::Output>

The resulting type after applying the >> operator.

fn shr(self, rhs: Array<B>) -> Self::Output

Performs the >> operation.

impl<'a, 'b, A, B> Shr<&'a Array<B>> for &'b Array<A> where
    A: HasAfEnum + ImplicitPromote<B>,
    B: HasAfEnum + ImplicitPromote<A>,
    <A as ImplicitPromote<B>>::Output: HasAfEnum, 

type Output = Array<<A as ImplicitPromote<B>>::Output>

The resulting type after applying the >> operator.

fn shr(self, rhs: &'a Array<B>) -> Self::Output

Performs the >> operation.

impl<A, B> BitAndAssign<Array<B>> for Array<A> where
    A: HasAfEnum + ImplicitPromote<B>,
    B: HasAfEnum + ImplicitPromote<A>,
    <A as ImplicitPromote<B>>::Output: HasAfEnum,
    <B as ImplicitPromote<A>>::Output: HasAfEnum, 

fn bitand_assign(&mut self, rhs: Array<B>)

Performs the &= operation.

impl<A, B> BitOrAssign<Array<B>> for Array<A> where
    A: HasAfEnum + ImplicitPromote<B>,
    B: HasAfEnum + ImplicitPromote<A>,
    <A as ImplicitPromote<B>>::Output: HasAfEnum,
    <B as ImplicitPromote<A>>::Output: HasAfEnum, 

fn bitor_assign(&mut self, rhs: Array<B>)

Performs the |= operation.

impl<A, B> BitXorAssign<Array<B>> for Array<A> where
    A: HasAfEnum + ImplicitPromote<B>,
    B: HasAfEnum + ImplicitPromote<A>,
    <A as ImplicitPromote<B>>::Output: HasAfEnum,
    <B as ImplicitPromote<A>>::Output: HasAfEnum, 

fn bitxor_assign(&mut self, rhs: Array<B>)

Performs the ^= operation.

impl<A, B> ShlAssign<Array<B>> for Array<A> where
    A: HasAfEnum + ImplicitPromote<B>,
    B: HasAfEnum + ImplicitPromote<A>,
    <A as ImplicitPromote<B>>::Output: HasAfEnum,
    <B as ImplicitPromote<A>>::Output: HasAfEnum, 

fn shl_assign(&mut self, rhs: Array<B>)

Performs the <<= operation.

impl<A, B> ShrAssign<Array<B>> for Array<A> where
    A: HasAfEnum + ImplicitPromote<B>,
    B: HasAfEnum + ImplicitPromote<A>,
    <A as ImplicitPromote<B>>::Output: HasAfEnum,
    <B as ImplicitPromote<A>>::Output: HasAfEnum, 

fn shr_assign(&mut self, rhs: Array<B>)

Performs the >>= operation.