Trait GenNum

pub trait GenNum<E: BaseNum>:
    Copy
    + Sized
    + Clone
    + One
    + Zero
    + Div<Self, Output = Self>
    + Rem<Self, Output = Self>
    + Add<E, Output = Self>
    + Mul<E, Output = Self>
    + Rand {
    // Required methods
    fn from_s(x: E) -> Self;
    fn map<F>(self, f: F) -> Self
       where F: Fn(E) -> E;
    fn zip<F>(self, y: Self, f: F) -> Self
       where F: Fn(E, E) -> E;
    fn split<F>(self, f: F) -> (Self, Self)
       where F: Fn(E) -> (E, E);
    fn map2<F>(self, y: Self, f: F) -> (Self, Self)
       where F: Fn(E, E) -> (E, E);
}

Generic numeric type.

Required Methods

fn from_s(x: E) -> Self

Constructs from a scalar number.

fn map<F>(self, f: F) -> Self

where F: Fn(E) -> E,

fn zip<F>(self, y: Self, f: F) -> Self

where F: Fn(E, E) -> E,

fn split<F>(self, f: F) -> (Self, Self)

where F: Fn(E) -> (E, E),

fn map2<F>(self, y: Self, f: F) -> (Self, Self)

where F: Fn(E, E) -> (E, E),

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 GenNum<f32> for f32

fn from_s(x: f32) -> Self

fn map<F: Fn(f32) -> f32>(self, f: F) -> f32

fn zip<F: Fn(f32, f32) -> f32>(self, y: f32, f: F) -> f32

fn split<F: Fn(f32) -> (f32, f32)>(self, f: F) -> (f32, f32)

fn map2<F: Fn(f32, f32) -> (f32, f32)>(self, y: f32, f: F) -> (f32, f32)

impl GenNum<f64> for f64

fn from_s(x: f64) -> Self

fn map<F: Fn(f64) -> f64>(self, f: F) -> f64

fn zip<F: Fn(f64, f64) -> f64>(self, y: f64, f: F) -> f64

fn split<F: Fn(f64) -> (f64, f64)>(self, f: F) -> (f64, f64)

fn map2<F: Fn(f64, f64) -> (f64, f64)>(self, y: f64, f: F) -> (f64, f64)

impl GenNum<i32> for i32

fn from_s(x: i32) -> Self

fn map<F: Fn(i32) -> i32>(self, f: F) -> i32

fn zip<F: Fn(i32, i32) -> i32>(self, y: i32, f: F) -> i32

fn split<F: Fn(i32) -> (i32, i32)>(self, f: F) -> (i32, i32)

fn map2<F: Fn(i32, i32) -> (i32, i32)>(self, y: i32, f: F) -> (i32, i32)

impl GenNum<u32> for u32

fn from_s(x: u32) -> Self

fn map<F: Fn(u32) -> u32>(self, f: F) -> u32

fn zip<F: Fn(u32, u32) -> u32>(self, y: u32, f: F) -> u32

fn split<F: Fn(u32) -> (u32, u32)>(self, f: F) -> (u32, u32)

fn map2<F: Fn(u32, u32) -> (u32, u32)>(self, y: u32, f: F) -> (u32, u32)

Implementors

impl<T: BaseNum> GenNum<T> for Vector2<T>

impl<T: BaseNum> GenNum<T> for Vector3<T>

impl<T: BaseNum> GenNum<T> for Vector4<T>