[−][src]Struct arrayfire::Array
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,
[src]
T: HasAfEnum,
pub fn new(slice: &[T], dims: Dim4) -> Self
[src]
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
[src]
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
[src]
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
[src]
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
[src]
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
[src]
Returns the number of elements in the Array
pub fn get_type(&self) -> DType
[src]
Returns the Array data type
pub fn dims(&self) -> Dim4
[src]
Returns the dimensions of the Array
pub fn strides(&self) -> Dim4
[src]
Returns the strides of the Array
pub fn numdims(&self) -> u32
[src]
Returns the number of dimensions of the Array
pub fn offset(&self) -> i64
[src]
Returns the offset to the pointer from where data begins
pub fn get(&self) -> i64
[src]
Returns the native FFI handle for Rust object Array
pub fn host<O: HasAfEnum>(&self, data: &mut [O])
[src]
Copies the data from the Array to the mutable slice data
pub fn eval(&self)
[src]
Evaluates any pending lazy expressions that represent the data in the Array object
pub fn copy(&self) -> Self
[src]
Makes an copy of the Array
This does a deep copy of the data into a new Array
pub fn is_empty(&self) -> bool
[src]
Check if Array is empty
pub fn is_scalar(&self) -> bool
[src]
Check if Array is scalar
pub fn is_row(&self) -> bool
[src]
Check if Array is a row
pub fn is_column(&self) -> bool
[src]
Check if Array is a column
pub fn is_vector(&self) -> bool
[src]
Check if Array is a vector
pub fn is_complex(&self) -> bool
[src]
Check if Array is of complex type
pub fn is_double(&self) -> bool
[src]
Check if Array's numerical type is of double precision
pub fn is_single(&self) -> bool
[src]
Check if Array's numerical type is of single precision
pub fn is_real(&self) -> bool
[src]
Check if Array is of real type
pub fn is_floating(&self) -> bool
[src]
Check if Array is of single precision
pub fn is_integer(&self) -> bool
[src]
Check if Array is of integral type
pub fn is_bool(&self) -> bool
[src]
Check if Array is of boolean type
pub fn is_linear(&self) -> bool
[src]
Check if Array's memory layout is continuous and one dimensional
pub fn is_owner(&self) -> bool
[src]
Check if Array's memory is owned by it and not a view of another Array
pub fn cast<O: HasAfEnum>(&self) -> Array<O>
[src]
Cast the Array data type to target_type
pub fn is_sparse(&self) -> bool
[src]
Find if the current array is sparse
pub fn lock(&self)
[src]
Lock the device buffer in the memory manager
Locked buffers are not freed by memory manager until unlock is called.
pub fn unlock(&self)
[src]
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
[src]
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
[src]
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>
[src]
type OutType = T
This type alias always points to Self
which is the type of Array returned by the trait method convert. Read more
fn convert(&self) -> Array<Self::OutType>
[src]
impl<T: HasAfEnum> Indexable for Array<T>
[src]
Enables Array to be used to index another Array
This is used in functions index_gen and assign_gen
impl<T> Clone for Array<T> where
T: HasAfEnum,
[src]
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
[src]
fn clone_from(&mut self, source: &Self)
1.0.0[src]
Performs copy-assignment from source
. Read more
impl<T> Drop for Array<T> where
T: HasAfEnum,
[src]
T: HasAfEnum,
To free resources when Array goes out of scope
impl<T: HasAfEnum> Into<Array<T>> for i64
[src]
Used for creating Array object from native resource id, an 64 bit integer
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,
[src]
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
[src]
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,
[src]
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
[src]
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,
[src]
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
[src]
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,
[src]
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
[src]
impl<'f, T> Add<f64> for &'f Array<T> where
T: HasAfEnum + ImplicitPromote<f64>,
f64: HasAfEnum + ImplicitPromote<T>,
<T as ImplicitPromote<f64>>::Output: HasAfEnum,
[src]
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
[src]
impl<T: HasAfEnum> Add<f64> for Array<T> where
T: HasAfEnum + ImplicitPromote<f64>,
f64: HasAfEnum + ImplicitPromote<T>,
<T as ImplicitPromote<f64>>::Output: HasAfEnum,
[src]
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
[src]
impl<'f, T> Add<f32> for &'f Array<T> where
T: HasAfEnum + ImplicitPromote<f32>,
f32: HasAfEnum + ImplicitPromote<T>,
<T as ImplicitPromote<f32>>::Output: HasAfEnum,
[src]
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
[src]
impl<T: HasAfEnum> Add<f32> for Array<T> where
T: HasAfEnum + ImplicitPromote<f32>,
f32: HasAfEnum + ImplicitPromote<T>,
<T as ImplicitPromote<f32>>::Output: HasAfEnum,
[src]
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
[src]
impl<'f, T> Add<u64> for &'f Array<T> where
T: HasAfEnum + ImplicitPromote<u64>,
u64: HasAfEnum + ImplicitPromote<T>,
<T as ImplicitPromote<u64>>::Output: HasAfEnum,
[src]
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
[src]
impl<T: HasAfEnum> Add<u64> for Array<T> where
T: HasAfEnum + ImplicitPromote<u64>,
u64: HasAfEnum + ImplicitPromote<T>,
<T as ImplicitPromote<u64>>::Output: HasAfEnum,
[src]
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
[src]
impl<'f, T> Add<i64> for &'f Array<T> where
T: HasAfEnum + ImplicitPromote<i64>,
i64: HasAfEnum + ImplicitPromote<T>,
<T as ImplicitPromote<i64>>::Output: HasAfEnum,
[src]
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
[src]
impl<T: HasAfEnum> Add<i64> for Array<T> where
T: HasAfEnum + ImplicitPromote<i64>,
i64: HasAfEnum + ImplicitPromote<T>,
<T as ImplicitPromote<i64>>::Output: HasAfEnum,
[src]
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
[src]
impl<'f, T> Add<u32> for &'f Array<T> where
T: HasAfEnum + ImplicitPromote<u32>,
u32: HasAfEnum + ImplicitPromote<T>,
<T as ImplicitPromote<u32>>::Output: HasAfEnum,
[src]
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
[src]
impl<T: HasAfEnum> Add<u32> for Array<T> where
T: HasAfEnum + ImplicitPromote<u32>,
u32: HasAfEnum + ImplicitPromote<T>,
<T as ImplicitPromote<u32>>::Output: HasAfEnum,
[src]
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
[src]
impl<'f, T> Add<i32> for &'f Array<T> where
T: HasAfEnum + ImplicitPromote<i32>,
i32: HasAfEnum + ImplicitPromote<T>,
<T as ImplicitPromote<i32>>::Output: HasAfEnum,
[src]
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
[src]
impl<T: HasAfEnum> Add<i32> for Array<T> where
T: HasAfEnum + ImplicitPromote<i32>,
i32: HasAfEnum + ImplicitPromote<T>,
<T as ImplicitPromote<i32>>::Output: HasAfEnum,
[src]
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
[src]
impl<'f, T> Add<u8> for &'f Array<T> where
T: HasAfEnum + ImplicitPromote<u8>,
u8: HasAfEnum + ImplicitPromote<T>,
<T as ImplicitPromote<u8>>::Output: HasAfEnum,
[src]
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
[src]
impl<T: HasAfEnum> Add<u8> for Array<T> where
T: HasAfEnum + ImplicitPromote<u8>,
u8: HasAfEnum + ImplicitPromote<T>,
<T as ImplicitPromote<u8>>::Output: HasAfEnum,
[src]
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
[src]
impl<A, B> Add<Array<B>> for Array<A> where
A: HasAfEnum + ImplicitPromote<B>,
B: HasAfEnum + ImplicitPromote<A>,
<A as ImplicitPromote<B>>::Output: HasAfEnum,
[src]
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
[src]
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,
[src]
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
[src]
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,
[src]
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
[src]
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,
[src]
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
[src]
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,
[src]
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
[src]
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,
[src]
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
[src]
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,
[src]
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
[src]
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,
[src]
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
[src]
impl<'f, T> Sub<f64> for &'f Array<T> where
T: HasAfEnum + ImplicitPromote<f64>,
f64: HasAfEnum + ImplicitPromote<T>,
<T as ImplicitPromote<f64>>::Output: HasAfEnum,
[src]
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
[src]
impl<T: HasAfEnum> Sub<f64> for Array<T> where
T: HasAfEnum + ImplicitPromote<f64>,
f64: HasAfEnum + ImplicitPromote<T>,
<T as ImplicitPromote<f64>>::Output: HasAfEnum,
[src]
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
[src]
impl<'f, T> Sub<f32> for &'f Array<T> where
T: HasAfEnum + ImplicitPromote<f32>,
f32: HasAfEnum + ImplicitPromote<T>,
<T as ImplicitPromote<f32>>::Output: HasAfEnum,
[src]
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
[src]
impl<T: HasAfEnum> Sub<f32> for Array<T> where
T: HasAfEnum + ImplicitPromote<f32>,
f32: HasAfEnum + ImplicitPromote<T>,
<T as ImplicitPromote<f32>>::Output: HasAfEnum,
[src]
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
[src]
impl<'f, T> Sub<u64> for &'f Array<T> where
T: HasAfEnum + ImplicitPromote<u64>,
u64: HasAfEnum + ImplicitPromote<T>,
<T as ImplicitPromote<u64>>::Output: HasAfEnum,
[src]
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
[src]
impl<T: HasAfEnum> Sub<u64> for Array<T> where
T: HasAfEnum + ImplicitPromote<u64>,
u64: HasAfEnum + ImplicitPromote<T>,
<T as ImplicitPromote<u64>>::Output: HasAfEnum,
[src]
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
[src]
impl<'f, T> Sub<i64> for &'f Array<T> where
T: HasAfEnum + ImplicitPromote<i64>,
i64: HasAfEnum + ImplicitPromote<T>,
<T as ImplicitPromote<i64>>::Output: HasAfEnum,
[src]
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
[src]
impl<T: HasAfEnum> Sub<i64> for Array<T> where
T: HasAfEnum + ImplicitPromote<i64>,
i64: HasAfEnum + ImplicitPromote<T>,
<T as ImplicitPromote<i64>>::Output: HasAfEnum,
[src]
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
[src]
impl<'f, T> Sub<u32> for &'f Array<T> where
T: HasAfEnum + ImplicitPromote<u32>,
u32: HasAfEnum + ImplicitPromote<T>,
<T as ImplicitPromote<u32>>::Output: HasAfEnum,
[src]
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
[src]
impl<T: HasAfEnum> Sub<u32> for Array<T> where
T: HasAfEnum + ImplicitPromote<u32>,
u32: HasAfEnum + ImplicitPromote<T>,
<T as ImplicitPromote<u32>>::Output: HasAfEnum,
[src]
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
[src]
impl<'f, T> Sub<i32> for &'f Array<T> where
T: HasAfEnum + ImplicitPromote<i32>,
i32: HasAfEnum + ImplicitPromote<T>,
<T as ImplicitPromote<i32>>::Output: HasAfEnum,
[src]
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
[src]
impl<T: HasAfEnum> Sub<i32> for Array<T> where
T: HasAfEnum + ImplicitPromote<i32>,
i32: HasAfEnum + ImplicitPromote<T>,
<T as ImplicitPromote<i32>>::Output: HasAfEnum,
[src]
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
[src]
impl<'f, T> Sub<u8> for &'f Array<T> where
T: HasAfEnum + ImplicitPromote<u8>,
u8: HasAfEnum + ImplicitPromote<T>,
<T as ImplicitPromote<u8>>::Output: HasAfEnum,
[src]
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
[src]
impl<T: HasAfEnum> Sub<u8> for Array<T> where
T: HasAfEnum + ImplicitPromote<u8>,
u8: HasAfEnum + ImplicitPromote<T>,
<T as ImplicitPromote<u8>>::Output: HasAfEnum,
[src]
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
[src]
impl<A, B> Sub<Array<B>> for Array<A> where
A: HasAfEnum + ImplicitPromote<B>,
B: HasAfEnum + ImplicitPromote<A>,
<A as ImplicitPromote<B>>::Output: HasAfEnum,
[src]
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
[src]
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,
[src]
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
[src]
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,
[src]
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
[src]
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,
[src]
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
[src]
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,
[src]
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
[src]
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,
[src]
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
[src]
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,
[src]
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
[src]
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,
[src]
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
[src]
impl<'f, T> Mul<f64> for &'f Array<T> where
T: HasAfEnum + ImplicitPromote<f64>,
f64: HasAfEnum + ImplicitPromote<T>,
<T as ImplicitPromote<f64>>::Output: HasAfEnum,
[src]
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
[src]
impl<T: HasAfEnum> Mul<f64> for Array<T> where
T: HasAfEnum + ImplicitPromote<f64>,
f64: HasAfEnum + ImplicitPromote<T>,
<T as ImplicitPromote<f64>>::Output: HasAfEnum,
[src]
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
[src]
impl<'f, T> Mul<f32> for &'f Array<T> where
T: HasAfEnum + ImplicitPromote<f32>,
f32: HasAfEnum + ImplicitPromote<T>,
<T as ImplicitPromote<f32>>::Output: HasAfEnum,
[src]
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
[src]
impl<T: HasAfEnum> Mul<f32> for Array<T> where
T: HasAfEnum + ImplicitPromote<f32>,
f32: HasAfEnum + ImplicitPromote<T>,
<T as ImplicitPromote<f32>>::Output: HasAfEnum,
[src]
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
[src]
impl<'f, T> Mul<u64> for &'f Array<T> where
T: HasAfEnum + ImplicitPromote<u64>,
u64: HasAfEnum + ImplicitPromote<T>,
<T as ImplicitPromote<u64>>::Output: HasAfEnum,
[src]
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
[src]
impl<T: HasAfEnum> Mul<u64> for Array<T> where
T: HasAfEnum + ImplicitPromote<u64>,
u64: HasAfEnum + ImplicitPromote<T>,
<T as ImplicitPromote<u64>>::Output: HasAfEnum,
[src]
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
[src]
impl<'f, T> Mul<i64> for &'f Array<T> where
T: HasAfEnum + ImplicitPromote<i64>,
i64: HasAfEnum + ImplicitPromote<T>,
<T as ImplicitPromote<i64>>::Output: HasAfEnum,
[src]
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
[src]
impl<T: HasAfEnum> Mul<i64> for Array<T> where
T: HasAfEnum + ImplicitPromote<i64>,
i64: HasAfEnum + ImplicitPromote<T>,
<T as ImplicitPromote<i64>>::Output: HasAfEnum,
[src]
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
[src]
impl<'f, T> Mul<u32> for &'f Array<T> where
T: HasAfEnum + ImplicitPromote<u32>,
u32: HasAfEnum + ImplicitPromote<T>,
<T as ImplicitPromote<u32>>::Output: HasAfEnum,
[src]
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
[src]
impl<T: HasAfEnum> Mul<u32> for Array<T> where
T: HasAfEnum + ImplicitPromote<u32>,
u32: HasAfEnum + ImplicitPromote<T>,
<T as ImplicitPromote<u32>>::Output: HasAfEnum,
[src]
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
[src]
impl<'f, T> Mul<i32> for &'f Array<T> where
T: HasAfEnum + ImplicitPromote<i32>,
i32: HasAfEnum + ImplicitPromote<T>,
<T as ImplicitPromote<i32>>::Output: HasAfEnum,
[src]
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
[src]
impl<T: HasAfEnum> Mul<i32> for Array<T> where
T: HasAfEnum + ImplicitPromote<i32>,
i32: HasAfEnum + ImplicitPromote<T>,
<T as ImplicitPromote<i32>>::Output: HasAfEnum,
[src]
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
[src]
impl<'f, T> Mul<u8> for &'f Array<T> where
T: HasAfEnum + ImplicitPromote<u8>,
u8: HasAfEnum + ImplicitPromote<T>,
<T as ImplicitPromote<u8>>::Output: HasAfEnum,
[src]
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
[src]
impl<T: HasAfEnum> Mul<u8> for Array<T> where
T: HasAfEnum + ImplicitPromote<u8>,
u8: HasAfEnum + ImplicitPromote<T>,
<T as ImplicitPromote<u8>>::Output: HasAfEnum,
[src]
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
[src]
impl<A, B> Mul<Array<B>> for Array<A> where
A: HasAfEnum + ImplicitPromote<B>,
B: HasAfEnum + ImplicitPromote<A>,
<A as ImplicitPromote<B>>::Output: HasAfEnum,
[src]
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
[src]
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,
[src]
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
[src]
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,
[src]
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
[src]
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,
[src]
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
[src]
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,
[src]
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
[src]
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,
[src]
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
[src]
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,
[src]
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
[src]
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,
[src]
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
[src]
impl<'f, T> Div<f64> for &'f Array<T> where
T: HasAfEnum + ImplicitPromote<f64>,
f64: HasAfEnum + ImplicitPromote<T>,
<T as ImplicitPromote<f64>>::Output: HasAfEnum,
[src]
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
[src]
impl<T: HasAfEnum> Div<f64> for Array<T> where
T: HasAfEnum + ImplicitPromote<f64>,
f64: HasAfEnum + ImplicitPromote<T>,
<T as ImplicitPromote<f64>>::Output: HasAfEnum,
[src]
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
[src]
impl<'f, T> Div<f32> for &'f Array<T> where
T: HasAfEnum + ImplicitPromote<f32>,
f32: HasAfEnum + ImplicitPromote<T>,
<T as ImplicitPromote<f32>>::Output: HasAfEnum,
[src]
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
[src]
impl<T: HasAfEnum> Div<f32> for Array<T> where
T: HasAfEnum + ImplicitPromote<f32>,
f32: HasAfEnum + ImplicitPromote<T>,
<T as ImplicitPromote<f32>>::Output: HasAfEnum,
[src]
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
[src]
impl<'f, T> Div<u64> for &'f Array<T> where
T: HasAfEnum + ImplicitPromote<u64>,
u64: HasAfEnum + ImplicitPromote<T>,
<T as ImplicitPromote<u64>>::Output: HasAfEnum,
[src]
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
[src]
impl<T: HasAfEnum> Div<u64> for Array<T> where
T: HasAfEnum + ImplicitPromote<u64>,
u64: HasAfEnum + ImplicitPromote<T>,
<T as ImplicitPromote<u64>>::Output: HasAfEnum,
[src]
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
[src]
impl<'f, T> Div<i64> for &'f Array<T> where
T: HasAfEnum + ImplicitPromote<i64>,
i64: HasAfEnum + ImplicitPromote<T>,
<T as ImplicitPromote<i64>>::Output: HasAfEnum,
[src]
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
[src]
impl<T: HasAfEnum> Div<i64> for Array<T> where
T: HasAfEnum + ImplicitPromote<i64>,
i64: HasAfEnum + ImplicitPromote<T>,
<T as ImplicitPromote<i64>>::Output: HasAfEnum,
[src]
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
[src]
impl<'f, T> Div<u32> for &'f Array<T> where
T: HasAfEnum + ImplicitPromote<u32>,
u32: HasAfEnum + ImplicitPromote<T>,
<T as ImplicitPromote<u32>>::Output: HasAfEnum,
[src]
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
[src]
impl<T: HasAfEnum> Div<u32> for Array<T> where
T: HasAfEnum + ImplicitPromote<u32>,
u32: HasAfEnum + ImplicitPromote<T>,
<T as ImplicitPromote<u32>>::Output: HasAfEnum,
[src]
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
[src]
impl<'f, T> Div<i32> for &'f Array<T> where
T: HasAfEnum + ImplicitPromote<i32>,
i32: HasAfEnum + ImplicitPromote<T>,
<T as ImplicitPromote<i32>>::Output: HasAfEnum,
[src]
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
[src]
impl<T: HasAfEnum> Div<i32> for Array<T> where
T: HasAfEnum + ImplicitPromote<i32>,
i32: HasAfEnum + ImplicitPromote<T>,
<T as ImplicitPromote<i32>>::Output: HasAfEnum,
[src]
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
[src]
impl<'f, T> Div<u8> for &'f Array<T> where
T: HasAfEnum + ImplicitPromote<u8>,
u8: HasAfEnum + ImplicitPromote<T>,
<T as ImplicitPromote<u8>>::Output: HasAfEnum,
[src]
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
[src]
impl<T: HasAfEnum> Div<u8> for Array<T> where
T: HasAfEnum + ImplicitPromote<u8>,
u8: HasAfEnum + ImplicitPromote<T>,
<T as ImplicitPromote<u8>>::Output: HasAfEnum,
[src]
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
[src]
impl<A, B> Div<Array<B>> for Array<A> where
A: HasAfEnum + ImplicitPromote<B>,
B: HasAfEnum + ImplicitPromote<A>,
<A as ImplicitPromote<B>>::Output: HasAfEnum,
[src]
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
[src]
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,
[src]
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
[src]
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,
[src]
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
[src]
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,
[src]
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
[src]
impl<A, B> Rem<Array<B>> for Array<A> where
A: HasAfEnum + ImplicitPromote<B>,
B: HasAfEnum + ImplicitPromote<A>,
<A as ImplicitPromote<B>>::Output: HasAfEnum,
[src]
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
[src]
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,
[src]
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
[src]
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,
[src]
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
[src]
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,
[src]
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
[src]
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,
[src]
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
[src]
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,
[src]
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>)
[src]
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,
[src]
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>)
[src]
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,
[src]
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>)
[src]
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,
[src]
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>)
[src]
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,
[src]
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>)
[src]
impl<'f, T> Not for &'f Array<T> where
T: HasAfEnum,
[src]
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
[src]
impl<A, B> BitAnd<Array<B>> for Array<A> where
A: HasAfEnum + ImplicitPromote<B>,
B: HasAfEnum + ImplicitPromote<A>,
<A as ImplicitPromote<B>>::Output: HasAfEnum,
[src]
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
[src]
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,
[src]
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
[src]
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,
[src]
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
[src]
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,
[src]
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
[src]
impl<A, B> BitOr<Array<B>> for Array<A> where
A: HasAfEnum + ImplicitPromote<B>,
B: HasAfEnum + ImplicitPromote<A>,
<A as ImplicitPromote<B>>::Output: HasAfEnum,
[src]
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
[src]
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,
[src]
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
[src]
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,
[src]
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
[src]
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,
[src]
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
[src]
impl<A, B> BitXor<Array<B>> for Array<A> where
A: HasAfEnum + ImplicitPromote<B>,
B: HasAfEnum + ImplicitPromote<A>,
<A as ImplicitPromote<B>>::Output: HasAfEnum,
[src]
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
[src]
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,
[src]
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
[src]
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,
[src]
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
[src]
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,
[src]
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
[src]
impl<A, B> Shl<Array<B>> for Array<A> where
A: HasAfEnum + ImplicitPromote<B>,
B: HasAfEnum + ImplicitPromote<A>,
<A as ImplicitPromote<B>>::Output: HasAfEnum,
[src]
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
[src]
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,
[src]
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
[src]
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,
[src]
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
[src]
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,
[src]
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
[src]
impl<A, B> Shr<Array<B>> for Array<A> where
A: HasAfEnum + ImplicitPromote<B>,
B: HasAfEnum + ImplicitPromote<A>,
<A as ImplicitPromote<B>>::Output: HasAfEnum,
[src]
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
[src]
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,
[src]
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
[src]
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,
[src]
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
[src]
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,
[src]
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
[src]
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,
[src]
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>)
[src]
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,
[src]
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>)
[src]
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,
[src]
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>)
[src]
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,
[src]
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>)
[src]
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,
[src]
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>)
[src]
Auto Trait Implementations
Blanket Implementations
impl<T> From<T> for T
[src]
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
fn to_owned(&self) -> T
[src]
fn clone_into(&self, target: &mut T)
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T, Rhs, Output> NumOps<Rhs, Output> for T where
T: Sub<Rhs, Output = Output> + Mul<Rhs, Output = Output> + Div<Rhs, Output = Output> + Add<Rhs, Output = Output> + Rem<Rhs, Output = Output>,
[src]
T: Sub<Rhs, Output = Output> + Mul<Rhs, Output = Output> + Div<Rhs, Output = Output> + Add<Rhs, Output = Output> + Rem<Rhs, Output = Output>,
impl<T, Rhs> NumAssignOps<Rhs> for T where
T: AddAssign<Rhs> + SubAssign<Rhs> + MulAssign<Rhs> + DivAssign<Rhs> + RemAssign<Rhs>,
[src]
T: AddAssign<Rhs> + SubAssign<Rhs> + MulAssign<Rhs> + DivAssign<Rhs> + RemAssign<Rhs>,
impl<T, Base> RefNum<Base> for T where
T: NumOps<Base, Base> + NumOps<&'r Base, Base>,
[src]
T: NumOps<Base, Base> + NumOps<&'r Base, Base>,