Struct Fast

pub struct Fast<F>(/* private fields */);

“fast-math” wrapper for f32 and f64.

The Fast type enforces no invariant and can hold any f32, f64 values. See crate docs for more details.

Implementations

impl<F> Fast<F>

pub unsafe fn new(value: F) -> Self

Create a new fast value

Safety

The value can be used with the fast_fadd etc intrinsics without checks after it has been created like this. Refer to Rust and other sources for documentation on which operations are valid (might change with time).

Be wary of operations creating invalid values in Fast which they could potentially do depending on the operation.

Examples found in repository

examples/sums.rs (line 7)

pub unsafe fn fast_sum(xs: &[f64]) -> f64 {
    xs.iter().map(|&x| Fast::new(x)).fold(Fast::new(0.), |acc, x| acc + x).get()
}

// for demonstration purposes
pub unsafe fn fast_dot(xs: &[f64], ys: &[f64]) -> f64 {
    xs.iter().zip(ys).fold(Fast::new(0.), |acc, (&x, &y)| acc + Fast::new(x) * Fast::new(y)).get()
}

pub fn get(self) -> F

Get the inner value

Examples found in repository

examples/sums.rs (line 7)

pub unsafe fn fast_sum(xs: &[f64]) -> f64 {
    xs.iter().map(|&x| Fast::new(x)).fold(Fast::new(0.), |acc, x| acc + x).get()
}

// for demonstration purposes
pub unsafe fn fast_dot(xs: &[f64], ys: &[f64]) -> f64 {
    xs.iter().zip(ys).fold(Fast::new(0.), |acc, (&x, &y)| acc + Fast::new(x) * Fast::new(y)).get()
}

Trait Implementations

impl Add<Fast<f32>> for f32

type Output = Fast<f32>

The resulting type after applying the + operator.

fn add(self, rhs: Fast<f32>) -> Self::Output

Performs the + operation.

impl Add<Fast<f64>> for f64

type Output = Fast<f64>

The resulting type after applying the + operator.

fn add(self, rhs: Fast<f64>) -> Self::Output

Performs the + operation.

impl Add<f32> for Fast<f32>

type Output = Fast<f32>

The resulting type after applying the + operator.

fn add(self, rhs: f32) -> Self::Output

Performs the + operation.

impl Add<f64> for Fast<f64>

type Output = Fast<f64>

The resulting type after applying the + operator.

fn add(self, rhs: f64) -> Self::Output

Performs the + operation.

impl Add for Fast<f32>

type Output = Fast<f32>

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl Add for Fast<f64>

type Output = Fast<f64>

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl<F, Rhs> AddAssign<Rhs> for Fast<F>

where Self: Add<Rhs, Output = Self> + Copy,

fn add_assign(&mut self, rhs: Rhs)

Performs the += operation.

impl<F: Clone> Clone for Fast<F>

fn clone(&self) -> Fast<F>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<F: Debug> Debug for Fast<F>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<F: Display> Display for Fast<F>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Div<Fast<f32>> for f32

type Output = Fast<f32>

The resulting type after applying the / operator.

fn div(self, rhs: Fast<f32>) -> Self::Output

Performs the / operation.

impl Div<Fast<f64>> for f64

type Output = Fast<f64>

The resulting type after applying the / operator.

fn div(self, rhs: Fast<f64>) -> Self::Output

Performs the / operation.

impl Div<f32> for Fast<f32>

type Output = Fast<f32>

The resulting type after applying the / operator.

fn div(self, rhs: f32) -> Self::Output

Performs the / operation.

impl Div<f64> for Fast<f64>

type Output = Fast<f64>

The resulting type after applying the / operator.

fn div(self, rhs: f64) -> Self::Output

Performs the / operation.

impl Div for Fast<f32>

type Output = Fast<f32>

The resulting type after applying the / operator.

fn div(self, rhs: Self) -> Self::Output

Performs the / operation.

impl Div for Fast<f64>

type Output = Fast<f64>

The resulting type after applying the / operator.

fn div(self, rhs: Self) -> Self::Output

Performs the / operation.

impl<F, Rhs> DivAssign<Rhs> for Fast<F>

where Self: Div<Rhs, Output = Self> + Copy,

fn div_assign(&mut self, rhs: Rhs)

Performs the /= operation.

impl Into<f32> for Fast<f32>

fn into(self) -> f32

Converts this type into the (usually inferred) input type.

impl Into<f64> for Fast<f64>

fn into(self) -> f64

Converts this type into the (usually inferred) input type.

impl<F: LowerExp> LowerExp for Fast<F>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Mul<Fast<f32>> for f32

type Output = Fast<f32>

The resulting type after applying the * operator.

fn mul(self, rhs: Fast<f32>) -> Self::Output

Performs the * operation.

impl Mul<Fast<f64>> for f64

type Output = Fast<f64>

The resulting type after applying the * operator.

fn mul(self, rhs: Fast<f64>) -> Self::Output

Performs the * operation.

impl Mul<f32> for Fast<f32>

type Output = Fast<f32>

The resulting type after applying the * operator.

fn mul(self, rhs: f32) -> Self::Output

Performs the * operation.

impl Mul<f64> for Fast<f64>

type Output = Fast<f64>

The resulting type after applying the * operator.

fn mul(self, rhs: f64) -> Self::Output

Performs the * operation.

impl Mul for Fast<f32>

type Output = Fast<f32>

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self::Output

Performs the * operation.

impl Mul for Fast<f64>

type Output = Fast<f64>

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self::Output

Performs the * operation.

impl<F, Rhs> MulAssign<Rhs> for Fast<F>

where Self: Mul<Rhs, Output = Self> + Copy,

fn mul_assign(&mut self, rhs: Rhs)

Performs the *= operation.

impl<F: PartialEq> PartialEq for Fast<F>

fn eq(&self, other: &Fast<F>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<F: PartialOrd> PartialOrd for Fast<F>

fn partial_cmp(&self, other: &Fast<F>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Rem<Fast<f32>> for f32

type Output = Fast<f32>

The resulting type after applying the % operator.

fn rem(self, rhs: Fast<f32>) -> Self::Output

Performs the % operation.

impl Rem<Fast<f64>> for f64

type Output = Fast<f64>

The resulting type after applying the % operator.

fn rem(self, rhs: Fast<f64>) -> Self::Output

Performs the % operation.

impl Rem<f32> for Fast<f32>

type Output = Fast<f32>

The resulting type after applying the % operator.

fn rem(self, rhs: f32) -> Self::Output

Performs the % operation.

impl Rem<f64> for Fast<f64>

type Output = Fast<f64>

The resulting type after applying the % operator.

fn rem(self, rhs: f64) -> Self::Output

Performs the % operation.

impl Rem for Fast<f32>

type Output = Fast<f32>

The resulting type after applying the % operator.

fn rem(self, rhs: Self) -> Self::Output

Performs the % operation.

impl Rem for Fast<f64>

type Output = Fast<f64>

The resulting type after applying the % operator.

fn rem(self, rhs: Self) -> Self::Output

Performs the % operation.

impl<F, Rhs> RemAssign<Rhs> for Fast<F>

where Self: Rem<Rhs, Output = Self> + Copy,

fn rem_assign(&mut self, rhs: Rhs)

Performs the %= operation.

impl Sub<Fast<f32>> for f32

type Output = Fast<f32>

The resulting type after applying the - operator.

fn sub(self, rhs: Fast<f32>) -> Self::Output

Performs the - operation.

impl Sub<Fast<f64>> for f64

type Output = Fast<f64>

The resulting type after applying the - operator.

fn sub(self, rhs: Fast<f64>) -> Self::Output

Performs the - operation.

impl Sub<f32> for Fast<f32>

type Output = Fast<f32>

The resulting type after applying the - operator.

fn sub(self, rhs: f32) -> Self::Output

Performs the - operation.

impl Sub<f64> for Fast<f64>

type Output = Fast<f64>

The resulting type after applying the - operator.

fn sub(self, rhs: f64) -> Self::Output

Performs the - operation.

impl Sub for Fast<f32>

type Output = Fast<f32>

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl Sub for Fast<f64>

type Output = Fast<f64>

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl<F, Rhs> SubAssign<Rhs> for Fast<F>

where Self: Sub<Rhs, Output = Self> + Copy,

fn sub_assign(&mut self, rhs: Rhs)

Performs the -= operation.

impl<F: UpperExp> UpperExp for Fast<F>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<F: Copy> Copy for Fast<F>

impl<F> StructuralPartialEq for Fast<F>