Trait Abs 

pub trait Abs {
    type Output;

    // Required method
    fn abs(self) -> Self::Output;
}

Abs function in a component way

Required Associated Types

type Output

Required Methods

fn abs(self) -> Self::Output

Absolute value in a component way.

Overflow behavior

The absolute value of iX::MIN cannot be represented as an iX, and attempting to calculate it will cause an overflow. This means that code in debug mode will trigger a panic on this case and optimized code will return iX::MIN without a panic.

Can cause a panic for grid if the size mismatch

Implementations on Foreign Types

impl Abs for bool

type Output = bool

fn abs(self) -> bool

impl Abs for f32

type Output = f32

fn abs(self) -> f32

impl Abs for f64

type Output = f64

fn abs(self) -> f64

impl Abs for i8

type Output = i8

fn abs(self) -> i8

impl Abs for i16

type Output = i16

fn abs(self) -> i16

impl Abs for i32

type Output = i32

fn abs(self) -> i32

impl Abs for i64

type Output = i64

fn abs(self) -> i64

impl Abs for isize

type Output = isize

fn abs(self) -> isize

impl Abs for u8

type Output = u8

fn abs(self) -> u8

impl Abs for u16

type Output = u16

fn abs(self) -> u16

impl Abs for u32

type Output = u32

fn abs(self) -> u32

impl Abs for u64

type Output = u64

fn abs(self) -> u64

impl Abs for usize

type Output = usize

fn abs(self) -> usize

impl Abs for Saturating<bool>

type Output = Saturating<bool>

fn abs(self) -> Saturating<bool>

impl Abs for Saturating<f32>

type Output = Saturating<f32>

fn abs(self) -> Saturating<f32>

impl Abs for Saturating<f64>

type Output = Saturating<f64>

fn abs(self) -> Saturating<f64>

impl Abs for Saturating<i8>

type Output = Saturating<i8>

fn abs(self) -> Saturating<i8>

impl Abs for Saturating<i16>

type Output = Saturating<i16>

fn abs(self) -> Saturating<i16>

impl Abs for Saturating<i32>

type Output = Saturating<i32>

fn abs(self) -> Saturating<i32>

impl Abs for Saturating<i64>

type Output = Saturating<i64>

fn abs(self) -> Saturating<i64>

impl Abs for Saturating<isize>

type Output = Saturating<isize>

fn abs(self) -> Saturating<isize>

impl Abs for Saturating<u8>

type Output = Saturating<u8>

fn abs(self) -> Saturating<u8>

impl Abs for Saturating<u16>

type Output = Saturating<u16>

fn abs(self) -> Saturating<u16>

impl Abs for Saturating<u32>

type Output = Saturating<u32>

fn abs(self) -> Saturating<u32>

impl Abs for Saturating<u64>

type Output = Saturating<u64>

fn abs(self) -> Saturating<u64>

impl Abs for Saturating<usize>

type Output = Saturating<usize>

fn abs(self) -> Saturating<usize>

impl Abs for Wrapping<bool>

type Output = Wrapping<bool>

fn abs(self) -> Wrapping<bool>

impl Abs for Wrapping<f32>

type Output = Wrapping<f32>

fn abs(self) -> Wrapping<f32>

impl Abs for Wrapping<f64>

type Output = Wrapping<f64>

fn abs(self) -> Wrapping<f64>

impl Abs for Wrapping<i8>

type Output = Wrapping<i8>

fn abs(self) -> Wrapping<i8>

impl Abs for Wrapping<i16>

type Output = Wrapping<i16>

fn abs(self) -> Wrapping<i16>

impl Abs for Wrapping<i32>

type Output = Wrapping<i32>

fn abs(self) -> Wrapping<i32>

impl Abs for Wrapping<i64>

type Output = Wrapping<i64>

fn abs(self) -> Wrapping<i64>

impl Abs for Wrapping<isize>

type Output = Wrapping<isize>

fn abs(self) -> Wrapping<isize>

impl Abs for Wrapping<u8>

type Output = Wrapping<u8>

fn abs(self) -> Wrapping<u8>

impl Abs for Wrapping<u16>

type Output = Wrapping<u16>

fn abs(self) -> Wrapping<u16>

impl Abs for Wrapping<u32>

type Output = Wrapping<u32>

fn abs(self) -> Wrapping<u32>

impl Abs for Wrapping<u64>

type Output = Wrapping<u64>

fn abs(self) -> Wrapping<u64>

impl Abs for Wrapping<usize>

type Output = Wrapping<usize>

fn abs(self) -> Wrapping<usize>

Implementors

impl<S> Abs for S

where S: Map, <S as MapIntern>::Item: Abs,

type Output = <S as Map>::WithType<<<S as MapIntern>::Item as Abs>::Output>

impl<T> Abs for AngleOf<T>

where T: Abs<Output = T>,

type Output = AngleOf<T>

impl<T> Abs for TimeOf<T>

where T: Abs<Output = T>,

type Output = TimeOf<T>