[−][src]Struct numeric_array::NumericArray
A numeric wrapper for a GenericArray
, allowing for easy numerical operations
on the whole sequence.
This has the added bonus of allowing SIMD optimizations for almost all operations
when compiled with RUSTFLAGS = "-C opt-level=3 -C target-cpu=native"
For example, adding together four-element NumericArray
's will result
in a single SIMD instruction for all elements at once.
Implementations
impl<T, N: ArrayLength<T>> NumericArray<T, N>
[src]
pub fn new(arr: GenericArray<T, N>) -> NumericArray<T, N>
[src]
Creates a new NumericArray
instance from a GenericArray
instance.
Example:
#[macro_use] extern crate generic_array; extern crate numeric_array; use numeric_array::NumericArray; fn main() { let arr = NumericArray::new(arr![i32; 1, 2, 3, 4]); println!("{:?}", arr); // Prints 'NumericArray([1, 2, 3, 4])' }
pub fn splat(t: T) -> NumericArray<T, N> where
T: Clone,
[src]
T: Clone,
Creates a new array filled with a single value.
Example:
let a = NumericArray::new(arr![i32; 5, 5, 5, 5]); let b = NumericArray::splat(5); assert_eq!(a, b);
pub fn convert<U: From<T>>(self) -> NumericArray<U, N> where
N: ArrayLength<U>,
[src]
N: ArrayLength<U>,
Convert all elements of the NumericArray
to another NumericArray
using From
pub fn into_array(self) -> GenericArray<T, N>
[src]
Consumes self and returns the internal GenericArray
instance
pub fn as_array(&self) -> &GenericArray<T, N>
[src]
Get reference to underlying GenericArray
instance.
pub fn as_mut_array(&mut self) -> &mut GenericArray<T, N>
[src]
Get mutable reference to underlying GenericArray
instance.
pub fn as_slice(&self) -> &[T]
[src]
Extracts a slice containing the entire array.
pub fn as_mut_slice(&mut self) -> &mut [T]
[src]
Extracts a mutable slice containing the entire array.
pub fn from_slice(slice: &[T]) -> &NumericArray<T, N>
[src]
Converts slice to a numeric array reference with inferred length;
Length of the slice must be equal to the length of the array.
pub fn from_mut_slice(slice: &mut [T]) -> &mut NumericArray<T, N>
[src]
Converts mutable slice to a mutable numeric array reference
Length of the slice must be equal to the length of the array.
impl<T, N: ArrayLength<T>> NumericArray<T, N>
[src]
pub fn offset<V: ArrayLength<T>, O: ArrayLength<T>>(
&self
) -> &NumericArray<T, V> where
N: Sub<O>,
Diff<N, O>: IsGreaterOrEqual<V, Output = True>,
[src]
&self
) -> &NumericArray<T, V> where
N: Sub<O>,
Diff<N, O>: IsGreaterOrEqual<V, Output = True>,
Offset the numeric array and cast it into a shorter array
pub fn offset_mut<V: ArrayLength<T>, O: ArrayLength<T>>(
&mut self
) -> &mut NumericArray<T, V> where
N: Sub<O>,
Diff<N, O>: IsGreaterOrEqual<V, Output = True>,
[src]
&mut self
) -> &mut NumericArray<T, V> where
N: Sub<O>,
Diff<N, O>: IsGreaterOrEqual<V, Output = True>,
Offset the numeric array and cast it into a shorter array
Trait Implementations
impl<'a, T: Clone, U: Clone, N: ArrayLength<T>> Add<&'a NumericArray<T, N>> for NumericConstant<U> where
U: Add<T>,
N: ArrayLength<<U as Add<T>>::Output>,
[src]
U: Add<T>,
N: ArrayLength<<U as Add<T>>::Output>,
type Output = NumericArray<<U as Add<T>>::Output, N>
The resulting type after applying the +
operator.
fn add(self, rhs: &'a NumericArray<T, N>) -> Self::Output
[src]
impl<'a, T, U: Clone, N: ArrayLength<T> + ArrayLength<U>> Add<&'a NumericArray<U, N>> for NumericArray<T, N> where
T: Add<U>,
N: ArrayLength<<T as Add<U>>::Output>,
[src]
T: Add<U>,
N: ArrayLength<<T as Add<U>>::Output>,
type Output = NumericArray<<T as Add<U>>::Output, N>
The resulting type after applying the +
operator.
fn add(self, rhs: &'a NumericArray<U, N>) -> Self::Output
[src]
impl<'a, 'b, T: Clone, U: Clone, N: ArrayLength<T> + ArrayLength<U>> Add<&'b NumericArray<U, N>> for &'a NumericArray<T, N> where
T: Add<U>,
N: ArrayLength<<T as Add<U>>::Output>,
[src]
T: Add<U>,
N: ArrayLength<<T as Add<U>>::Output>,
type Output = NumericArray<<T as Add<U>>::Output, N>
The resulting type after applying the +
operator.
fn add(self, rhs: &'b NumericArray<U, N>) -> Self::Output
[src]
impl<T, U: Clone, N: ArrayLength<T>> Add<NumericArray<T, N>> for NumericConstant<U> where
U: Add<T>,
N: ArrayLength<<U as Add<T>>::Output>,
[src]
U: Add<T>,
N: ArrayLength<<U as Add<T>>::Output>,
type Output = NumericArray<<U as Add<T>>::Output, N>
The resulting type after applying the +
operator.
fn add(self, rhs: NumericArray<T, N>) -> Self::Output
[src]
impl<T, U, N: ArrayLength<T> + ArrayLength<U>> Add<NumericArray<U, N>> for NumericArray<T, N> where
T: Add<U>,
N: ArrayLength<<T as Add<U>>::Output>,
[src]
T: Add<U>,
N: ArrayLength<<T as Add<U>>::Output>,
type Output = NumericArray<<T as Add<U>>::Output, N>
The resulting type after applying the +
operator.
fn add(self, rhs: NumericArray<U, N>) -> Self::Output
[src]
impl<'a, T: Clone, U, N: ArrayLength<T> + ArrayLength<U>> Add<NumericArray<U, N>> for &'a NumericArray<T, N> where
T: Add<U>,
N: ArrayLength<<T as Add<U>>::Output>,
[src]
T: Add<U>,
N: ArrayLength<<T as Add<U>>::Output>,
type Output = NumericArray<<T as Add<U>>::Output, N>
The resulting type after applying the +
operator.
fn add(self, rhs: NumericArray<U, N>) -> Self::Output
[src]
impl<T, U: Clone, N: ArrayLength<T>> Add<NumericConstant<U>> for NumericArray<T, N> where
T: Add<U>,
N: ArrayLength<<T as Add<U>>::Output>,
[src]
T: Add<U>,
N: ArrayLength<<T as Add<U>>::Output>,
type Output = NumericArray<<T as Add<U>>::Output, N>
The resulting type after applying the +
operator.
fn add(self, rhs: NumericConstant<U>) -> Self::Output
[src]
impl<'a, T: Clone, U: Clone, N: ArrayLength<T>> Add<NumericConstant<U>> for &'a NumericArray<T, N> where
T: Add<U>,
N: ArrayLength<<T as Add<U>>::Output>,
[src]
T: Add<U>,
N: ArrayLength<<T as Add<U>>::Output>,
type Output = NumericArray<<T as Add<U>>::Output, N>
The resulting type after applying the +
operator.
fn add(self, rhs: NumericConstant<U>) -> Self::Output
[src]
impl<'a, T, U: Clone, N: ArrayLength<T> + ArrayLength<U>> AddAssign<&'a NumericArray<U, N>> for NumericArray<T, N> where
T: AddAssign<U>,
[src]
T: AddAssign<U>,
fn add_assign(&mut self, rhs: &'a NumericArray<U, N>)
[src]
impl<T, U, N: ArrayLength<T> + ArrayLength<U>> AddAssign<NumericArray<U, N>> for NumericArray<T, N> where
T: AddAssign<U>,
[src]
T: AddAssign<U>,
fn add_assign(&mut self, rhs: NumericArray<U, N>)
[src]
impl<T, U: Clone, N: ArrayLength<T>> AddAssign<NumericConstant<U>> for NumericArray<T, N> where
T: AddAssign<U>,
[src]
T: AddAssign<U>,
fn add_assign(&mut self, rhs: NumericConstant<U>)
[src]
impl<T, N: ArrayLength<T>> AsMut<[T]> for NumericArray<T, N>
[src]
impl<T, N: ArrayLength<T>> AsRef<[T]> for NumericArray<T, N>
[src]
impl<'a, T: Clone, U: Clone, N: ArrayLength<T>> BitAnd<&'a NumericArray<T, N>> for NumericConstant<U> where
U: BitAnd<T>,
N: ArrayLength<<U as BitAnd<T>>::Output>,
[src]
U: BitAnd<T>,
N: ArrayLength<<U as BitAnd<T>>::Output>,
type Output = NumericArray<<U as BitAnd<T>>::Output, N>
The resulting type after applying the &
operator.
fn bitand(self, rhs: &'a NumericArray<T, N>) -> Self::Output
[src]
impl<'a, T, U: Clone, N: ArrayLength<T> + ArrayLength<U>> BitAnd<&'a NumericArray<U, N>> for NumericArray<T, N> where
T: BitAnd<U>,
N: ArrayLength<<T as BitAnd<U>>::Output>,
[src]
T: BitAnd<U>,
N: ArrayLength<<T as BitAnd<U>>::Output>,
type Output = NumericArray<<T as BitAnd<U>>::Output, N>
The resulting type after applying the &
operator.
fn bitand(self, rhs: &'a NumericArray<U, N>) -> Self::Output
[src]
impl<'a, 'b, T: Clone, U: Clone, N: ArrayLength<T> + ArrayLength<U>> BitAnd<&'b NumericArray<U, N>> for &'a NumericArray<T, N> where
T: BitAnd<U>,
N: ArrayLength<<T as BitAnd<U>>::Output>,
[src]
T: BitAnd<U>,
N: ArrayLength<<T as BitAnd<U>>::Output>,
type Output = NumericArray<<T as BitAnd<U>>::Output, N>
The resulting type after applying the &
operator.
fn bitand(self, rhs: &'b NumericArray<U, N>) -> Self::Output
[src]
impl<T, U: Clone, N: ArrayLength<T>> BitAnd<NumericArray<T, N>> for NumericConstant<U> where
U: BitAnd<T>,
N: ArrayLength<<U as BitAnd<T>>::Output>,
[src]
U: BitAnd<T>,
N: ArrayLength<<U as BitAnd<T>>::Output>,
type Output = NumericArray<<U as BitAnd<T>>::Output, N>
The resulting type after applying the &
operator.
fn bitand(self, rhs: NumericArray<T, N>) -> Self::Output
[src]
impl<T, U, N: ArrayLength<T> + ArrayLength<U>> BitAnd<NumericArray<U, N>> for NumericArray<T, N> where
T: BitAnd<U>,
N: ArrayLength<<T as BitAnd<U>>::Output>,
[src]
T: BitAnd<U>,
N: ArrayLength<<T as BitAnd<U>>::Output>,
type Output = NumericArray<<T as BitAnd<U>>::Output, N>
The resulting type after applying the &
operator.
fn bitand(self, rhs: NumericArray<U, N>) -> Self::Output
[src]
impl<'a, T: Clone, U, N: ArrayLength<T> + ArrayLength<U>> BitAnd<NumericArray<U, N>> for &'a NumericArray<T, N> where
T: BitAnd<U>,
N: ArrayLength<<T as BitAnd<U>>::Output>,
[src]
T: BitAnd<U>,
N: ArrayLength<<T as BitAnd<U>>::Output>,
type Output = NumericArray<<T as BitAnd<U>>::Output, N>
The resulting type after applying the &
operator.
fn bitand(self, rhs: NumericArray<U, N>) -> Self::Output
[src]
impl<T, U: Clone, N: ArrayLength<T>> BitAnd<NumericConstant<U>> for NumericArray<T, N> where
T: BitAnd<U>,
N: ArrayLength<<T as BitAnd<U>>::Output>,
[src]
T: BitAnd<U>,
N: ArrayLength<<T as BitAnd<U>>::Output>,
type Output = NumericArray<<T as BitAnd<U>>::Output, N>
The resulting type after applying the &
operator.
fn bitand(self, rhs: NumericConstant<U>) -> Self::Output
[src]
impl<'a, T: Clone, U: Clone, N: ArrayLength<T>> BitAnd<NumericConstant<U>> for &'a NumericArray<T, N> where
T: BitAnd<U>,
N: ArrayLength<<T as BitAnd<U>>::Output>,
[src]
T: BitAnd<U>,
N: ArrayLength<<T as BitAnd<U>>::Output>,
type Output = NumericArray<<T as BitAnd<U>>::Output, N>
The resulting type after applying the &
operator.
fn bitand(self, rhs: NumericConstant<U>) -> Self::Output
[src]
impl<'a, T, U: Clone, N: ArrayLength<T> + ArrayLength<U>> BitAndAssign<&'a NumericArray<U, N>> for NumericArray<T, N> where
T: BitAndAssign<U>,
[src]
T: BitAndAssign<U>,
fn bitand_assign(&mut self, rhs: &'a NumericArray<U, N>)
[src]
impl<T, U, N: ArrayLength<T> + ArrayLength<U>> BitAndAssign<NumericArray<U, N>> for NumericArray<T, N> where
T: BitAndAssign<U>,
[src]
T: BitAndAssign<U>,
fn bitand_assign(&mut self, rhs: NumericArray<U, N>)
[src]
impl<T, U: Clone, N: ArrayLength<T>> BitAndAssign<NumericConstant<U>> for NumericArray<T, N> where
T: BitAndAssign<U>,
[src]
T: BitAndAssign<U>,
fn bitand_assign(&mut self, rhs: NumericConstant<U>)
[src]
impl<'a, T: Clone, U: Clone, N: ArrayLength<T>> BitOr<&'a NumericArray<T, N>> for NumericConstant<U> where
U: BitOr<T>,
N: ArrayLength<<U as BitOr<T>>::Output>,
[src]
U: BitOr<T>,
N: ArrayLength<<U as BitOr<T>>::Output>,
type Output = NumericArray<<U as BitOr<T>>::Output, N>
The resulting type after applying the |
operator.
fn bitor(self, rhs: &'a NumericArray<T, N>) -> Self::Output
[src]
impl<'a, T, U: Clone, N: ArrayLength<T> + ArrayLength<U>> BitOr<&'a NumericArray<U, N>> for NumericArray<T, N> where
T: BitOr<U>,
N: ArrayLength<<T as BitOr<U>>::Output>,
[src]
T: BitOr<U>,
N: ArrayLength<<T as BitOr<U>>::Output>,
type Output = NumericArray<<T as BitOr<U>>::Output, N>
The resulting type after applying the |
operator.
fn bitor(self, rhs: &'a NumericArray<U, N>) -> Self::Output
[src]
impl<'a, 'b, T: Clone, U: Clone, N: ArrayLength<T> + ArrayLength<U>> BitOr<&'b NumericArray<U, N>> for &'a NumericArray<T, N> where
T: BitOr<U>,
N: ArrayLength<<T as BitOr<U>>::Output>,
[src]
T: BitOr<U>,
N: ArrayLength<<T as BitOr<U>>::Output>,
type Output = NumericArray<<T as BitOr<U>>::Output, N>
The resulting type after applying the |
operator.
fn bitor(self, rhs: &'b NumericArray<U, N>) -> Self::Output
[src]
impl<T, U: Clone, N: ArrayLength<T>> BitOr<NumericArray<T, N>> for NumericConstant<U> where
U: BitOr<T>,
N: ArrayLength<<U as BitOr<T>>::Output>,
[src]
U: BitOr<T>,
N: ArrayLength<<U as BitOr<T>>::Output>,
type Output = NumericArray<<U as BitOr<T>>::Output, N>
The resulting type after applying the |
operator.
fn bitor(self, rhs: NumericArray<T, N>) -> Self::Output
[src]
impl<T, U, N: ArrayLength<T> + ArrayLength<U>> BitOr<NumericArray<U, N>> for NumericArray<T, N> where
T: BitOr<U>,
N: ArrayLength<<T as BitOr<U>>::Output>,
[src]
T: BitOr<U>,
N: ArrayLength<<T as BitOr<U>>::Output>,
type Output = NumericArray<<T as BitOr<U>>::Output, N>
The resulting type after applying the |
operator.
fn bitor(self, rhs: NumericArray<U, N>) -> Self::Output
[src]
impl<'a, T: Clone, U, N: ArrayLength<T> + ArrayLength<U>> BitOr<NumericArray<U, N>> for &'a NumericArray<T, N> where
T: BitOr<U>,
N: ArrayLength<<T as BitOr<U>>::Output>,
[src]
T: BitOr<U>,
N: ArrayLength<<T as BitOr<U>>::Output>,
type Output = NumericArray<<T as BitOr<U>>::Output, N>
The resulting type after applying the |
operator.
fn bitor(self, rhs: NumericArray<U, N>) -> Self::Output
[src]
impl<T, U: Clone, N: ArrayLength<T>> BitOr<NumericConstant<U>> for NumericArray<T, N> where
T: BitOr<U>,
N: ArrayLength<<T as BitOr<U>>::Output>,
[src]
T: BitOr<U>,
N: ArrayLength<<T as BitOr<U>>::Output>,
type Output = NumericArray<<T as BitOr<U>>::Output, N>
The resulting type after applying the |
operator.
fn bitor(self, rhs: NumericConstant<U>) -> Self::Output
[src]
impl<'a, T: Clone, U: Clone, N: ArrayLength<T>> BitOr<NumericConstant<U>> for &'a NumericArray<T, N> where
T: BitOr<U>,
N: ArrayLength<<T as BitOr<U>>::Output>,
[src]
T: BitOr<U>,
N: ArrayLength<<T as BitOr<U>>::Output>,
type Output = NumericArray<<T as BitOr<U>>::Output, N>
The resulting type after applying the |
operator.
fn bitor(self, rhs: NumericConstant<U>) -> Self::Output
[src]
impl<'a, T, U: Clone, N: ArrayLength<T> + ArrayLength<U>> BitOrAssign<&'a NumericArray<U, N>> for NumericArray<T, N> where
T: BitOrAssign<U>,
[src]
T: BitOrAssign<U>,
fn bitor_assign(&mut self, rhs: &'a NumericArray<U, N>)
[src]
impl<T, U, N: ArrayLength<T> + ArrayLength<U>> BitOrAssign<NumericArray<U, N>> for NumericArray<T, N> where
T: BitOrAssign<U>,
[src]
T: BitOrAssign<U>,
fn bitor_assign(&mut self, rhs: NumericArray<U, N>)
[src]
impl<T, U: Clone, N: ArrayLength<T>> BitOrAssign<NumericConstant<U>> for NumericArray<T, N> where
T: BitOrAssign<U>,
[src]
T: BitOrAssign<U>,
fn bitor_assign(&mut self, rhs: NumericConstant<U>)
[src]
impl<'a, T: Clone, U: Clone, N: ArrayLength<T>> BitXor<&'a NumericArray<T, N>> for NumericConstant<U> where
U: BitXor<T>,
N: ArrayLength<<U as BitXor<T>>::Output>,
[src]
U: BitXor<T>,
N: ArrayLength<<U as BitXor<T>>::Output>,
type Output = NumericArray<<U as BitXor<T>>::Output, N>
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: &'a NumericArray<T, N>) -> Self::Output
[src]
impl<'a, T, U: Clone, N: ArrayLength<T> + ArrayLength<U>> BitXor<&'a NumericArray<U, N>> for NumericArray<T, N> where
T: BitXor<U>,
N: ArrayLength<<T as BitXor<U>>::Output>,
[src]
T: BitXor<U>,
N: ArrayLength<<T as BitXor<U>>::Output>,
type Output = NumericArray<<T as BitXor<U>>::Output, N>
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: &'a NumericArray<U, N>) -> Self::Output
[src]
impl<'a, 'b, T: Clone, U: Clone, N: ArrayLength<T> + ArrayLength<U>> BitXor<&'b NumericArray<U, N>> for &'a NumericArray<T, N> where
T: BitXor<U>,
N: ArrayLength<<T as BitXor<U>>::Output>,
[src]
T: BitXor<U>,
N: ArrayLength<<T as BitXor<U>>::Output>,
type Output = NumericArray<<T as BitXor<U>>::Output, N>
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: &'b NumericArray<U, N>) -> Self::Output
[src]
impl<T, U: Clone, N: ArrayLength<T>> BitXor<NumericArray<T, N>> for NumericConstant<U> where
U: BitXor<T>,
N: ArrayLength<<U as BitXor<T>>::Output>,
[src]
U: BitXor<T>,
N: ArrayLength<<U as BitXor<T>>::Output>,
type Output = NumericArray<<U as BitXor<T>>::Output, N>
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: NumericArray<T, N>) -> Self::Output
[src]
impl<T, U, N: ArrayLength<T> + ArrayLength<U>> BitXor<NumericArray<U, N>> for NumericArray<T, N> where
T: BitXor<U>,
N: ArrayLength<<T as BitXor<U>>::Output>,
[src]
T: BitXor<U>,
N: ArrayLength<<T as BitXor<U>>::Output>,
type Output = NumericArray<<T as BitXor<U>>::Output, N>
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: NumericArray<U, N>) -> Self::Output
[src]
impl<'a, T: Clone, U, N: ArrayLength<T> + ArrayLength<U>> BitXor<NumericArray<U, N>> for &'a NumericArray<T, N> where
T: BitXor<U>,
N: ArrayLength<<T as BitXor<U>>::Output>,
[src]
T: BitXor<U>,
N: ArrayLength<<T as BitXor<U>>::Output>,
type Output = NumericArray<<T as BitXor<U>>::Output, N>
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: NumericArray<U, N>) -> Self::Output
[src]
impl<T, U: Clone, N: ArrayLength<T>> BitXor<NumericConstant<U>> for NumericArray<T, N> where
T: BitXor<U>,
N: ArrayLength<<T as BitXor<U>>::Output>,
[src]
T: BitXor<U>,
N: ArrayLength<<T as BitXor<U>>::Output>,
type Output = NumericArray<<T as BitXor<U>>::Output, N>
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: NumericConstant<U>) -> Self::Output
[src]
impl<'a, T: Clone, U: Clone, N: ArrayLength<T>> BitXor<NumericConstant<U>> for &'a NumericArray<T, N> where
T: BitXor<U>,
N: ArrayLength<<T as BitXor<U>>::Output>,
[src]
T: BitXor<U>,
N: ArrayLength<<T as BitXor<U>>::Output>,
type Output = NumericArray<<T as BitXor<U>>::Output, N>
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: NumericConstant<U>) -> Self::Output
[src]
impl<'a, T, U: Clone, N: ArrayLength<T> + ArrayLength<U>> BitXorAssign<&'a NumericArray<U, N>> for NumericArray<T, N> where
T: BitXorAssign<U>,
[src]
T: BitXorAssign<U>,
fn bitxor_assign(&mut self, rhs: &'a NumericArray<U, N>)
[src]
impl<T, U, N: ArrayLength<T> + ArrayLength<U>> BitXorAssign<NumericArray<U, N>> for NumericArray<T, N> where
T: BitXorAssign<U>,
[src]
T: BitXorAssign<U>,
fn bitxor_assign(&mut self, rhs: NumericArray<U, N>)
[src]
impl<T, U: Clone, N: ArrayLength<T>> BitXorAssign<NumericConstant<U>> for NumericArray<T, N> where
T: BitXorAssign<U>,
[src]
T: BitXorAssign<U>,
fn bitxor_assign(&mut self, rhs: NumericConstant<U>)
[src]
impl<T, N: ArrayLength<T>> Borrow<[T]> for NumericArray<T, N>
[src]
impl<T, N: ArrayLength<T>> BorrowMut<[T]> for NumericArray<T, N>
[src]
fn borrow_mut(&mut self) -> &mut [T]
[src]
impl<T, N: ArrayLength<T>> Bounded for NumericArray<T, N> where
T: Bounded,
[src]
T: Bounded,
impl<T, N: ArrayLength<T>> CheckedAdd for NumericArray<T, N> where
T: CheckedAdd,
[src]
T: CheckedAdd,
fn checked_add(&self, rhs: &Self) -> Option<Self>
[src]
impl<T, N: ArrayLength<T>> CheckedDiv for NumericArray<T, N> where
T: CheckedDiv,
[src]
T: CheckedDiv,
fn checked_div(&self, rhs: &Self) -> Option<Self>
[src]
impl<T, N: ArrayLength<T>> CheckedMul for NumericArray<T, N> where
T: CheckedMul,
[src]
T: CheckedMul,
fn checked_mul(&self, rhs: &Self) -> Option<Self>
[src]
impl<T, N: ArrayLength<T>> CheckedShl for NumericArray<T, N> where
T: CheckedShl,
Self: Shl<u32, Output = Self>,
[src]
T: CheckedShl,
Self: Shl<u32, Output = Self>,
fn checked_shl(&self, rhs: u32) -> Option<Self>
[src]
impl<T, N: ArrayLength<T>> CheckedShr for NumericArray<T, N> where
T: CheckedShr,
Self: Shr<u32, Output = Self>,
[src]
T: CheckedShr,
Self: Shr<u32, Output = Self>,
fn checked_shr(&self, rhs: u32) -> Option<Self>
[src]
impl<T, N: ArrayLength<T>> CheckedSub for NumericArray<T, N> where
T: CheckedSub,
[src]
T: CheckedSub,
fn checked_sub(&self, rhs: &Self) -> Option<Self>
[src]
impl<T: Clone, N: ArrayLength<T>> Clone for NumericArray<T, N>
[src]
fn clone(&self) -> NumericArray<T, N>
[src]
fn clone_from(&mut self, source: &Self)
1.0.0[src]
impl<T: Copy, N: ArrayLength<T>> Copy for NumericArray<T, N> where
N::ArrayType: Copy,
[src]
N::ArrayType: Copy,
impl<T: Debug, N: ArrayLength<T>> Debug for NumericArray<T, N>
[src]
impl<T, N: ArrayLength<T>> Default for NumericArray<T, N> where
T: Default,
[src]
T: Default,
impl<T, N: ArrayLength<T>> Deref for NumericArray<T, N>
[src]
impl<T, N: ArrayLength<T>> DerefMut for NumericArray<T, N>
[src]
impl<'a, T: Clone, U: Clone, N: ArrayLength<T>> Div<&'a NumericArray<T, N>> for NumericConstant<U> where
U: Div<T>,
N: ArrayLength<<U as Div<T>>::Output>,
[src]
U: Div<T>,
N: ArrayLength<<U as Div<T>>::Output>,
type Output = NumericArray<<U as Div<T>>::Output, N>
The resulting type after applying the /
operator.
fn div(self, rhs: &'a NumericArray<T, N>) -> Self::Output
[src]
impl<'a, T, U: Clone, N: ArrayLength<T> + ArrayLength<U>> Div<&'a NumericArray<U, N>> for NumericArray<T, N> where
T: Div<U>,
N: ArrayLength<<T as Div<U>>::Output>,
[src]
T: Div<U>,
N: ArrayLength<<T as Div<U>>::Output>,
type Output = NumericArray<<T as Div<U>>::Output, N>
The resulting type after applying the /
operator.
fn div(self, rhs: &'a NumericArray<U, N>) -> Self::Output
[src]
impl<'a, 'b, T: Clone, U: Clone, N: ArrayLength<T> + ArrayLength<U>> Div<&'b NumericArray<U, N>> for &'a NumericArray<T, N> where
T: Div<U>,
N: ArrayLength<<T as Div<U>>::Output>,
[src]
T: Div<U>,
N: ArrayLength<<T as Div<U>>::Output>,
type Output = NumericArray<<T as Div<U>>::Output, N>
The resulting type after applying the /
operator.
fn div(self, rhs: &'b NumericArray<U, N>) -> Self::Output
[src]
impl<T, U: Clone, N: ArrayLength<T>> Div<NumericArray<T, N>> for NumericConstant<U> where
U: Div<T>,
N: ArrayLength<<U as Div<T>>::Output>,
[src]
U: Div<T>,
N: ArrayLength<<U as Div<T>>::Output>,
type Output = NumericArray<<U as Div<T>>::Output, N>
The resulting type after applying the /
operator.
fn div(self, rhs: NumericArray<T, N>) -> Self::Output
[src]
impl<T, U, N: ArrayLength<T> + ArrayLength<U>> Div<NumericArray<U, N>> for NumericArray<T, N> where
T: Div<U>,
N: ArrayLength<<T as Div<U>>::Output>,
[src]
T: Div<U>,
N: ArrayLength<<T as Div<U>>::Output>,
type Output = NumericArray<<T as Div<U>>::Output, N>
The resulting type after applying the /
operator.
fn div(self, rhs: NumericArray<U, N>) -> Self::Output
[src]
impl<'a, T: Clone, U, N: ArrayLength<T> + ArrayLength<U>> Div<NumericArray<U, N>> for &'a NumericArray<T, N> where
T: Div<U>,
N: ArrayLength<<T as Div<U>>::Output>,
[src]
T: Div<U>,
N: ArrayLength<<T as Div<U>>::Output>,
type Output = NumericArray<<T as Div<U>>::Output, N>
The resulting type after applying the /
operator.
fn div(self, rhs: NumericArray<U, N>) -> Self::Output
[src]
impl<T, U: Clone, N: ArrayLength<T>> Div<NumericConstant<U>> for NumericArray<T, N> where
T: Div<U>,
N: ArrayLength<<T as Div<U>>::Output>,
[src]
T: Div<U>,
N: ArrayLength<<T as Div<U>>::Output>,
type Output = NumericArray<<T as Div<U>>::Output, N>
The resulting type after applying the /
operator.
fn div(self, rhs: NumericConstant<U>) -> Self::Output
[src]
impl<'a, T: Clone, U: Clone, N: ArrayLength<T>> Div<NumericConstant<U>> for &'a NumericArray<T, N> where
T: Div<U>,
N: ArrayLength<<T as Div<U>>::Output>,
[src]
T: Div<U>,
N: ArrayLength<<T as Div<U>>::Output>,
type Output = NumericArray<<T as Div<U>>::Output, N>
The resulting type after applying the /
operator.
fn div(self, rhs: NumericConstant<U>) -> Self::Output
[src]
impl<'a, T, U: Clone, N: ArrayLength<T> + ArrayLength<U>> DivAssign<&'a NumericArray<U, N>> for NumericArray<T, N> where
T: DivAssign<U>,
[src]
T: DivAssign<U>,
fn div_assign(&mut self, rhs: &'a NumericArray<U, N>)
[src]
impl<T, U, N: ArrayLength<T> + ArrayLength<U>> DivAssign<NumericArray<U, N>> for NumericArray<T, N> where
T: DivAssign<U>,
[src]
T: DivAssign<U>,
fn div_assign(&mut self, rhs: NumericArray<U, N>)
[src]
impl<T, U: Clone, N: ArrayLength<T>> DivAssign<NumericConstant<U>> for NumericArray<T, N> where
T: DivAssign<U>,
[src]
T: DivAssign<U>,
fn div_assign(&mut self, rhs: NumericConstant<U>)
[src]
impl<T, N: ArrayLength<T>> Eq for NumericArray<T, N> where
T: Eq,
[src]
T: Eq,
impl<T, N: ArrayLength<T>> Float for NumericArray<T, N> where
T: Float + Copy,
Self: Copy,
[src]
T: Float + Copy,
Self: Copy,
fn nan() -> Self
[src]
fn infinity() -> Self
[src]
fn neg_infinity() -> Self
[src]
fn neg_zero() -> Self
[src]
fn min_value() -> Self
[src]
fn min_positive_value() -> Self
[src]
fn max_value() -> Self
[src]
fn is_nan(self) -> bool
[src]
fn is_infinite(self) -> bool
[src]
fn is_finite(self) -> bool
[src]
fn is_normal(self) -> bool
[src]
fn classify(self) -> FpCategory
[src]
fn floor(self) -> Self
[src]
fn ceil(self) -> Self
[src]
fn round(self) -> Self
[src]
fn trunc(self) -> Self
[src]
fn fract(self) -> Self
[src]
fn abs(self) -> Self
[src]
fn signum(self) -> Self
[src]
fn is_sign_positive(self) -> bool
[src]
fn is_sign_negative(self) -> bool
[src]
fn mul_add(self, a: Self, b: Self) -> Self
[src]
fn recip(self) -> Self
[src]
fn powi(self, n: i32) -> Self
[src]
fn powf(self, n: Self) -> Self
[src]
fn sqrt(self) -> Self
[src]
fn exp(self) -> Self
[src]
fn exp2(self) -> Self
[src]
fn ln(self) -> Self
[src]
fn log(self, base: Self) -> Self
[src]
fn log2(self) -> Self
[src]
fn log10(self) -> Self
[src]
fn max(self, other: Self) -> Self
[src]
fn min(self, other: Self) -> Self
[src]
fn abs_sub(self, other: Self) -> Self
[src]
fn cbrt(self) -> Self
[src]
fn hypot(self, other: Self) -> Self
[src]
fn sin(self) -> Self
[src]
fn cos(self) -> Self
[src]
fn tan(self) -> Self
[src]
fn asin(self) -> Self
[src]
fn acos(self) -> Self
[src]
fn atan(self) -> Self
[src]
fn atan2(self, other: Self) -> Self
[src]
fn sin_cos(self) -> (Self, Self)
[src]
fn exp_m1(self) -> Self
[src]
fn ln_1p(self) -> Self
[src]
fn sinh(self) -> Self
[src]
fn cosh(self) -> Self
[src]
fn tanh(self) -> Self
[src]
fn asinh(self) -> Self
[src]
fn acosh(self) -> Self
[src]
fn atanh(self) -> Self
[src]
fn integer_decode(self) -> (u64, i16, i8)
[src]
fn epsilon() -> Self
[src]
fn to_degrees(self) -> Self
[src]
fn to_radians(self) -> Self
[src]
impl<T, N: ArrayLength<T>> FloatConst for NumericArray<T, N> where
T: FloatConst,
[src]
T: FloatConst,
fn E() -> Self
[src]
fn FRAC_1_PI() -> Self
[src]
fn FRAC_1_SQRT_2() -> Self
[src]
fn FRAC_2_PI() -> Self
[src]
fn FRAC_2_SQRT_PI() -> Self
[src]
fn FRAC_PI_2() -> Self
[src]
fn FRAC_PI_3() -> Self
[src]
fn FRAC_PI_4() -> Self
[src]
fn FRAC_PI_6() -> Self
[src]
fn FRAC_PI_8() -> Self
[src]
fn LN_10() -> Self
[src]
fn LN_2() -> Self
[src]
fn LOG10_E() -> Self
[src]
fn LOG2_E() -> Self
[src]
fn PI() -> Self
[src]
fn SQRT_2() -> Self
[src]
fn TAU() -> Self where
Self: Add<Self, Output = Self>,
[src]
Self: Add<Self, Output = Self>,
fn LOG10_2() -> Self where
Self: Div<Self, Output = Self>,
[src]
Self: Div<Self, Output = Self>,
fn LOG2_10() -> Self where
Self: Div<Self, Output = Self>,
[src]
Self: Div<Self, Output = Self>,
impl<'a, T, N: ArrayLength<T>> From<&'a [T]> for &'a NumericArray<T, N>
[src]
fn from(slice: &[T]) -> &NumericArray<T, N>
[src]
Converts slice to a numeric array reference with inferred length;
Length of the slice must be equal to the length of the array.
impl<'a, T, N: ArrayLength<T>> From<&'a mut [T]> for &'a mut NumericArray<T, N>
[src]
fn from(slice: &mut [T]) -> &mut NumericArray<T, N>
[src]
Converts mutable slice to a mutable numeric array reference
Length of the slice must be equal to the length of the array.
impl<X, T, N: ArrayLength<T>> From<X> for NumericArray<T, N> where
X: Into<GenericArray<T, N>>,
[src]
X: Into<GenericArray<T, N>>,
fn from(x: X) -> NumericArray<T, N>
[src]
impl<T, N: ArrayLength<T>> FromIterator<T> for NumericArray<T, N>
[src]
fn from_iter<I>(iter: I) -> Self where
I: IntoIterator<Item = T>,
[src]
I: IntoIterator<Item = T>,
impl<T, N: ArrayLength<T>> GenericSequence<T> for NumericArray<T, N>
[src]
type Length = N
GenericArray
associated length
type Sequence = Self
Concrete sequence type used in conjuction with reference implementations of GenericSequence
fn generate<F>(f: F) -> Self where
F: FnMut(usize) -> T,
[src]
F: FnMut(usize) -> T,
impl<T, N: ArrayLength<T>> Geometric<T> for NumericArray<T, N> where
T: Add<Output = T> + Mul<Output = T> + Zero + Copy,
[src]
T: Add<Output = T> + Mul<Output = T> + Zero + Copy,
fn scalar_product(&self, other: &Self) -> T
[src]
fn abs_scalar_product(&self, other: &Self) -> T where
T: Signed,
[src]
T: Signed,
fn norm_squared(&self) -> T
[src]
impl<T, N: ArrayLength<T>> Index<Range<usize>> for NumericArray<T, N>
[src]
type Output = [T]
The returned type after indexing.
fn index(&self, index: Range<usize>) -> &[T]
[src]
impl<T, N: ArrayLength<T>> Index<RangeFrom<usize>> for NumericArray<T, N>
[src]
type Output = [T]
The returned type after indexing.
fn index(&self, index: RangeFrom<usize>) -> &[T]
[src]
impl<T, N: ArrayLength<T>> Index<RangeFull> for NumericArray<T, N>
[src]
impl<T, N: ArrayLength<T>> Index<RangeTo<usize>> for NumericArray<T, N>
[src]
type Output = [T]
The returned type after indexing.
fn index(&self, index: RangeTo<usize>) -> &[T]
[src]
impl<T, N: ArrayLength<T>> Index<usize> for NumericArray<T, N>
[src]
impl<T, N: ArrayLength<T>> IndexMut<Range<usize>> for NumericArray<T, N>
[src]
impl<T, N: ArrayLength<T>> IndexMut<RangeFrom<usize>> for NumericArray<T, N>
[src]
impl<T, N: ArrayLength<T>> IndexMut<RangeFull> for NumericArray<T, N>
[src]
impl<T, N: ArrayLength<T>> IndexMut<RangeTo<usize>> for NumericArray<T, N>
[src]
impl<T, N: ArrayLength<T>> IndexMut<usize> for NumericArray<T, N>
[src]
impl<'a, T, N: ArrayLength<T>> IntoIterator for &'a NumericArray<T, N>
[src]
type Item = &'a T
The type of the elements being iterated over.
type IntoIter = Iter<'a, T>
Which kind of iterator are we turning this into?
fn into_iter(self) -> Self::IntoIter
[src]
impl<'a, T, N: ArrayLength<T>> IntoIterator for &'a mut NumericArray<T, N>
[src]
type Item = &'a mut T
The type of the elements being iterated over.
type IntoIter = IterMut<'a, T>
Which kind of iterator are we turning this into?
fn into_iter(self) -> Self::IntoIter
[src]
impl<T, N: ArrayLength<T>> IntoIterator for NumericArray<T, N>
[src]
type Item = T
The type of the elements being iterated over.
type IntoIter = GenericArrayIter<T, N>
Which kind of iterator are we turning this into?
fn into_iter(self) -> Self::IntoIter
[src]
impl<T, N: ArrayLength<T>> Inv for NumericArray<T, N> where
T: Inv,
N: ArrayLength<<T as Inv>::Output>,
[src]
T: Inv,
N: ArrayLength<<T as Inv>::Output>,
type Output = NumericArray<<T as Inv>::Output, N>
The result after applying the operator.
fn inv(self) -> Self::Output
[src]
impl<'a, T: Clone, N: ArrayLength<T>> Inv for &'a NumericArray<T, N> where
T: Inv,
N: ArrayLength<<T as Inv>::Output>,
[src]
T: Inv,
N: ArrayLength<<T as Inv>::Output>,
type Output = NumericArray<<T as Inv>::Output, N>
The result after applying the operator.
fn inv(self) -> Self::Output
[src]
impl<'a, T: Clone, U: Clone, N: ArrayLength<T>> Mul<&'a NumericArray<T, N>> for NumericConstant<U> where
U: Mul<T>,
N: ArrayLength<<U as Mul<T>>::Output>,
[src]
U: Mul<T>,
N: ArrayLength<<U as Mul<T>>::Output>,
type Output = NumericArray<<U as Mul<T>>::Output, N>
The resulting type after applying the *
operator.
fn mul(self, rhs: &'a NumericArray<T, N>) -> Self::Output
[src]
impl<'a, T, U: Clone, N: ArrayLength<T> + ArrayLength<U>> Mul<&'a NumericArray<U, N>> for NumericArray<T, N> where
T: Mul<U>,
N: ArrayLength<<T as Mul<U>>::Output>,
[src]
T: Mul<U>,
N: ArrayLength<<T as Mul<U>>::Output>,
type Output = NumericArray<<T as Mul<U>>::Output, N>
The resulting type after applying the *
operator.
fn mul(self, rhs: &'a NumericArray<U, N>) -> Self::Output
[src]
impl<'a, 'b, T: Clone, U: Clone, N: ArrayLength<T> + ArrayLength<U>> Mul<&'b NumericArray<U, N>> for &'a NumericArray<T, N> where
T: Mul<U>,
N: ArrayLength<<T as Mul<U>>::Output>,
[src]
T: Mul<U>,
N: ArrayLength<<T as Mul<U>>::Output>,
type Output = NumericArray<<T as Mul<U>>::Output, N>
The resulting type after applying the *
operator.
fn mul(self, rhs: &'b NumericArray<U, N>) -> Self::Output
[src]
impl<T, U: Clone, N: ArrayLength<T>> Mul<NumericArray<T, N>> for NumericConstant<U> where
U: Mul<T>,
N: ArrayLength<<U as Mul<T>>::Output>,
[src]
U: Mul<T>,
N: ArrayLength<<U as Mul<T>>::Output>,
type Output = NumericArray<<U as Mul<T>>::Output, N>
The resulting type after applying the *
operator.
fn mul(self, rhs: NumericArray<T, N>) -> Self::Output
[src]
impl<T, U, N: ArrayLength<T> + ArrayLength<U>> Mul<NumericArray<U, N>> for NumericArray<T, N> where
T: Mul<U>,
N: ArrayLength<<T as Mul<U>>::Output>,
[src]
T: Mul<U>,
N: ArrayLength<<T as Mul<U>>::Output>,
type Output = NumericArray<<T as Mul<U>>::Output, N>
The resulting type after applying the *
operator.
fn mul(self, rhs: NumericArray<U, N>) -> Self::Output
[src]
impl<'a, T: Clone, U, N: ArrayLength<T> + ArrayLength<U>> Mul<NumericArray<U, N>> for &'a NumericArray<T, N> where
T: Mul<U>,
N: ArrayLength<<T as Mul<U>>::Output>,
[src]
T: Mul<U>,
N: ArrayLength<<T as Mul<U>>::Output>,
type Output = NumericArray<<T as Mul<U>>::Output, N>
The resulting type after applying the *
operator.
fn mul(self, rhs: NumericArray<U, N>) -> Self::Output
[src]
impl<T, U: Clone, N: ArrayLength<T>> Mul<NumericConstant<U>> for NumericArray<T, N> where
T: Mul<U>,
N: ArrayLength<<T as Mul<U>>::Output>,
[src]
T: Mul<U>,
N: ArrayLength<<T as Mul<U>>::Output>,
type Output = NumericArray<<T as Mul<U>>::Output, N>
The resulting type after applying the *
operator.
fn mul(self, rhs: NumericConstant<U>) -> Self::Output
[src]
impl<'a, T: Clone, U: Clone, N: ArrayLength<T>> Mul<NumericConstant<U>> for &'a NumericArray<T, N> where
T: Mul<U>,
N: ArrayLength<<T as Mul<U>>::Output>,
[src]
T: Mul<U>,
N: ArrayLength<<T as Mul<U>>::Output>,
type Output = NumericArray<<T as Mul<U>>::Output, N>
The resulting type after applying the *
operator.
fn mul(self, rhs: NumericConstant<U>) -> Self::Output
[src]
impl<'a, T, U: Clone, N: ArrayLength<T> + ArrayLength<U>> MulAssign<&'a NumericArray<U, N>> for NumericArray<T, N> where
T: MulAssign<U>,
[src]
T: MulAssign<U>,
fn mul_assign(&mut self, rhs: &'a NumericArray<U, N>)
[src]
impl<T, U, N: ArrayLength<T> + ArrayLength<U>> MulAssign<NumericArray<U, N>> for NumericArray<T, N> where
T: MulAssign<U>,
[src]
T: MulAssign<U>,
fn mul_assign(&mut self, rhs: NumericArray<U, N>)
[src]
impl<T, U: Clone, N: ArrayLength<T>> MulAssign<NumericConstant<U>> for NumericArray<T, N> where
T: MulAssign<U>,
[src]
T: MulAssign<U>,
fn mul_assign(&mut self, rhs: NumericConstant<U>)
[src]
impl<T, N: ArrayLength<T>> Neg for NumericArray<T, N> where
T: Neg,
N: ArrayLength<<T as Neg>::Output>,
[src]
T: Neg,
N: ArrayLength<<T as Neg>::Output>,
type Output = NumericArray<<T as Neg>::Output, N>
The resulting type after applying the -
operator.
fn neg(self) -> Self::Output
[src]
impl<'a, T: Clone, N: ArrayLength<T>> Neg for &'a NumericArray<T, N> where
T: Neg,
N: ArrayLength<<T as Neg>::Output>,
[src]
T: Neg,
N: ArrayLength<<T as Neg>::Output>,
type Output = NumericArray<<T as Neg>::Output, N>
The resulting type after applying the -
operator.
fn neg(self) -> Self::Output
[src]
impl<T, N: ArrayLength<T>> Not for NumericArray<T, N> where
T: Not,
N: ArrayLength<<T as Not>::Output>,
[src]
T: Not,
N: ArrayLength<<T as Not>::Output>,
type Output = NumericArray<<T as Not>::Output, N>
The resulting type after applying the !
operator.
fn not(self) -> Self::Output
[src]
impl<'a, T: Clone, N: ArrayLength<T>> Not for &'a NumericArray<T, N> where
T: Not,
N: ArrayLength<<T as Not>::Output>,
[src]
T: Not,
N: ArrayLength<<T as Not>::Output>,
type Output = NumericArray<<T as Not>::Output, N>
The resulting type after applying the !
operator.
fn not(self) -> Self::Output
[src]
impl<T: Clone, N: ArrayLength<T>> Num for NumericArray<T, N> where
T: Num,
[src]
T: Num,
type FromStrRadixErr = <T as Num>::FromStrRadixErr
fn from_str_radix(str: &str, radix: u32) -> Result<Self, Self::FromStrRadixErr>
[src]
impl<T, N: ArrayLength<T>> NumCast for NumericArray<T, N> where
T: NumCast + Clone,
[src]
T: NumCast + Clone,
fn from<P: ToPrimitive>(n: P) -> Option<Self>
[src]
impl<T, N: ArrayLength<T>> One for NumericArray<T, N> where
T: One,
[src]
T: One,
fn one() -> Self
[src]
fn set_one(&mut self)
[src]
fn is_one(&self) -> bool where
Self: PartialEq<Self>,
[src]
Self: PartialEq<Self>,
impl<T, N: ArrayLength<T>> Ord for NumericArray<T, N> where
T: Ord,
[src]
T: Ord,
fn cmp(&self, rhs: &Self) -> Ordering
[src]
#[must_use]fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<T, U, N: ArrayLength<T> + ArrayLength<U>> PartialEq<GenericArray<U, N>> for NumericArray<T, N> where
T: PartialEq<U>,
[src]
T: PartialEq<U>,
fn eq(&self, rhs: &GenericArray<U, N>) -> bool
[src]
#[must_use]fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<T, U, N: ArrayLength<T> + ArrayLength<U>> PartialEq<NumericArray<U, N>> for NumericArray<T, N> where
T: PartialEq<U>,
[src]
T: PartialEq<U>,
fn eq(&self, rhs: &NumericArray<U, N>) -> bool
[src]
#[must_use]fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<T, N: ArrayLength<T>> PartialOrd<GenericArray<T, N>> for NumericArray<T, N> where
T: PartialOrd,
[src]
T: PartialOrd,
fn partial_cmp(&self, rhs: &GenericArray<T, N>) -> Option<Ordering>
[src]
fn lt(&self, rhs: &GenericArray<T, N>) -> bool
[src]
fn le(&self, rhs: &GenericArray<T, N>) -> bool
[src]
fn gt(&self, rhs: &GenericArray<T, N>) -> bool
[src]
fn ge(&self, rhs: &GenericArray<T, N>) -> bool
[src]
impl<T, N: ArrayLength<T>> PartialOrd<NumericArray<T, N>> for NumericArray<T, N> where
T: PartialOrd,
[src]
T: PartialOrd,
fn partial_cmp(&self, rhs: &Self) -> Option<Ordering>
[src]
fn lt(&self, rhs: &Self) -> bool
[src]
fn le(&self, rhs: &Self) -> bool
[src]
fn gt(&self, rhs: &Self) -> bool
[src]
fn ge(&self, rhs: &Self) -> bool
[src]
impl<T, N: ArrayLength<T>> Permute<T, N> for NumericArray<usize, N> where
N: ArrayLength<usize>,
T: Clone,
[src]
N: ArrayLength<usize>,
T: Clone,
fn permute(self, values: &NumericArray<T, N>) -> NumericArray<T, N>
[src]
impl<'a, T: Clone, U: Clone, N: ArrayLength<T>> Pow<&'a NumericArray<T, N>> for NumericConstant<U> where
U: Pow<T>,
N: ArrayLength<<U as Pow<T>>::Output>,
[src]
U: Pow<T>,
N: ArrayLength<<U as Pow<T>>::Output>,
type Output = NumericArray<<U as Pow<T>>::Output, N>
The result after applying the operator.
fn pow(self, rhs: &'a NumericArray<T, N>) -> Self::Output
[src]
impl<'a, T, U: Clone, N: ArrayLength<T> + ArrayLength<U>> Pow<&'a NumericArray<U, N>> for NumericArray<T, N> where
T: Pow<U>,
N: ArrayLength<<T as Pow<U>>::Output>,
[src]
T: Pow<U>,
N: ArrayLength<<T as Pow<U>>::Output>,
type Output = NumericArray<<T as Pow<U>>::Output, N>
The result after applying the operator.
fn pow(self, rhs: &'a NumericArray<U, N>) -> Self::Output
[src]
impl<'a, 'b, T: Clone, U: Clone, N: ArrayLength<T> + ArrayLength<U>> Pow<&'b NumericArray<U, N>> for &'a NumericArray<T, N> where
T: Pow<U>,
N: ArrayLength<<T as Pow<U>>::Output>,
[src]
T: Pow<U>,
N: ArrayLength<<T as Pow<U>>::Output>,
type Output = NumericArray<<T as Pow<U>>::Output, N>
The result after applying the operator.
fn pow(self, rhs: &'b NumericArray<U, N>) -> Self::Output
[src]
impl<T, U: Clone, N: ArrayLength<T>> Pow<NumericArray<T, N>> for NumericConstant<U> where
U: Pow<T>,
N: ArrayLength<<U as Pow<T>>::Output>,
[src]
U: Pow<T>,
N: ArrayLength<<U as Pow<T>>::Output>,
type Output = NumericArray<<U as Pow<T>>::Output, N>
The result after applying the operator.
fn pow(self, rhs: NumericArray<T, N>) -> Self::Output
[src]
impl<T, U, N: ArrayLength<T> + ArrayLength<U>> Pow<NumericArray<U, N>> for NumericArray<T, N> where
T: Pow<U>,
N: ArrayLength<<T as Pow<U>>::Output>,
[src]
T: Pow<U>,
N: ArrayLength<<T as Pow<U>>::Output>,
type Output = NumericArray<<T as Pow<U>>::Output, N>
The result after applying the operator.
fn pow(self, rhs: NumericArray<U, N>) -> Self::Output
[src]
impl<'a, T: Clone, U, N: ArrayLength<T> + ArrayLength<U>> Pow<NumericArray<U, N>> for &'a NumericArray<T, N> where
T: Pow<U>,
N: ArrayLength<<T as Pow<U>>::Output>,
[src]
T: Pow<U>,
N: ArrayLength<<T as Pow<U>>::Output>,
type Output = NumericArray<<T as Pow<U>>::Output, N>
The result after applying the operator.
fn pow(self, rhs: NumericArray<U, N>) -> Self::Output
[src]
impl<T, U: Clone, N: ArrayLength<T>> Pow<NumericConstant<U>> for NumericArray<T, N> where
T: Pow<U>,
N: ArrayLength<<T as Pow<U>>::Output>,
[src]
T: Pow<U>,
N: ArrayLength<<T as Pow<U>>::Output>,
type Output = NumericArray<<T as Pow<U>>::Output, N>
The result after applying the operator.
fn pow(self, rhs: NumericConstant<U>) -> Self::Output
[src]
impl<'a, T: Clone, U: Clone, N: ArrayLength<T>> Pow<NumericConstant<U>> for &'a NumericArray<T, N> where
T: Pow<U>,
N: ArrayLength<<T as Pow<U>>::Output>,
[src]
T: Pow<U>,
N: ArrayLength<<T as Pow<U>>::Output>,
type Output = NumericArray<<T as Pow<U>>::Output, N>
The result after applying the operator.
fn pow(self, rhs: NumericConstant<U>) -> Self::Output
[src]
impl<'a, T: Clone, U: Clone, N: ArrayLength<T>> Rem<&'a NumericArray<T, N>> for NumericConstant<U> where
U: Rem<T>,
N: ArrayLength<<U as Rem<T>>::Output>,
[src]
U: Rem<T>,
N: ArrayLength<<U as Rem<T>>::Output>,
type Output = NumericArray<<U as Rem<T>>::Output, N>
The resulting type after applying the %
operator.
fn rem(self, rhs: &'a NumericArray<T, N>) -> Self::Output
[src]
impl<'a, T, U: Clone, N: ArrayLength<T> + ArrayLength<U>> Rem<&'a NumericArray<U, N>> for NumericArray<T, N> where
T: Rem<U>,
N: ArrayLength<<T as Rem<U>>::Output>,
[src]
T: Rem<U>,
N: ArrayLength<<T as Rem<U>>::Output>,
type Output = NumericArray<<T as Rem<U>>::Output, N>
The resulting type after applying the %
operator.
fn rem(self, rhs: &'a NumericArray<U, N>) -> Self::Output
[src]
impl<'a, 'b, T: Clone, U: Clone, N: ArrayLength<T> + ArrayLength<U>> Rem<&'b NumericArray<U, N>> for &'a NumericArray<T, N> where
T: Rem<U>,
N: ArrayLength<<T as Rem<U>>::Output>,
[src]
T: Rem<U>,
N: ArrayLength<<T as Rem<U>>::Output>,
type Output = NumericArray<<T as Rem<U>>::Output, N>
The resulting type after applying the %
operator.
fn rem(self, rhs: &'b NumericArray<U, N>) -> Self::Output
[src]
impl<T, U: Clone, N: ArrayLength<T>> Rem<NumericArray<T, N>> for NumericConstant<U> where
U: Rem<T>,
N: ArrayLength<<U as Rem<T>>::Output>,
[src]
U: Rem<T>,
N: ArrayLength<<U as Rem<T>>::Output>,
type Output = NumericArray<<U as Rem<T>>::Output, N>
The resulting type after applying the %
operator.
fn rem(self, rhs: NumericArray<T, N>) -> Self::Output
[src]
impl<T, U, N: ArrayLength<T> + ArrayLength<U>> Rem<NumericArray<U, N>> for NumericArray<T, N> where
T: Rem<U>,
N: ArrayLength<<T as Rem<U>>::Output>,
[src]
T: Rem<U>,
N: ArrayLength<<T as Rem<U>>::Output>,
type Output = NumericArray<<T as Rem<U>>::Output, N>
The resulting type after applying the %
operator.
fn rem(self, rhs: NumericArray<U, N>) -> Self::Output
[src]
impl<'a, T: Clone, U, N: ArrayLength<T> + ArrayLength<U>> Rem<NumericArray<U, N>> for &'a NumericArray<T, N> where
T: Rem<U>,
N: ArrayLength<<T as Rem<U>>::Output>,
[src]
T: Rem<U>,
N: ArrayLength<<T as Rem<U>>::Output>,
type Output = NumericArray<<T as Rem<U>>::Output, N>
The resulting type after applying the %
operator.
fn rem(self, rhs: NumericArray<U, N>) -> Self::Output
[src]
impl<T, U: Clone, N: ArrayLength<T>> Rem<NumericConstant<U>> for NumericArray<T, N> where
T: Rem<U>,
N: ArrayLength<<T as Rem<U>>::Output>,
[src]
T: Rem<U>,
N: ArrayLength<<T as Rem<U>>::Output>,
type Output = NumericArray<<T as Rem<U>>::Output, N>
The resulting type after applying the %
operator.
fn rem(self, rhs: NumericConstant<U>) -> Self::Output
[src]
impl<'a, T: Clone, U: Clone, N: ArrayLength<T>> Rem<NumericConstant<U>> for &'a NumericArray<T, N> where
T: Rem<U>,
N: ArrayLength<<T as Rem<U>>::Output>,
[src]
T: Rem<U>,
N: ArrayLength<<T as Rem<U>>::Output>,
type Output = NumericArray<<T as Rem<U>>::Output, N>
The resulting type after applying the %
operator.
fn rem(self, rhs: NumericConstant<U>) -> Self::Output
[src]
impl<'a, T, U: Clone, N: ArrayLength<T> + ArrayLength<U>> RemAssign<&'a NumericArray<U, N>> for NumericArray<T, N> where
T: RemAssign<U>,
[src]
T: RemAssign<U>,
fn rem_assign(&mut self, rhs: &'a NumericArray<U, N>)
[src]
impl<T, U, N: ArrayLength<T> + ArrayLength<U>> RemAssign<NumericArray<U, N>> for NumericArray<T, N> where
T: RemAssign<U>,
[src]
T: RemAssign<U>,
fn rem_assign(&mut self, rhs: NumericArray<U, N>)
[src]
impl<T, U: Clone, N: ArrayLength<T>> RemAssign<NumericConstant<U>> for NumericArray<T, N> where
T: RemAssign<U>,
[src]
T: RemAssign<U>,
fn rem_assign(&mut self, rhs: NumericConstant<U>)
[src]
impl<T, N: ArrayLength<T>> Saturating for NumericArray<T, N> where
T: Saturating,
[src]
T: Saturating,
fn saturating_add(self, rhs: Self) -> Self
[src]
fn saturating_sub(self, rhs: Self) -> Self
[src]
impl<T, N: ArrayLength<T>> Select<T, N> for NumericArray<bool, N> where
N: ArrayLength<bool>,
[src]
N: ArrayLength<bool>,
fn select(
self,
true_values: NumericArray<T, N>,
false_values: NumericArray<T, N>
) -> NumericArray<T, N>
[src]
self,
true_values: NumericArray<T, N>,
false_values: NumericArray<T, N>
) -> NumericArray<T, N>
impl<'a, T: Clone, U: Clone, N: ArrayLength<T>> Shl<&'a NumericArray<T, N>> for NumericConstant<U> where
U: Shl<T>,
N: ArrayLength<<U as Shl<T>>::Output>,
[src]
U: Shl<T>,
N: ArrayLength<<U as Shl<T>>::Output>,
type Output = NumericArray<<U as Shl<T>>::Output, N>
The resulting type after applying the <<
operator.
fn shl(self, rhs: &'a NumericArray<T, N>) -> Self::Output
[src]
impl<'a, T, U: Clone, N: ArrayLength<T> + ArrayLength<U>> Shl<&'a NumericArray<U, N>> for NumericArray<T, N> where
T: Shl<U>,
N: ArrayLength<<T as Shl<U>>::Output>,
[src]
T: Shl<U>,
N: ArrayLength<<T as Shl<U>>::Output>,
type Output = NumericArray<<T as Shl<U>>::Output, N>
The resulting type after applying the <<
operator.
fn shl(self, rhs: &'a NumericArray<U, N>) -> Self::Output
[src]
impl<'a, 'b, T: Clone, U: Clone, N: ArrayLength<T> + ArrayLength<U>> Shl<&'b NumericArray<U, N>> for &'a NumericArray<T, N> where
T: Shl<U>,
N: ArrayLength<<T as Shl<U>>::Output>,
[src]
T: Shl<U>,
N: ArrayLength<<T as Shl<U>>::Output>,
type Output = NumericArray<<T as Shl<U>>::Output, N>
The resulting type after applying the <<
operator.
fn shl(self, rhs: &'b NumericArray<U, N>) -> Self::Output
[src]
impl<T, U: Clone, N: ArrayLength<T>> Shl<NumericArray<T, N>> for NumericConstant<U> where
U: Shl<T>,
N: ArrayLength<<U as Shl<T>>::Output>,
[src]
U: Shl<T>,
N: ArrayLength<<U as Shl<T>>::Output>,
type Output = NumericArray<<U as Shl<T>>::Output, N>
The resulting type after applying the <<
operator.
fn shl(self, rhs: NumericArray<T, N>) -> Self::Output
[src]
impl<T, U, N: ArrayLength<T> + ArrayLength<U>> Shl<NumericArray<U, N>> for NumericArray<T, N> where
T: Shl<U>,
N: ArrayLength<<T as Shl<U>>::Output>,
[src]
T: Shl<U>,
N: ArrayLength<<T as Shl<U>>::Output>,
type Output = NumericArray<<T as Shl<U>>::Output, N>
The resulting type after applying the <<
operator.
fn shl(self, rhs: NumericArray<U, N>) -> Self::Output
[src]
impl<'a, T: Clone, U, N: ArrayLength<T> + ArrayLength<U>> Shl<NumericArray<U, N>> for &'a NumericArray<T, N> where
T: Shl<U>,
N: ArrayLength<<T as Shl<U>>::Output>,
[src]
T: Shl<U>,
N: ArrayLength<<T as Shl<U>>::Output>,
type Output = NumericArray<<T as Shl<U>>::Output, N>
The resulting type after applying the <<
operator.
fn shl(self, rhs: NumericArray<U, N>) -> Self::Output
[src]
impl<T, U: Clone, N: ArrayLength<T>> Shl<NumericConstant<U>> for NumericArray<T, N> where
T: Shl<U>,
N: ArrayLength<<T as Shl<U>>::Output>,
[src]
T: Shl<U>,
N: ArrayLength<<T as Shl<U>>::Output>,
type Output = NumericArray<<T as Shl<U>>::Output, N>
The resulting type after applying the <<
operator.
fn shl(self, rhs: NumericConstant<U>) -> Self::Output
[src]
impl<'a, T: Clone, U: Clone, N: ArrayLength<T>> Shl<NumericConstant<U>> for &'a NumericArray<T, N> where
T: Shl<U>,
N: ArrayLength<<T as Shl<U>>::Output>,
[src]
T: Shl<U>,
N: ArrayLength<<T as Shl<U>>::Output>,
type Output = NumericArray<<T as Shl<U>>::Output, N>
The resulting type after applying the <<
operator.
fn shl(self, rhs: NumericConstant<U>) -> Self::Output
[src]
impl<'a, T, U: Clone, N: ArrayLength<T> + ArrayLength<U>> ShlAssign<&'a NumericArray<U, N>> for NumericArray<T, N> where
T: ShlAssign<U>,
[src]
T: ShlAssign<U>,
fn shl_assign(&mut self, rhs: &'a NumericArray<U, N>)
[src]
impl<T, U, N: ArrayLength<T> + ArrayLength<U>> ShlAssign<NumericArray<U, N>> for NumericArray<T, N> where
T: ShlAssign<U>,
[src]
T: ShlAssign<U>,
fn shl_assign(&mut self, rhs: NumericArray<U, N>)
[src]
impl<T, U: Clone, N: ArrayLength<T>> ShlAssign<NumericConstant<U>> for NumericArray<T, N> where
T: ShlAssign<U>,
[src]
T: ShlAssign<U>,
fn shl_assign(&mut self, rhs: NumericConstant<U>)
[src]
impl<'a, T: Clone, U: Clone, N: ArrayLength<T>> Shr<&'a NumericArray<T, N>> for NumericConstant<U> where
U: Shr<T>,
N: ArrayLength<<U as Shr<T>>::Output>,
[src]
U: Shr<T>,
N: ArrayLength<<U as Shr<T>>::Output>,
type Output = NumericArray<<U as Shr<T>>::Output, N>
The resulting type after applying the >>
operator.
fn shr(self, rhs: &'a NumericArray<T, N>) -> Self::Output
[src]
impl<'a, T, U: Clone, N: ArrayLength<T> + ArrayLength<U>> Shr<&'a NumericArray<U, N>> for NumericArray<T, N> where
T: Shr<U>,
N: ArrayLength<<T as Shr<U>>::Output>,
[src]
T: Shr<U>,
N: ArrayLength<<T as Shr<U>>::Output>,
type Output = NumericArray<<T as Shr<U>>::Output, N>
The resulting type after applying the >>
operator.
fn shr(self, rhs: &'a NumericArray<U, N>) -> Self::Output
[src]
impl<'a, 'b, T: Clone, U: Clone, N: ArrayLength<T> + ArrayLength<U>> Shr<&'b NumericArray<U, N>> for &'a NumericArray<T, N> where
T: Shr<U>,
N: ArrayLength<<T as Shr<U>>::Output>,
[src]
T: Shr<U>,
N: ArrayLength<<T as Shr<U>>::Output>,
type Output = NumericArray<<T as Shr<U>>::Output, N>
The resulting type after applying the >>
operator.
fn shr(self, rhs: &'b NumericArray<U, N>) -> Self::Output
[src]
impl<T, U: Clone, N: ArrayLength<T>> Shr<NumericArray<T, N>> for NumericConstant<U> where
U: Shr<T>,
N: ArrayLength<<U as Shr<T>>::Output>,
[src]
U: Shr<T>,
N: ArrayLength<<U as Shr<T>>::Output>,
type Output = NumericArray<<U as Shr<T>>::Output, N>
The resulting type after applying the >>
operator.
fn shr(self, rhs: NumericArray<T, N>) -> Self::Output
[src]
impl<T, U, N: ArrayLength<T> + ArrayLength<U>> Shr<NumericArray<U, N>> for NumericArray<T, N> where
T: Shr<U>,
N: ArrayLength<<T as Shr<U>>::Output>,
[src]
T: Shr<U>,
N: ArrayLength<<T as Shr<U>>::Output>,
type Output = NumericArray<<T as Shr<U>>::Output, N>
The resulting type after applying the >>
operator.
fn shr(self, rhs: NumericArray<U, N>) -> Self::Output
[src]
impl<'a, T: Clone, U, N: ArrayLength<T> + ArrayLength<U>> Shr<NumericArray<U, N>> for &'a NumericArray<T, N> where
T: Shr<U>,
N: ArrayLength<<T as Shr<U>>::Output>,
[src]
T: Shr<U>,
N: ArrayLength<<T as Shr<U>>::Output>,
type Output = NumericArray<<T as Shr<U>>::Output, N>
The resulting type after applying the >>
operator.
fn shr(self, rhs: NumericArray<U, N>) -> Self::Output
[src]
impl<T, U: Clone, N: ArrayLength<T>> Shr<NumericConstant<U>> for NumericArray<T, N> where
T: Shr<U>,
N: ArrayLength<<T as Shr<U>>::Output>,
[src]
T: Shr<U>,
N: ArrayLength<<T as Shr<U>>::Output>,
type Output = NumericArray<<T as Shr<U>>::Output, N>
The resulting type after applying the >>
operator.
fn shr(self, rhs: NumericConstant<U>) -> Self::Output
[src]
impl<'a, T: Clone, U: Clone, N: ArrayLength<T>> Shr<NumericConstant<U>> for &'a NumericArray<T, N> where
T: Shr<U>,
N: ArrayLength<<T as Shr<U>>::Output>,
[src]
T: Shr<U>,
N: ArrayLength<<T as Shr<U>>::Output>,
type Output = NumericArray<<T as Shr<U>>::Output, N>
The resulting type after applying the >>
operator.
fn shr(self, rhs: NumericConstant<U>) -> Self::Output
[src]
impl<'a, T, U: Clone, N: ArrayLength<T> + ArrayLength<U>> ShrAssign<&'a NumericArray<U, N>> for NumericArray<T, N> where
T: ShrAssign<U>,
[src]
T: ShrAssign<U>,
fn shr_assign(&mut self, rhs: &'a NumericArray<U, N>)
[src]
impl<T, U, N: ArrayLength<T> + ArrayLength<U>> ShrAssign<NumericArray<U, N>> for NumericArray<T, N> where
T: ShrAssign<U>,
[src]
T: ShrAssign<U>,
fn shr_assign(&mut self, rhs: NumericArray<U, N>)
[src]
impl<T, U: Clone, N: ArrayLength<T>> ShrAssign<NumericConstant<U>> for NumericArray<T, N> where
T: ShrAssign<U>,
[src]
T: ShrAssign<U>,
fn shr_assign(&mut self, rhs: NumericConstant<U>)
[src]
impl<T: Clone, N: ArrayLength<T>> Signed for NumericArray<T, N> where
T: Signed,
[src]
T: Signed,
fn abs(&self) -> Self
[src]
fn abs_sub(&self, rhs: &Self) -> Self
[src]
fn signum(&self) -> Self
[src]
fn is_positive(&self) -> bool
[src]
fn is_negative(&self) -> bool
[src]
impl<'a, T: Clone, U: Clone, N: ArrayLength<T>> Sub<&'a NumericArray<T, N>> for NumericConstant<U> where
U: Sub<T>,
N: ArrayLength<<U as Sub<T>>::Output>,
[src]
U: Sub<T>,
N: ArrayLength<<U as Sub<T>>::Output>,
type Output = NumericArray<<U as Sub<T>>::Output, N>
The resulting type after applying the -
operator.
fn sub(self, rhs: &'a NumericArray<T, N>) -> Self::Output
[src]
impl<'a, T, U: Clone, N: ArrayLength<T> + ArrayLength<U>> Sub<&'a NumericArray<U, N>> for NumericArray<T, N> where
T: Sub<U>,
N: ArrayLength<<T as Sub<U>>::Output>,
[src]
T: Sub<U>,
N: ArrayLength<<T as Sub<U>>::Output>,
type Output = NumericArray<<T as Sub<U>>::Output, N>
The resulting type after applying the -
operator.
fn sub(self, rhs: &'a NumericArray<U, N>) -> Self::Output
[src]
impl<'a, 'b, T: Clone, U: Clone, N: ArrayLength<T> + ArrayLength<U>> Sub<&'b NumericArray<U, N>> for &'a NumericArray<T, N> where
T: Sub<U>,
N: ArrayLength<<T as Sub<U>>::Output>,
[src]
T: Sub<U>,
N: ArrayLength<<T as Sub<U>>::Output>,
type Output = NumericArray<<T as Sub<U>>::Output, N>
The resulting type after applying the -
operator.
fn sub(self, rhs: &'b NumericArray<U, N>) -> Self::Output
[src]
impl<T, U: Clone, N: ArrayLength<T>> Sub<NumericArray<T, N>> for NumericConstant<U> where
U: Sub<T>,
N: ArrayLength<<U as Sub<T>>::Output>,
[src]
U: Sub<T>,
N: ArrayLength<<U as Sub<T>>::Output>,
type Output = NumericArray<<U as Sub<T>>::Output, N>
The resulting type after applying the -
operator.
fn sub(self, rhs: NumericArray<T, N>) -> Self::Output
[src]
impl<T, U, N: ArrayLength<T> + ArrayLength<U>> Sub<NumericArray<U, N>> for NumericArray<T, N> where
T: Sub<U>,
N: ArrayLength<<T as Sub<U>>::Output>,
[src]
T: Sub<U>,
N: ArrayLength<<T as Sub<U>>::Output>,
type Output = NumericArray<<T as Sub<U>>::Output, N>
The resulting type after applying the -
operator.
fn sub(self, rhs: NumericArray<U, N>) -> Self::Output
[src]
impl<'a, T: Clone, U, N: ArrayLength<T> + ArrayLength<U>> Sub<NumericArray<U, N>> for &'a NumericArray<T, N> where
T: Sub<U>,
N: ArrayLength<<T as Sub<U>>::Output>,
[src]
T: Sub<U>,
N: ArrayLength<<T as Sub<U>>::Output>,
type Output = NumericArray<<T as Sub<U>>::Output, N>
The resulting type after applying the -
operator.
fn sub(self, rhs: NumericArray<U, N>) -> Self::Output
[src]
impl<T, U: Clone, N: ArrayLength<T>> Sub<NumericConstant<U>> for NumericArray<T, N> where
T: Sub<U>,
N: ArrayLength<<T as Sub<U>>::Output>,
[src]
T: Sub<U>,
N: ArrayLength<<T as Sub<U>>::Output>,
type Output = NumericArray<<T as Sub<U>>::Output, N>
The resulting type after applying the -
operator.
fn sub(self, rhs: NumericConstant<U>) -> Self::Output
[src]
impl<'a, T: Clone, U: Clone, N: ArrayLength<T>> Sub<NumericConstant<U>> for &'a NumericArray<T, N> where
T: Sub<U>,
N: ArrayLength<<T as Sub<U>>::Output>,
[src]
T: Sub<U>,
N: ArrayLength<<T as Sub<U>>::Output>,
type Output = NumericArray<<T as Sub<U>>::Output, N>
The resulting type after applying the -
operator.
fn sub(self, rhs: NumericConstant<U>) -> Self::Output
[src]
impl<'a, T, U: Clone, N: ArrayLength<T> + ArrayLength<U>> SubAssign<&'a NumericArray<U, N>> for NumericArray<T, N> where
T: SubAssign<U>,
[src]
T: SubAssign<U>,
fn sub_assign(&mut self, rhs: &'a NumericArray<U, N>)
[src]
impl<T, U, N: ArrayLength<T> + ArrayLength<U>> SubAssign<NumericArray<U, N>> for NumericArray<T, N> where
T: SubAssign<U>,
[src]
T: SubAssign<U>,
fn sub_assign(&mut self, rhs: NumericArray<U, N>)
[src]
impl<T, U: Clone, N: ArrayLength<T>> SubAssign<NumericConstant<U>> for NumericArray<T, N> where
T: SubAssign<U>,
[src]
T: SubAssign<U>,
fn sub_assign(&mut self, rhs: NumericConstant<U>)
[src]
impl<T, N: ArrayLength<T>> ToPrimitive for NumericArray<T, N> where
T: ToPrimitive,
[src]
T: ToPrimitive,
fn to_i8(&self) -> Option<i8>
[src]
fn to_i16(&self) -> Option<i16>
[src]
fn to_i32(&self) -> Option<i32>
[src]
fn to_i64(&self) -> Option<i64>
[src]
fn to_i128(&self) -> Option<i128>
[src]
fn to_isize(&self) -> Option<isize>
[src]
fn to_u8(&self) -> Option<u8>
[src]
fn to_u16(&self) -> Option<u16>
[src]
fn to_u32(&self) -> Option<u32>
[src]
fn to_u64(&self) -> Option<u64>
[src]
fn to_u128(&self) -> Option<u128>
[src]
fn to_usize(&self) -> Option<usize>
[src]
fn to_f32(&self) -> Option<f32>
[src]
fn to_f64(&self) -> Option<f64>
[src]
impl<T: Clone, N: ArrayLength<T>> Unsigned for NumericArray<T, N> where
T: Unsigned,
[src]
T: Unsigned,
impl<T, N: ArrayLength<T>> WrappingAdd for NumericArray<T, N> where
T: WrappingAdd,
[src]
T: WrappingAdd,
fn wrapping_add(&self, rhs: &Self) -> Self
[src]
impl<T, N: ArrayLength<T>> WrappingMul for NumericArray<T, N> where
T: WrappingMul,
[src]
T: WrappingMul,
fn wrapping_mul(&self, rhs: &Self) -> Self
[src]
impl<T, N: ArrayLength<T>> WrappingSub for NumericArray<T, N> where
T: WrappingSub,
[src]
T: WrappingSub,
fn wrapping_sub(&self, rhs: &Self) -> Self
[src]
impl<T, N: ArrayLength<T>> Zero for NumericArray<T, N> where
T: Zero,
[src]
T: Zero,
Auto Trait Implementations
impl<T, N> RefUnwindSafe for NumericArray<T, N> where
<N as ArrayLength<T>>::ArrayType: RefUnwindSafe,
<N as ArrayLength<T>>::ArrayType: RefUnwindSafe,
impl<T, N> Send for NumericArray<T, N> where
T: Send,
T: Send,
impl<T, N> Sync for NumericArray<T, N> where
T: Sync,
T: Sync,
impl<T, N> Unpin for NumericArray<T, N> where
<N as ArrayLength<T>>::ArrayType: Unpin,
<N as ArrayLength<T>>::ArrayType: Unpin,
impl<T, N> UnwindSafe for NumericArray<T, N> where
<N as ArrayLength<T>>::ArrayType: UnwindSafe,
<N as ArrayLength<T>>::ArrayType: UnwindSafe,
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<I> IntoIterator for I where
I: Iterator,
[src]
I: Iterator,
type Item = <I as Iterator>::Item
The type of the elements being iterated over.
type IntoIter = I
Which kind of iterator are we turning this into?
fn into_iter(self) -> I
[src]
impl<T> NumAssign for T where
T: Num + NumAssignOps<T>,
[src]
T: Num + NumAssignOps<T>,
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> NumAssignRef for T where
T: NumAssign + for<'r> NumAssignOps<&'r T>,
[src]
T: NumAssign + for<'r> NumAssignOps<&'r T>,
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> NumRef for T where
T: Num + for<'r> NumOps<&'r T, T>,
[src]
T: Num + for<'r> NumOps<&'r T, T>,
impl<T> Real for T where
T: Float,
[src]
T: Float,
fn min_value() -> T
[src]
fn min_positive_value() -> T
[src]
fn epsilon() -> T
[src]
fn max_value() -> T
[src]
fn floor(self) -> T
[src]
fn ceil(self) -> T
[src]
fn round(self) -> T
[src]
fn trunc(self) -> T
[src]
fn fract(self) -> T
[src]
fn abs(self) -> T
[src]
fn signum(self) -> T
[src]
fn is_sign_positive(self) -> bool
[src]
fn is_sign_negative(self) -> bool
[src]
fn mul_add(self, a: T, b: T) -> T
[src]
fn recip(self) -> T
[src]
fn powi(self, n: i32) -> T
[src]
fn powf(self, n: T) -> T
[src]
fn sqrt(self) -> T
[src]
fn exp(self) -> T
[src]
fn exp2(self) -> T
[src]
fn ln(self) -> T
[src]
fn log(self, base: T) -> T
[src]
fn log2(self) -> T
[src]
fn log10(self) -> T
[src]
fn to_degrees(self) -> T
[src]
fn to_radians(self) -> T
[src]
fn max(self, other: T) -> T
[src]
fn min(self, other: T) -> T
[src]
fn abs_sub(self, other: T) -> T
[src]
fn cbrt(self) -> T
[src]
fn hypot(self, other: T) -> T
[src]
fn sin(self) -> T
[src]
fn cos(self) -> T
[src]
fn tan(self) -> T
[src]
fn asin(self) -> T
[src]
fn acos(self) -> T
[src]
fn atan(self) -> T
[src]
fn atan2(self, other: T) -> T
[src]
fn sin_cos(self) -> (T, T)
[src]
fn exp_m1(self) -> T
[src]
fn ln_1p(self) -> T
[src]
fn sinh(self) -> T
[src]
fn cosh(self) -> T
[src]
fn tanh(self) -> T
[src]
fn asinh(self) -> T
[src]
fn acosh(self) -> T
[src]
fn atanh(self) -> T
[src]
impl<T, Base> RefNum<Base> for T where
T: NumOps<Base, Base> + for<'r> NumOps<&'r Base, Base>,
[src]
T: NumOps<Base, Base> + for<'r> NumOps<&'r Base, Base>,
impl<T> Same<T> for T
type Output = T
Should always be Self
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> 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>,