Trait Float 

pub trait Float:
    Float
    + Sealed
    + KernelItem
    + Source<Self> {
    type Working: Native;
    type OrderKey: RadixKey + Key;

    // Required methods
    fn working(self) -> Self::Working;
    fn from_working(t: Self::Working) -> Self;
    fn wide(self) -> f64;
    fn narrow(x: f64) -> Self;
    fn next_up(self) -> Self;
    fn next_down(self) -> Self;
    fn round_ties_even(self) -> Self;
    fn order_key(self) -> Self::OrderKey;
    fn total_key(self) -> Self::OrderKey;
    fn from_order_key(k: Self::OrderKey) -> Self;
    fn choose(
        x: Arg<'_, Self>,
        y: Arg<'_, Self>,
        mask: Arg<'_, Self>,
        n: usize,
        out: &mut Slots<'_, Self>,
    ) -> bool;
}

A float type that rustymath’s functions take: half::f16, f32 or f64.

Required Associated Types

type Working: Native

The type this float computes in, its working precision: f32 for f16, and the type itself otherwise. A function of an f16 computes in f32 and rounds once. Sums keep their running totals in this type.

type OrderKey: RadixKey + Key

The unsigned type, of this float’s width, that order_key gives.

Required Methods

fn working(self) -> Self::Working

This float in its working type, which holds it exactly.

fn from_working(t: Self::Working) -> Self

t rounded to this type.

fn wide(self) -> f64

This float as an f64, which holds it exactly.

fn narrow(x: f64) -> Self

x rounded to the nearest float of this type.

fn next_up(self) -> Self

The least float of this type above self, as f64::next_up gives it.

fn next_down(self) -> Self

The greatest float of this type below self, as f64::next_down gives it.

fn round_ties_even(self) -> Self

Rounds to the nearest whole number, with ties to even.

fn order_key(self) -> Self::OrderKey

A key whose unsigned order is the order of total_cmp, after ¯0 becomes 0 and every NaN becomes one NaN. So ¯0 and 0 share a key, NaN’s key follows every other, and two floats match exactly when their keys are equal.

fn total_key(self) -> Self::OrderKey

A key whose unsigned order is the order of total_cmp, after every NaN becomes positive. So ¯0’s key comes just before 0’s, every NaN’s follows ∞’s, and from_order_key reads the float back exactly, apart from a NaN’s sign. Sorts and selections compare these keys and write floats back from them.

fn from_order_key(k: Self::OrderKey) -> Self

The float whose order_key or total_key is k. A total key reads back exactly, apart from a NaN’s sign. An order key reads ¯0 back as 0, and every NaN as one NaN.

fn choose( x: Arg<'_, Self>, y: Arg<'_, Self>, mask: Arg<'_, Self>, n: usize, out: &mut Slots<'_, Self>, ) -> bool

Writes x where mask’s lanes aren’t zero and y where they are into the next n slots of out, through Choose, and gives whether every result succeeded. Fused graphs pass a comparison’s lanes of 1 and 0 as the mask.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl Float for f16

type Working = f32

type OrderKey = u16

fn working(self) -> f32

fn from_working(t: f32) -> Self

fn wide(self) -> f64

fn narrow(x: f64) -> Self

fn choose( x: Arg<'_, Self>, y: Arg<'_, Self>, mask: Arg<'_, Self>, n: usize, out: &mut Slots<'_, Self>, ) -> bool

fn next_up(self) -> Self

fn next_down(self) -> Self

fn round_ties_even(self) -> Self

fn order_key(self) -> u16

fn total_key(self) -> u16

fn from_order_key(k: u16) -> Self

impl Float for f32

type Working = f32

type OrderKey = u32

fn working(self) -> f32

fn from_working(t: f32) -> f32

fn wide(self) -> f64

fn narrow(x: f64) -> f32

fn choose( x: Arg<'_, f32>, y: Arg<'_, f32>, mask: Arg<'_, f32>, n: usize, out: &mut Slots<'_, f32>, ) -> bool

fn next_up(self) -> f32

fn next_down(self) -> f32

fn round_ties_even(self) -> Self

fn order_key(self) -> u32

fn total_key(self) -> u32

fn from_order_key(k: u32) -> Self

impl Float for f64

type Working = f64

type OrderKey = u64

fn working(self) -> f64

fn from_working(t: f64) -> f64

fn wide(self) -> f64

fn narrow(x: f64) -> f64

fn choose( x: Arg<'_, f64>, y: Arg<'_, f64>, mask: Arg<'_, f64>, n: usize, out: &mut Slots<'_, f64>, ) -> bool

fn next_up(self) -> f64

fn next_down(self) -> f64

fn round_ties_even(self) -> Self

fn order_key(self) -> u64

fn total_key(self) -> u64

fn from_order_key(k: u64) -> Self

Implementors