rust ffast-math (defunct, use lower)
Diffstat (limited to 'src/generic_float.rs')
| -rw-r--r-- | src/generic_float.rs | 336 |
1 files changed, 336 insertions, 0 deletions
diff --git a/src/generic_float.rs b/src/generic_float.rs new file mode 100644 index 0000000..752441c --- /dev/null +++ b/src/generic_float.rs @@ -0,0 +1,336 @@ +//! provides generic float traits. +//! this is the best way to make a function possibly take a [`FFloat`]. +//! ``` +//! # use umath::*; +//! /// this function can take anything that implements Float, and "works with" a f32: it can be added to a f32, it can be created from a f32, etc. +//! /// with no external implementations, this can take either f32 or FFloat<f32>. +//! fn takes_float<F: Float<f32>>(f: F) {} +//! ``` +use crate::{FFloat, FastFloat}; +use core::ops::{ + Add, AddAssign, Deref, Div, DivAssign, Mul, MulAssign, Neg, Rem, RemAssign, Sub, SubAssign, +}; +#[cfg(doc)] +use std::f32::{INFINITY as INF, NAN}; + +macro_rules! simp { + ($doc:literal trait $trat:ident with $($name:ident),+) => { + #[doc = $doc] + pub trait $trat { + $( + #[doc = concat!("Refer to [`f32::", stringify!($name), "`]")] + fn $name(self) -> Self; + )+ + } + + impl $trat for f32 { $(fn $name(self) -> Self { self.$name() })+ } + impl $trat for f64 { $(fn $name(self) -> Self { self.$name() })+ } + impl<T: FastFloat + Trig + Rounding> $trat for FFloat<T> { $(fn $name(self) -> Self { unsafe { FFloat::new(self.deref().$name()) } })+ } + }; +} + +simp!["Trigonometry functions" trait Trig with sin, asin, sinh, asinh, cos, acos, cosh, acosh, tan, atan, tanh, atanh]; +simp!["Rounding functions" trait Rounding with floor, ceil, round]; + +macro_rules! ctor { + ($for:ty) => { + impl Constructors for $for { + /// Returns 0. This function is safe to call. + unsafe fn zero() -> $for { + 0.0 + } + + /// Returns 1. This function is safe to call. + unsafe fn one() -> $for { + 1.0 + } + + #[doc = concat!("Returns [`", stringify!($for), "::MIN`]. This function is safe to call")] + unsafe fn min() -> $for { + <$for>::MIN + } + + #[doc = concat!("Returns [`", stringify!($for), "::MAX`]. This function is safe to call")] + unsafe fn max() -> $for { + <$for>::MAX + } + } + }; +} + +ctor!(f32); +ctor!(f64); + +/// Float constructors. +pub trait Constructors { + /// Returns 0. + #[doc = include_str!("refer.md")] + unsafe fn zero() -> Self; + + /// Returns 1. + #[doc = include_str!("refer.md")] + unsafe fn one() -> Self; + + /// Returns the minimum value for this float. + #[doc = include_str!("refer.md")] + unsafe fn min() -> Self; + + /// Returns the maximum value for this float. + #[doc = include_str!("refer.md")] + unsafe fn max() -> Self; +} + +/// Generic float trait, implemented by {[`FFloat`], [`f32`], [`f64`]}. +/// The main purpose of this is to be taken (generically) by optionally fast functions. +/// +/// If there is a method you would like to see on this trait, please open a issue. +/// +/// Do note that the implementations of these functions are provided by std. +/// These functions are not likely to be faster than the std counterparts, unless the implementation is software provided and can benefit from fast math. +/// +/// # Safety +/// +/// Please note that calling these functions on a [`FFloat`] _may_ incur UB. +/// These functions are not marked `unsafe`, as the entire [`FFloat`] type is essentially unsafe. +/// Calling these functions on a [`f32`] is perfectly safe, even the `unsafe` marked functions (although theres not much point in doing so). +pub trait Float<F>: + PartialEq + + PartialOrd + + PartialOrd<F> + + Copy + + Trig + + Rounding + + Constructors + + Add<Self, Output = Self> + + Add<F, Output = Self> + + Sub<Self, Output = Self> + + Sub<F, Output = Self> + + Mul<Self, Output = Self> + + Mul<F, Output = Self> + + Rem<Self, Output = Self> + + Rem<F, Output = Self> + + Div<Self, Output = Self> + + Neg<Output = Self> + + Div<F, Output = Self> + + AddAssign<Self> + + AddAssign<F> + + SubAssign<Self> + + SubAssign<F> + + MulAssign<Self> + + MulAssign<F> + + DivAssign<Self> + + DivAssign<F> + + RemAssign<Self> + + RemAssign<F> +where + Self: Sized, +{ + /// Returns a new [`Self`] from the float. + #[doc = include_str!("refer.md")] + unsafe fn new(from: F) -> Self; + + /// Returns this float + fn take(self) -> F; + + /// Refer to [`f32::trunc`] + fn trunc(self) -> Self; + + /// Refer to [`f32::fract`] + fn fract(self) -> Self; + + /// Refer to [`f32::abs`] + fn abs(self) -> Self; + + /// Refer to [`f32::powi`] + fn powi(self, n: i32) -> Self; + + /// Refer to [`f32::powf`] + fn powf(self, n: Self) -> Self; + + /// Refer to [`f32::sqrt`] + fn sqrt(self) -> Self; + + /// Refer to [`f32::cbrt`] + fn cbrt(self) -> Self; + + /// Refer to [`f32::hypot`] + fn hypot(self, other: Self) -> Self; + + /// Refer to [`f32::exp2`] + fn exp2(self) -> Self; + + /// Refer to [`f32::ln`] + fn ln(self) -> Self; + + /// Refer to [`f32::log`] + fn log(self, base: Self) -> Self; + + /// Refer to [`f32::min`] + fn min(self, other: Self) -> Self; + + /// Refer to [`f32::max`] + fn max(self, other: Self) -> Self; +} + +macro_rules! impf { + ($for:ty) => { + impl Float<$for> for $for { + /// Returns the input value. This function is safe to call. + unsafe fn new(from: $for) -> $for { + from + } + fn take(self) -> $for { + self + } + fn trunc(self) -> $for { + self.trunc() + } + fn fract(self) -> $for { + self.fract() + } + fn abs(self) -> $for { + self.abs() + } + fn powi(self, n: i32) -> $for { + self.powi(n) + } + fn powf(self, n: $for) -> $for { + self.powf(n) + } + fn sqrt(self) -> $for { + self.sqrt() + } + fn cbrt(self) -> $for { + self.cbrt() + } + fn hypot(self, other: Self) -> $for { + self.hypot(other) + } + fn exp2(self) -> $for { + self.exp2() + } + fn ln(self) -> $for { + self.ln() + } + fn log(self, base: Self) -> Self { + self.log(base) + } + fn min(self, other: Self) -> Self { + self.min(other) + } + fn max(self, other: Self) -> Self { + self.max(other) + } + } + }; +} + +impf!(f32); +impf!(f64); + +impl<F: FastFloat + Constructors> Constructors for FFloat<F> { + /// Create a new [`FFloat`] representing `0.0`. + #[doc = include_str!("ffloat_safety_noconstr.md")] + unsafe fn zero() -> Self { + Self::new(F::zero()) + } + /// Create a new [`FFloat`] representing `1.0`. + #[doc = include_str!("ffloat_safety_noconstr.md")] + unsafe fn one() -> Self { + Self::new(F::one()) + } + /// Create a new [`FFloat`] representing the minimum value for the inner float.. + #[doc = include_str!("ffloat_safety_noconstr.md")] + unsafe fn min() -> Self { + Self::new(F::min()) + } + /// Create a new [`FFloat`] representing the maximum value for the inner float.. + #[doc = include_str!("ffloat_safety_noconstr.md")] + unsafe fn max() -> Self { + Self::new(F::max()) + } +} + +macro_rules! reuse { + (fn $name:ident) => { + #[doc = concat!("Refer to [`f32::", stringify!($name), "`]")] + #[doc = include_str!("ffloat_safety_notice.md")] + fn $name(self) -> Self { + self.check(); + unsafe { Self::new(self.0.$name()) } + } + }; +} + +impl<F: FastFloat + Float<F>> Float<F> for FFloat<F> { + /// Create a new [`FFloat`] from your {[`f32`], [`f64`]} + #[doc = include_str!("ffloat_safety.md")] + unsafe fn new(from: F) -> Self { + Self::new(from) + } + + fn take(self) -> F { + self.0 + } + + reuse!(fn trunc); + reuse!(fn fract); + reuse!(fn abs); + + /// Refer to [`f32::powi`] + #[doc = include_str!("ffloat_safety_notice.md")] + fn powi(self, n: i32) -> Self { + unsafe { Self::new(self.0.powi(n)) } + } + + /// Refer to [`f32::powf`] + #[doc = include_str!("ffloat_safety_notice.md")] + fn powf(self, n: Self) -> Self { + self.check(); + unsafe { Self::new(self.0.powf(*n)) } + } + + reuse!(fn sqrt); + reuse!(fn cbrt); + /// Refer to [`f32::hypot`] + #[doc = include_str!("ffloat_safety_notice.md")] + fn hypot(self, other: Self) -> Self { + self.check(); + unsafe { Self::new(self.0.hypot(*other)) } + } + reuse!(fn exp2); + reuse!(fn ln); + + /// Refer to [`f32::log`] + #[doc = include_str!("ffloat_safety_notice.md")] + fn log(self, base: Self) -> Self { + self.check(); + unsafe { Self::new(self.0.log(*base)) } + } + + /// Refer to [`f32::min`] + #[doc = include_str!("ffloat_safety_notice.md")] + fn min(self, other: Self) -> Self { + self.check(); + unsafe { Self::new(self.0.min(*other)) } + } + + /// Refer to [`f32::max`] + #[doc = include_str!("ffloat_safety_notice.md")] + fn max(self, other: Self) -> Self { + self.check(); + unsafe { Self::new(self.0.max(*other)) } + } +} + +#[test] +fn usable() { + fn cos<F: Float<f32>>(x: F) -> F { + let mut y = x * (1.0 / 6.283); + y -= (y + 0.25).floor() + 0.25; + y *= (y.abs() - 0.5) * 16.0; + return y; + } + assert!((0.995..0.996).contains(&cos(0.1))); + assert!((0.995..0.996).contains(&*cos(unsafe { FFloat::new(0.1) }))); +} |