Trait ElementwiseNeg 

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

Required Methods

fn elementwise_neg(&self) -> Self

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl ElementwiseNeg for f32

fn elementwise_neg(&self) -> f32

impl ElementwiseNeg for f64

fn elementwise_neg(&self) -> f64

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

impl ElementwiseNeg for isize

fn elementwise_neg(&self) -> isize

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<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<T: Copy + Neg<Output = T>> ElementwiseNeg for LinkedList<T>

fn elementwise_neg(&self) -> LinkedList<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 Vec<T>

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

Implementors