Signaling-NaN simulator wrapper for f32/f64

signaling.rs

#[cfg(debug_assertions)] use std::ops::*;
#[cfg(debug_assertions)] use std::{f32, f64, fmt};

#[cfg(debug_assertions)]
#[derive(Copy, Clone, Debug)]
struct Signaling<T>(T);

#[cfg(debug_assertions)]
impl<T: fmt::Display> fmt::Display for Signaling<T> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.0)
    }
}

#[cfg(debug_assertions)]
impl<T: fmt::Debug> fmt::Debug for Signaling<T> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{:?}", self.0)
    }
}

macro_rules! checking_impl {
    ($t:ident, $trate:ident, $func:ident) => {
        #[cfg(debug_assertions)]
        impl $trate for Signaling<$t> {
            type Output = Self;
            
            fn $func(self, rhs: Self) -> Self {
                let res = (self.0).$func(rhs.0);
                if $t::is_nan(res) {
                    panic!("NaN");
                } else {
                    Signaling(res)
                }
            }
        }
    }
}

macro_rules! impl_ops {
    ($t:ident) => {
        checking_impl!($t, Add, add);
        checking_impl!($t, Sub, sub);
        checking_impl!($t, Mul, mul);
        checking_impl!($t, Div, div);
        checking_impl!($t, Rem, rem);
    }
}

impl_ops!(f32);
impl_ops!(f64);

#[cfg(not(debug_assertions))]
#[inline(always)]
#[allow(non_snake_case)]
fn Signaling<T>(t: T) -> T { t }

fn main() {
    println!("{:?}", Signaling(1.0) / Signaling(2.0));
    println!("{:?}", Signaling(0.0) / Signaling(0.0));
}