Since f32/f64 are defined as IEEE 754-2008 floating point types, I believe arithmetic operators on them should always follow the IEEE754 operations. But it would be ok to provide fast math semantics on operations over some wrapper type, if they can only be evaluated within the unsafe context like dereferencing raw pointers. This also solves method problems like `.sqrt()`

as the wrapper type can provides its own implementation of it with fast math semantics.

```
use std::num::FastMath;
let (a, b) = (3.0, 4.0);
let (c, d) = unsafe {
let ieee_754 = a + b;
let fast_math = FastMath(a) + FastMath(b);
(ieee_754, fast_math)
};
let e = FastMath(a) + FastMath(b); // compile error
```

But since we don't have any unsafe arithmetics yet, implementation would not be trivial. Also having it under nightly feature only prevents many users to have experiment with it. Instead, if the intrinsics themselves are available on stable, anything other can be implemented as a 3rd party crate with some macro and trait tricks.

```
use fast_math_helper::{fast_math, FastMath};
let (a, b) = (3.0, 4.0);
#[fast_math]
let (c, d) = unsafe {
let ieee_754 = a + b;
let fast_math = FastMath(a) + FastMath(b);
(ieee_754, fast_math)
};
let e = FastMath(a) + FastMath(b); // compile error
```