Trait elementwise::arithmetic::ElementwiseNeg

pub trait ElementwiseNeg {
    fn elementwise_neg(&self) -> Self;
}

Required methods

fn elementwise_neg(&self) -> Self

Loading content...

Implementations on Foreign Types

impl<T: Copy + Neg<Output = T>> ElementwiseNeg for Vec<T>

fn elementwise_neg(&self) -> Vec<T>

impl<T: Copy + Neg<Output = T>> ElementwiseNeg for VecDeque<T>

fn elementwise_neg(&self) -> VecDeque<T>

impl<T: Copy + Neg<Output = T>> ElementwiseNeg for LinkedList<T>

fn elementwise_neg(&self) -> LinkedList<T>

impl<T: Copy + Neg<Output = T>> ElementwiseNeg for [T; 1]

fn elementwise_neg(&self) -> [T; 1]

impl<T: Copy + Neg<Output = T>> ElementwiseNeg for [T; 2]

fn elementwise_neg(&self) -> [T; 2]

impl<T: Copy + Neg<Output = T>> ElementwiseNeg for [T; 3]

fn elementwise_neg(&self) -> [T; 3]

impl<T: Copy + Neg<Output = T>> ElementwiseNeg for [T; 4]

fn elementwise_neg(&self) -> [T; 4]

impl<T: Copy + Neg<Output = T>> ElementwiseNeg for [T; 5]

fn elementwise_neg(&self) -> [T; 5]

impl<T: Copy + Neg<Output = T>> ElementwiseNeg for [T; 6]

fn elementwise_neg(&self) -> [T; 6]

impl<T: Copy + Neg<Output = T>> ElementwiseNeg for [T; 7]

fn elementwise_neg(&self) -> [T; 7]

impl<T: Copy + Neg<Output = T>> ElementwiseNeg for [T; 8]

fn elementwise_neg(&self) -> [T; 8]

impl<T: Copy + Neg<Output = T>> ElementwiseNeg for [T; 9]

fn elementwise_neg(&self) -> [T; 9]

impl<T: Copy + Neg<Output = T>> ElementwiseNeg for [T; 10]

fn elementwise_neg(&self) -> [T; 10]

impl<T: Copy + Neg<Output = T>> ElementwiseNeg for [T; 11]

fn elementwise_neg(&self) -> [T; 11]

impl<T: Copy + Neg<Output = T>> ElementwiseNeg for [T; 12]

fn elementwise_neg(&self) -> [T; 12]

impl<T: Copy + Neg<Output = T>> ElementwiseNeg for [T; 13]

fn elementwise_neg(&self) -> [T; 13]

impl<T: Copy + Neg<Output = T>> ElementwiseNeg for [T; 14]

fn elementwise_neg(&self) -> [T; 14]

impl<T: Copy + Neg<Output = T>> ElementwiseNeg for [T; 15]

fn elementwise_neg(&self) -> [T; 15]

impl<T: Copy + Neg<Output = T>> ElementwiseNeg for [T; 16]

fn elementwise_neg(&self) -> [T; 16]

impl<T: Copy + Neg<Output = T>> ElementwiseNeg for [T; 17]

fn elementwise_neg(&self) -> [T; 17]

impl<T: Copy + Neg<Output = T>> ElementwiseNeg for [T; 18]

fn elementwise_neg(&self) -> [T; 18]

impl<T: Copy + Neg<Output = T>> ElementwiseNeg for [T; 19]

fn elementwise_neg(&self) -> [T; 19]

impl<T: Copy + Neg<Output = T>> ElementwiseNeg for [T; 20]

fn elementwise_neg(&self) -> [T; 20]

impl<T: Copy + Neg<Output = T>> ElementwiseNeg for [T; 21]

fn elementwise_neg(&self) -> [T; 21]

impl<T: Copy + Neg<Output = T>> ElementwiseNeg for [T; 22]

fn elementwise_neg(&self) -> [T; 22]

impl<T: Copy + Neg<Output = T>> ElementwiseNeg for [T; 23]

fn elementwise_neg(&self) -> [T; 23]

impl<T: Copy + Neg<Output = T>> ElementwiseNeg for [T; 24]

fn elementwise_neg(&self) -> [T; 24]

impl<T: Copy + Neg<Output = T>> ElementwiseNeg for [T; 25]

fn elementwise_neg(&self) -> [T; 25]

impl<T: Copy + Neg<Output = T>> ElementwiseNeg for [T; 26]

fn elementwise_neg(&self) -> [T; 26]

impl<T: Copy + Neg<Output = T>> ElementwiseNeg for [T; 27]

fn elementwise_neg(&self) -> [T; 27]

impl<T: Copy + Neg<Output = T>> ElementwiseNeg for [T; 28]

fn elementwise_neg(&self) -> [T; 28]

impl<T: Copy + Neg<Output = T>> ElementwiseNeg for [T; 29]

fn elementwise_neg(&self) -> [T; 29]

impl<T: Copy + Neg<Output = T>> ElementwiseNeg for [T; 30]

fn elementwise_neg(&self) -> [T; 30]

impl<T: Copy + Neg<Output = T>> ElementwiseNeg for [T; 31]

fn elementwise_neg(&self) -> [T; 31]

impl<T: Copy + Neg<Output = T>> ElementwiseNeg for [T; 32]

fn elementwise_neg(&self) -> [T; 32]

impl<T1, T2> ElementwiseNeg for (T1, T2) where
    T1: Copy + Neg<Output = T1>,
    T2: Copy + Neg<Output = T2>, 

fn elementwise_neg(&self) -> (T1, T2)

impl<T1, T2, T3> ElementwiseNeg for (T1, T2, T3) where
    T1: Copy + Neg<Output = T1>,
    T2: Copy + Neg<Output = T2>,
    T3: Copy + Neg<Output = T3>, 

fn elementwise_neg(&self) -> (T1, T2, T3)

impl<T1, T2, T3, T4> ElementwiseNeg for (T1, T2, T3, T4) where
    T1: Copy + Neg<Output = T1>,
    T2: Copy + Neg<Output = T2>,
    T3: Copy + Neg<Output = T3>,
    T4: Copy + Neg<Output = T4>, 

fn elementwise_neg(&self) -> (T1, T2, T3, T4)

impl<T1, T2, T3, T4, T5> ElementwiseNeg for (T1, T2, T3, T4, T5) where
    T1: Copy + Neg<Output = T1>,
    T2: Copy + Neg<Output = T2>,
    T3: Copy + Neg<Output = T3>,
    T4: Copy + Neg<Output = T4>,
    T5: Copy + Neg<Output = T5>, 

fn elementwise_neg(&self) -> (T1, T2, T3, T4, T5)

impl<T1, T2, T3, T4, T5, T6> ElementwiseNeg for (T1, T2, T3, T4, T5, T6) where
    T1: Copy + Neg<Output = T1>,
    T2: Copy + Neg<Output = T2>,
    T3: Copy + Neg<Output = T3>,
    T4: Copy + Neg<Output = T4>,
    T5: Copy + Neg<Output = T5>,
    T6: Copy + Neg<Output = T6>, 

fn elementwise_neg(&self) -> (T1, T2, T3, T4, T5, T6)

impl<T1, T2, T3, T4, T5, T6, T7> ElementwiseNeg for (T1, T2, T3, T4, T5, T6, T7) where
    T1: Copy + Neg<Output = T1>,
    T2: Copy + Neg<Output = T2>,
    T3: Copy + Neg<Output = T3>,
    T4: Copy + Neg<Output = T4>,
    T5: Copy + Neg<Output = T5>,
    T6: Copy + Neg<Output = T6>,
    T7: Copy + Neg<Output = T7>, 

fn elementwise_neg(&self) -> (T1, T2, T3, T4, T5, T6, T7)

impl<T1, T2, T3, T4, T5, T6, T7, T8> ElementwiseNeg for (T1, T2, T3, T4, T5, T6, T7, T8) where
    T1: Copy + Neg<Output = T1>,
    T2: Copy + Neg<Output = T2>,
    T3: Copy + Neg<Output = T3>,
    T4: Copy + Neg<Output = T4>,
    T5: Copy + Neg<Output = T5>,
    T6: Copy + Neg<Output = T6>,
    T7: Copy + Neg<Output = T7>,
    T8: Copy + Neg<Output = T8>, 

fn elementwise_neg(&self) -> (T1, T2, T3, T4, T5, T6, T7, T8)

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9> ElementwiseNeg for (T1, T2, T3, T4, T5, T6, T7, T8, T9) where
    T1: Copy + Neg<Output = T1>,
    T2: Copy + Neg<Output = T2>,
    T3: Copy + Neg<Output = T3>,
    T4: Copy + Neg<Output = T4>,
    T5: Copy + Neg<Output = T5>,
    T6: Copy + Neg<Output = T6>,
    T7: Copy + Neg<Output = T7>,
    T8: Copy + Neg<Output = T8>,
    T9: Copy + Neg<Output = T9>, 

fn elementwise_neg(&self) -> (T1, T2, T3, T4, T5, T6, T7, T8, T9)

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> ElementwiseNeg for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) where
    T1: Copy + Neg<Output = T1>,
    T2: Copy + Neg<Output = T2>,
    T3: Copy + Neg<Output = T3>,
    T4: Copy + Neg<Output = T4>,
    T5: Copy + Neg<Output = T5>,
    T6: Copy + Neg<Output = T6>,
    T7: Copy + Neg<Output = T7>,
    T8: Copy + Neg<Output = T8>,
    T9: Copy + Neg<Output = T9>,
    T10: Copy + Neg<Output = T10>, 

fn elementwise_neg(&self) -> (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> ElementwiseNeg for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) where
    T1: Copy + Neg<Output = T1>,
    T2: Copy + Neg<Output = T2>,
    T3: Copy + Neg<Output = T3>,
    T4: Copy + Neg<Output = T4>,
    T5: Copy + Neg<Output = T5>,
    T6: Copy + Neg<Output = T6>,
    T7: Copy + Neg<Output = T7>,
    T8: Copy + Neg<Output = T8>,
    T9: Copy + Neg<Output = T9>,
    T10: Copy + Neg<Output = T10>,
    T11: Copy + Neg<Output = T11>, 

fn elementwise_neg(&self) -> (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> ElementwiseNeg for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) where
    T1: Copy + Neg<Output = T1>,
    T2: Copy + Neg<Output = T2>,
    T3: Copy + Neg<Output = T3>,
    T4: Copy + Neg<Output = T4>,
    T5: Copy + Neg<Output = T5>,
    T6: Copy + Neg<Output = T6>,
    T7: Copy + Neg<Output = T7>,
    T8: Copy + Neg<Output = T8>,
    T9: Copy + Neg<Output = T9>,
    T10: Copy + Neg<Output = T10>,
    T11: Copy + Neg<Output = T11>,
    T12: Copy + Neg<Output = T12>, 

fn elementwise_neg(&self) -> (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)

impl ElementwiseNeg for f32

fn elementwise_neg(&self) -> f32

impl ElementwiseNeg for f64

fn elementwise_neg(&self) -> f64

impl ElementwiseNeg for isize

fn elementwise_neg(&self) -> isize

impl ElementwiseNeg for i8

fn elementwise_neg(&self) -> i8

impl ElementwiseNeg for i16

fn elementwise_neg(&self) -> i16

impl ElementwiseNeg for i32

fn elementwise_neg(&self) -> i32

impl ElementwiseNeg for i64

fn elementwise_neg(&self) -> i64

Loading content...

Implementors

Loading content...