Struct arrayfire::Array

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

A multidimensional data container

Currently, Array objects can store only data until four dimensions

Sharing Across Threads

While sharing an Array with other threads, there is no need to wrap this in an Arc object unless only one such object is required to exist. The reason being that ArrayFire's internal Array is appropriately reference counted in thread safe manner. However, if you need to modify Array object, then please do wrap the object using a Mutex or Read-Write lock.

Examples on how to share Array across threads is illustrated in our book

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.

Implementations

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

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

Constructs a new Array object

Examples

An example of creating an Array from f32 array

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

An example of creating an Array from half::f16 array

use arrayfire::{Array, Dim4, is_half_available, print};
use half::f16;

let values: [f32; 3] = [1.0, 2.0, 3.0];

if is_half_available(0) { // Default device is 0, hence the argument
    let half_values = values.iter().map(|&x| f16::from_f32(x)).collect::<Vec<_>>();

    let hvals = Array::new(&half_values, Dim4::new(&[3, 1, 1, 1]));

    print(&hvals);
} else {
    println!("Half support isn't available on this device");
}

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 garbage_vals = Array::<f32>::new_empty(Dim4::new(&[3, 1, 1, 1]));

pub fn new_from_device_ptr(dev_ptr: *mut T, dims: Dim4) -> Self

Constructs a new Array object from device pointer

The example show cases the usage using CUDA API, but usage of this function will be similar in CPU and OpenCL backends also. In the case of OpenCL backend, the pointer would be cl_mem. A short example of how to create an Array from device pointer is shown below but for detailed set of examples, please check out the tutorial book pages:

• Interoperability with CUDA
• Interoperability with OpenCL

Examples

An example of creating an Array device pointer using rustacuda crate. The example has to be copied to a bin crate with following contents in Cargo.toml to run successfully. Note that, all required setup for rustacuda and arrayfire crate have to completed first.

[package]
....
[dependencies]
rustacuda = "0.1"
rustacuda_derive = "0.1"
rustacuda_core = "0.1"
arrayfire = "3.7.*"

use arrayfire::*;
use rustacuda::*;
use rustacuda::prelude::*;

fn main() {
   let v: Vec<_> = (0u8 .. 100).map(f32::from).collect();

   rustacuda::init(CudaFlags::empty());
   let device = Device::get_device(0).unwrap();
   let context = Context::create_and_push(ContextFlags::MAP_HOST | ContextFlags::SCHED_AUTO,
                                          device).unwrap();
   // Approach 1
   {
       let mut buffer = memory::DeviceBuffer::from_slice(&v).unwrap();

       let array_dptr = Array::new_from_device_ptr(
           buffer.as_device_ptr().as_raw_mut(), dim4!(10, 10));

       af_print!("array_dptr", &array_dptr);

       array_dptr.lock(); // Needed to avoid free as arrayfire takes ownership
   }

   // Approach 2
   {
       let mut dptr: *mut f32 = std::ptr::null_mut();
       unsafe {
           dptr = memory::cuda_malloc::<f32>(10*10).unwrap().as_raw_mut();
       }
       let array_dptr = Array::new_from_device_ptr(dptr, dim4!(10, 10));
       // note that values might be garbage in the memory pointed out by dptr
       // in this example as it is allocated but not initialized prior to passing
       // along to arrayfire::Array::new*

       // After ArrayFire takes over ownership of the pointer, you can use other
       // arrayfire functions as usual.
       af_print!("array_dptr", &array_dptr);
   }
}

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 unsafe fn get(&self) -> af_array

Returns the native FFI handle for Rust object Array

pub fn set(&mut self, handle: af_array)

Set 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

Examples

Basic case

let a:Vec<u8> = vec![0,1,2,3,4,5,6,7,8];
let b = Array::<u8>::new(&a,Dim4::new(&[3,3,1,1]));
let mut c = vec!(u8::default();b.elements());
b.host(&mut c);
assert_eq!(c,a);

Generic case

fn to_vec<T:HasAfEnum+Default+Clone>(array:&Array<T>) -> Vec<T> {
    let mut vec = vec!(T::default();array.elements());
    array.host(&mut vec);
    return vec;
}

let a = Array::<u8>::new(&[0,1,2,3,4,5,6,7,8],Dim4::new(&[3,3,1,1]));
let b:Vec<u8> = vec![0,1,2,3,4,5,6,7,8];
assert_eq!(to_vec(&a),b);

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_real(&self) -> bool

Check if Array is of real (not complex) type

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_half(&self) -> bool

Check if Array's numerical type is of half 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_realfloating(&self) -> bool

Check if Array is floating point real(not complex) data type

pub fn is_floating(&self) -> bool

Check if Array is floating point type, either real or complex data

pub fn is_linear(&self) -> bool

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

pub fn is_sparse(&self) -> bool

Check if Array is a sparse matrix

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 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 unsafe fn device_ptr(&self) -> void_ptr

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<'a, A, B> Add<&'a Array<B>> for Array<A> where
    A: ImplicitPromote<B>,
    B: ImplicitPromote<A>, 

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, 'b, A, B> Add<&'a Array<B>> for &'b Array<A> where
    A: ImplicitPromote<B>,
    B: ImplicitPromote<A>, 

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> Add<&'f Array<T>> for Complex<f64> where
    T: ImplicitPromote<Complex<f64>>,
    Complex<f64>: ImplicitPromote<T>, 

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'f, T> Add<&'f Array<T>> for f64 where
    T: ImplicitPromote<f64>,
    f64: ImplicitPromote<T>, 

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'f, T> Add<&'f Array<T>> for f32 where
    T: ImplicitPromote<f32>,
    f32: ImplicitPromote<T>, 

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'f, T> Add<&'f Array<T>> for u64 where
    T: ImplicitPromote<u64>,
    u64: ImplicitPromote<T>, 

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'f, T> Add<&'f Array<T>> for i64 where
    T: ImplicitPromote<i64>,
    i64: ImplicitPromote<T>, 

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'f, T> Add<&'f Array<T>> for u32 where
    T: ImplicitPromote<u32>,
    u32: ImplicitPromote<T>, 

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'f, T> Add<&'f Array<T>> for i32 where
    T: ImplicitPromote<i32>,
    i32: ImplicitPromote<T>, 

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'f, T> Add<&'f Array<T>> for u8 where
    T: ImplicitPromote<u8>,
    u8: ImplicitPromote<T>, 

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl<A, B> Add<Array<B>> for Array<A> where
    A: ImplicitPromote<B>,
    B: ImplicitPromote<A>, 

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<Array<B>> for &'a Array<A> where
    A: ImplicitPromote<B>,
    B: ImplicitPromote<A>, 

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<T> Add<Array<T>> for Complex<f64> where
    T: ImplicitPromote<Complex<f64>>,
    Complex<f64>: ImplicitPromote<T>, 

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T> Add<Array<T>> for Complex<f32> where
    T: ImplicitPromote<Complex<f32>>,
    Complex<f32>: ImplicitPromote<T>, 

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T> Add<Array<T>> for f64 where
    T: ImplicitPromote<f64>,
    f64: ImplicitPromote<T>, 

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T> Add<Array<T>> for f32 where
    T: ImplicitPromote<f32>,
    f32: ImplicitPromote<T>, 

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T> Add<Array<T>> for u64 where
    T: ImplicitPromote<u64>,
    u64: ImplicitPromote<T>, 

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T> Add<Array<T>> for i64 where
    T: ImplicitPromote<i64>,
    i64: ImplicitPromote<T>, 

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T> Add<Array<T>> for u32 where
    T: ImplicitPromote<u32>,
    u32: ImplicitPromote<T>, 

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T> Add<Array<T>> for i32 where
    T: ImplicitPromote<i32>,
    i32: ImplicitPromote<T>, 

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T> Add<Array<T>> for u8 where
    T: ImplicitPromote<u8>,
    u8: ImplicitPromote<T>, 

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'f, T, U> Add<U> for &'f Array<T> where
    T: ImplicitPromote<U>,
    U: ImplicitPromote<T> + Clone + ConstGenerator<OutType = U>, 

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, U> Add<U> for Array<T> where
    T: ImplicitPromote<U>,
    U: ImplicitPromote<T> + Clone + ConstGenerator<OutType = U>, 

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl<A, B> AddAssign<Array<B>> for Array<A> where
    A: ImplicitPromote<B>,
    B: ImplicitPromote<A>, 

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

Performs the += operation.

impl<'a, A, B> BitAnd<&'a Array<B>> for Array<A> where
    A: ImplicitPromote<B>,
    B: ImplicitPromote<A>, 

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, A, B> BitAnd<&'a Array<B>> for &'b Array<A> where
    A: ImplicitPromote<B>,
    B: ImplicitPromote<A>, 

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> BitAnd<Array<B>> for Array<A> where
    A: ImplicitPromote<B>,
    B: ImplicitPromote<A>, 

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<Array<B>> for &'a Array<A> where
    A: ImplicitPromote<B>,
    B: ImplicitPromote<A>, 

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> BitAndAssign<Array<B>> for Array<A> where
    A: ImplicitPromote<B>,
    B: ImplicitPromote<A>, 

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

Performs the &= operation.

impl<'a, A, B> BitOr<&'a Array<B>> for Array<A> where
    A: ImplicitPromote<B>,
    B: ImplicitPromote<A>, 

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, A, B> BitOr<&'a Array<B>> for &'b Array<A> where
    A: ImplicitPromote<B>,
    B: ImplicitPromote<A>, 

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> BitOr<Array<B>> for Array<A> where
    A: ImplicitPromote<B>,
    B: ImplicitPromote<A>, 

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<Array<B>> for &'a Array<A> where
    A: ImplicitPromote<B>,
    B: ImplicitPromote<A>, 

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> BitOrAssign<Array<B>> for Array<A> where
    A: ImplicitPromote<B>,
    B: ImplicitPromote<A>, 

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

Performs the |= operation.

impl<'a, A, B> BitXor<&'a Array<B>> for Array<A> where
    A: ImplicitPromote<B>,
    B: ImplicitPromote<A>, 

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, A, B> BitXor<&'a Array<B>> for &'b Array<A> where
    A: ImplicitPromote<B>,
    B: ImplicitPromote<A>, 

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> BitXor<Array<B>> for Array<A> where
    A: ImplicitPromote<B>,
    B: ImplicitPromote<A>, 

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<Array<B>> for &'a Array<A> where
    A: ImplicitPromote<B>,
    B: ImplicitPromote<A>, 

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> BitXorAssign<Array<B>> for Array<A> where
    A: ImplicitPromote<B>,
    B: ImplicitPromote<A>, 

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

Performs the ^= operation.

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<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<'a, A, B> Div<&'a Array<B>> for Array<A> where
    A: ImplicitPromote<B>,
    B: ImplicitPromote<A>, 

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, A, B> Div<&'a Array<B>> for &'b Array<A> where
    A: ImplicitPromote<B>,
    B: ImplicitPromote<A>, 

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<'f, T> Div<&'f Array<T>> for Complex<f64> where
    T: ImplicitPromote<Complex<f64>>,
    Complex<f64>: ImplicitPromote<T>, 

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

The resulting type after applying the / operator.

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

Performs the / operation.

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

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

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'f, T> Div<&'f Array<T>> for f64 where
    T: ImplicitPromote<f64>,
    f64: ImplicitPromote<T>, 

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

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'f, T> Div<&'f Array<T>> for f32 where
    T: ImplicitPromote<f32>,
    f32: ImplicitPromote<T>, 

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

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'f, T> Div<&'f Array<T>> for u64 where
    T: ImplicitPromote<u64>,
    u64: ImplicitPromote<T>, 

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

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'f, T> Div<&'f Array<T>> for i64 where
    T: ImplicitPromote<i64>,
    i64: ImplicitPromote<T>, 

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

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'f, T> Div<&'f Array<T>> for u32 where
    T: ImplicitPromote<u32>,
    u32: ImplicitPromote<T>, 

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

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'f, T> Div<&'f Array<T>> for i32 where
    T: ImplicitPromote<i32>,
    i32: ImplicitPromote<T>, 

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

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'f, T> Div<&'f Array<T>> for u8 where
    T: ImplicitPromote<u8>,
    u8: ImplicitPromote<T>, 

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

The resulting type after applying the / operator.

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

Performs the / operation.

impl<A, B> Div<Array<B>> for Array<A> where
    A: ImplicitPromote<B>,
    B: ImplicitPromote<A>, 

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<Array<B>> for &'a Array<A> where
    A: ImplicitPromote<B>,
    B: ImplicitPromote<A>, 

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<T> Div<Array<T>> for Complex<f64> where
    T: ImplicitPromote<Complex<f64>>,
    Complex<f64>: ImplicitPromote<T>, 

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

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T> Div<Array<T>> for Complex<f32> where
    T: ImplicitPromote<Complex<f32>>,
    Complex<f32>: ImplicitPromote<T>, 

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

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T> Div<Array<T>> for f64 where
    T: ImplicitPromote<f64>,
    f64: ImplicitPromote<T>, 

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

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T> Div<Array<T>> for f32 where
    T: ImplicitPromote<f32>,
    f32: ImplicitPromote<T>, 

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

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T> Div<Array<T>> for u64 where
    T: ImplicitPromote<u64>,
    u64: ImplicitPromote<T>, 

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

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T> Div<Array<T>> for i64 where
    T: ImplicitPromote<i64>,
    i64: ImplicitPromote<T>, 

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

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T> Div<Array<T>> for u32 where
    T: ImplicitPromote<u32>,
    u32: ImplicitPromote<T>, 

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

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T> Div<Array<T>> for i32 where
    T: ImplicitPromote<i32>,
    i32: ImplicitPromote<T>, 

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

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T> Div<Array<T>> for u8 where
    T: ImplicitPromote<u8>,
    u8: ImplicitPromote<T>, 

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

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'f, T, U> Div<U> for &'f Array<T> where
    T: ImplicitPromote<U>,
    U: ImplicitPromote<T> + Clone + ConstGenerator<OutType = U>, 

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

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, U> Div<U> for Array<T> where
    T: ImplicitPromote<U>,
    U: ImplicitPromote<T> + Clone + ConstGenerator<OutType = U>, 

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

The resulting type after applying the / operator.

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

Performs the / operation.

impl<A, B> DivAssign<Array<B>> for Array<A> where
    A: ImplicitPromote<B>,
    B: ImplicitPromote<A>, 

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

Performs the /= operation.

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> Indexable for Array<T> where
    T: HasAfEnum + IndexableType, 

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 af_array

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

fn into(self) -> Array<T>

Performs the conversion.

impl<'a, A, B> Mul<&'a Array<B>> for Array<A> where
    A: ImplicitPromote<B>,
    B: ImplicitPromote<A>, 

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, 'b, A, B> Mul<&'a Array<B>> for &'b Array<A> where
    A: ImplicitPromote<B>,
    B: ImplicitPromote<A>, 

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> Mul<&'f Array<T>> for Complex<f64> where
    T: ImplicitPromote<Complex<f64>>,
    Complex<f64>: ImplicitPromote<T>, 

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'f, T> Mul<&'f Array<T>> for f64 where
    T: ImplicitPromote<f64>,
    f64: ImplicitPromote<T>, 

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'f, T> Mul<&'f Array<T>> for f32 where
    T: ImplicitPromote<f32>,
    f32: ImplicitPromote<T>, 

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'f, T> Mul<&'f Array<T>> for u64 where
    T: ImplicitPromote<u64>,
    u64: ImplicitPromote<T>, 

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'f, T> Mul<&'f Array<T>> for i64 where
    T: ImplicitPromote<i64>,
    i64: ImplicitPromote<T>, 

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'f, T> Mul<&'f Array<T>> for u32 where
    T: ImplicitPromote<u32>,
    u32: ImplicitPromote<T>, 

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'f, T> Mul<&'f Array<T>> for i32 where
    T: ImplicitPromote<i32>,
    i32: ImplicitPromote<T>, 

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'f, T> Mul<&'f Array<T>> for u8 where
    T: ImplicitPromote<u8>,
    u8: ImplicitPromote<T>, 

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<A, B> Mul<Array<B>> for Array<A> where
    A: ImplicitPromote<B>,
    B: ImplicitPromote<A>, 

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<Array<B>> for &'a Array<A> where
    A: ImplicitPromote<B>,
    B: ImplicitPromote<A>, 

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<T> Mul<Array<T>> for Complex<f64> where
    T: ImplicitPromote<Complex<f64>>,
    Complex<f64>: ImplicitPromote<T>, 

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> Mul<Array<T>> for Complex<f32> where
    T: ImplicitPromote<Complex<f32>>,
    Complex<f32>: ImplicitPromote<T>, 

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> Mul<Array<T>> for f64 where
    T: ImplicitPromote<f64>,
    f64: ImplicitPromote<T>, 

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> Mul<Array<T>> for f32 where
    T: ImplicitPromote<f32>,
    f32: ImplicitPromote<T>, 

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> Mul<Array<T>> for u64 where
    T: ImplicitPromote<u64>,
    u64: ImplicitPromote<T>, 

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> Mul<Array<T>> for i64 where
    T: ImplicitPromote<i64>,
    i64: ImplicitPromote<T>, 

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> Mul<Array<T>> for u32 where
    T: ImplicitPromote<u32>,
    u32: ImplicitPromote<T>, 

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> Mul<Array<T>> for i32 where
    T: ImplicitPromote<i32>,
    i32: ImplicitPromote<T>, 

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> Mul<Array<T>> for u8 where
    T: ImplicitPromote<u8>,
    u8: ImplicitPromote<T>, 

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'f, T, U> Mul<U> for &'f Array<T> where
    T: ImplicitPromote<U>,
    U: ImplicitPromote<T> + Clone + ConstGenerator<OutType = U>, 

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, U> Mul<U> for Array<T> where
    T: ImplicitPromote<U>,
    U: ImplicitPromote<T> + Clone + ConstGenerator<OutType = U>, 

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl<A, B> MulAssign<Array<B>> for Array<A> where
    A: ImplicitPromote<B>,
    B: ImplicitPromote<A>, 

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

Performs the *= operation.

impl<T> Neg for Array<T> where
    T: Zero + ConstGenerator<OutType = T>, 

Implement negation trait for Array

type Output = Array<T>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - 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, A, B> Rem<&'a Array<B>> for Array<A> where
    A: ImplicitPromote<B>,
    B: ImplicitPromote<A>, 

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, 'b, A, B> Rem<&'a Array<B>> for &'b Array<A> where
    A: ImplicitPromote<B>,
    B: ImplicitPromote<A>, 

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, B> Rem<Array<B>> for Array<A> where
    A: ImplicitPromote<B>,
    B: ImplicitPromote<A>, 

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<Array<B>> for &'a Array<A> where
    A: ImplicitPromote<B>,
    B: ImplicitPromote<A>, 

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> RemAssign<Array<B>> for Array<A> where
    A: ImplicitPromote<B>,
    B: ImplicitPromote<A>, 

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

Performs the %= operation.

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

Enable safely moving Array objects across threads

impl<'a, A, B> Shl<&'a Array<B>> for Array<A> where
    A: ImplicitPromote<B>,
    B: ImplicitPromote<A>, 

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, A, B> Shl<&'a Array<B>> for &'b Array<A> where
    A: ImplicitPromote<B>,
    B: ImplicitPromote<A>, 

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> Shl<Array<B>> for Array<A> where
    A: ImplicitPromote<B>,
    B: ImplicitPromote<A>, 

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<Array<B>> for &'a Array<A> where
    A: ImplicitPromote<B>,
    B: ImplicitPromote<A>, 

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<T> Shl<u16> for Array<T> where
    T: ImplicitPromote<u16>,
    u16: ImplicitPromote<T>, 

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

The resulting type after applying the << operator.

fn shl(self, rhs: u16) -> Self::Output

Performs the << operation.

impl<'f, T> Shl<u16> for &'f Array<T> where
    T: ImplicitPromote<u16>,
    u16: ImplicitPromote<T>, 

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

The resulting type after applying the << operator.

fn shl(self, rhs: u16) -> Self::Output

Performs the << operation.

impl<T> Shl<u32> for Array<T> where
    T: ImplicitPromote<u32>,
    u32: ImplicitPromote<T>, 

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

The resulting type after applying the << operator.

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

Performs the << operation.

impl<'f, T> Shl<u32> for &'f Array<T> where
    T: ImplicitPromote<u32>,
    u32: ImplicitPromote<T>, 

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

The resulting type after applying the << operator.

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

Performs the << operation.

impl<T> Shl<u64> for Array<T> where
    T: ImplicitPromote<u64>,
    u64: ImplicitPromote<T>, 

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

The resulting type after applying the << operator.

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

Performs the << operation.

impl<'f, T> Shl<u64> for &'f Array<T> where
    T: ImplicitPromote<u64>,
    u64: ImplicitPromote<T>, 

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

The resulting type after applying the << operator.

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

Performs the << operation.

impl<T> Shl<u8> for Array<T> where
    T: ImplicitPromote<u8>,
    u8: ImplicitPromote<T>, 

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

The resulting type after applying the << operator.

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

Performs the << operation.

impl<'f, T> Shl<u8> for &'f Array<T> where
    T: ImplicitPromote<u8>,
    u8: ImplicitPromote<T>, 

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

The resulting type after applying the << operator.

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

Performs the << operation.

impl<A, B> ShlAssign<Array<B>> for Array<A> where
    A: ImplicitPromote<B>,
    B: ImplicitPromote<A>, 

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

Performs the <<= operation.

impl<T> ShlAssign<u16> for Array<T> where
    u16: ImplicitPromote<T>,
    T: ImplicitPromote<u16, Output = T>, 

fn shl_assign(&mut self, rhs: u16)

Performs the <<= operation.

impl<T> ShlAssign<u32> for Array<T> where
    u32: ImplicitPromote<T>,
    T: ImplicitPromote<u32, Output = T>, 

fn shl_assign(&mut self, rhs: u32)

Performs the <<= operation.

impl<T> ShlAssign<u64> for Array<T> where
    u64: ImplicitPromote<T>,
    T: ImplicitPromote<u64, Output = T>, 

fn shl_assign(&mut self, rhs: u64)

Performs the <<= operation.

impl<T> ShlAssign<u8> for Array<T> where
    u8: ImplicitPromote<T>,
    T: ImplicitPromote<u8, Output = T>, 

fn shl_assign(&mut self, rhs: u8)

Performs the <<= operation.

impl<'a, A, B> Shr<&'a Array<B>> for Array<A> where
    A: ImplicitPromote<B>,
    B: ImplicitPromote<A>, 

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, A, B> Shr<&'a Array<B>> for &'b Array<A> where
    A: ImplicitPromote<B>,
    B: ImplicitPromote<A>, 

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> Shr<Array<B>> for Array<A> where
    A: ImplicitPromote<B>,
    B: ImplicitPromote<A>, 

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<Array<B>> for &'a Array<A> where
    A: ImplicitPromote<B>,
    B: ImplicitPromote<A>, 

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<T> Shr<u16> for Array<T> where
    T: ImplicitPromote<u16>,
    u16: ImplicitPromote<T>, 

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

The resulting type after applying the >> operator.

fn shr(self, rhs: u16) -> Self::Output

Performs the >> operation.

impl<'f, T> Shr<u16> for &'f Array<T> where
    T: ImplicitPromote<u16>,
    u16: ImplicitPromote<T>, 

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

The resulting type after applying the >> operator.

fn shr(self, rhs: u16) -> Self::Output

Performs the >> operation.

impl<T> Shr<u32> for Array<T> where
    T: ImplicitPromote<u32>,
    u32: ImplicitPromote<T>, 

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

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<'f, T> Shr<u32> for &'f Array<T> where
    T: ImplicitPromote<u32>,
    u32: ImplicitPromote<T>, 

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

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<T> Shr<u64> for Array<T> where
    T: ImplicitPromote<u64>,
    u64: ImplicitPromote<T>, 

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

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<'f, T> Shr<u64> for &'f Array<T> where
    T: ImplicitPromote<u64>,
    u64: ImplicitPromote<T>, 

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

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<T> Shr<u8> for Array<T> where
    T: ImplicitPromote<u8>,
    u8: ImplicitPromote<T>, 

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

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<'f, T> Shr<u8> for &'f Array<T> where
    T: ImplicitPromote<u8>,
    u8: ImplicitPromote<T>, 

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

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<A, B> ShrAssign<Array<B>> for Array<A> where
    A: ImplicitPromote<B>,
    B: ImplicitPromote<A>, 

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

Performs the >>= operation.

impl<T> ShrAssign<u16> for Array<T> where
    u16: ImplicitPromote<T>,
    T: ImplicitPromote<u16, Output = T>, 

fn shr_assign(&mut self, rhs: u16)

Performs the >>= operation.

impl<T> ShrAssign<u32> for Array<T> where
    u32: ImplicitPromote<T>,
    T: ImplicitPromote<u32, Output = T>, 

fn shr_assign(&mut self, rhs: u32)

Performs the >>= operation.

impl<T> ShrAssign<u64> for Array<T> where
    u64: ImplicitPromote<T>,
    T: ImplicitPromote<u64, Output = T>, 

fn shr_assign(&mut self, rhs: u64)

Performs the >>= operation.

impl<T> ShrAssign<u8> for Array<T> where
    u8: ImplicitPromote<T>,
    T: ImplicitPromote<u8, Output = T>, 

fn shr_assign(&mut self, rhs: u8)

Performs the >>= operation.

impl<'a, A, B> Sub<&'a Array<B>> for Array<A> where
    A: ImplicitPromote<B>,
    B: ImplicitPromote<A>, 

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, 'b, A, B> Sub<&'a Array<B>> for &'b Array<A> where
    A: ImplicitPromote<B>,
    B: ImplicitPromote<A>, 

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> Sub<&'f Array<T>> for Complex<f64> where
    T: ImplicitPromote<Complex<f64>>,
    Complex<f64>: ImplicitPromote<T>, 

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

The resulting type after applying the - operator.

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

Performs the - operation.

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

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

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'f, T> Sub<&'f Array<T>> for f64 where
    T: ImplicitPromote<f64>,
    f64: ImplicitPromote<T>, 

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

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'f, T> Sub<&'f Array<T>> for f32 where
    T: ImplicitPromote<f32>,
    f32: ImplicitPromote<T>, 

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

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'f, T> Sub<&'f Array<T>> for u64 where
    T: ImplicitPromote<u64>,
    u64: ImplicitPromote<T>, 

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

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'f, T> Sub<&'f Array<T>> for i64 where
    T: ImplicitPromote<i64>,
    i64: ImplicitPromote<T>, 

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

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'f, T> Sub<&'f Array<T>> for u32 where
    T: ImplicitPromote<u32>,
    u32: ImplicitPromote<T>, 

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

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'f, T> Sub<&'f Array<T>> for i32 where
    T: ImplicitPromote<i32>,
    i32: ImplicitPromote<T>, 

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

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'f, T> Sub<&'f Array<T>> for u8 where
    T: ImplicitPromote<u8>,
    u8: ImplicitPromote<T>, 

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

The resulting type after applying the - operator.

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

Performs the - operation.

impl<A, B> Sub<Array<B>> for Array<A> where
    A: ImplicitPromote<B>,
    B: ImplicitPromote<A>, 

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<Array<B>> for &'a Array<A> where
    A: ImplicitPromote<B>,
    B: ImplicitPromote<A>, 

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<T> Sub<Array<T>> for Complex<f64> where
    T: ImplicitPromote<Complex<f64>>,
    Complex<f64>: ImplicitPromote<T>, 

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

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T> Sub<Array<T>> for Complex<f32> where
    T: ImplicitPromote<Complex<f32>>,
    Complex<f32>: ImplicitPromote<T>, 

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

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T> Sub<Array<T>> for f64 where
    T: ImplicitPromote<f64>,
    f64: ImplicitPromote<T>, 

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

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T> Sub<Array<T>> for f32 where
    T: ImplicitPromote<f32>,
    f32: ImplicitPromote<T>, 

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

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T> Sub<Array<T>> for u64 where
    T: ImplicitPromote<u64>,
    u64: ImplicitPromote<T>, 

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

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T> Sub<Array<T>> for i64 where
    T: ImplicitPromote<i64>,
    i64: ImplicitPromote<T>, 

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

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T> Sub<Array<T>> for u32 where
    T: ImplicitPromote<u32>,
    u32: ImplicitPromote<T>, 

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

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T> Sub<Array<T>> for i32 where
    T: ImplicitPromote<i32>,
    i32: ImplicitPromote<T>, 

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

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T> Sub<Array<T>> for u8 where
    T: ImplicitPromote<u8>,
    u8: ImplicitPromote<T>, 

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

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'f, T, U> Sub<U> for &'f Array<T> where
    T: ImplicitPromote<U>,
    U: ImplicitPromote<T> + Clone + ConstGenerator<OutType = U>, 

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

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, U> Sub<U> for Array<T> where
    T: ImplicitPromote<U>,
    U: ImplicitPromote<T> + Clone + ConstGenerator<OutType = U>, 

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

The resulting type after applying the - operator.

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

Performs the - operation.

impl<A, B> SubAssign<Array<B>> for Array<A> where
    A: ImplicitPromote<B>,
    B: ImplicitPromote<A>, 

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

Performs the -= operation.

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