Rely on libm for a no_std alternative to round_ties_even

Author: bushrat011899

Cargo.lock

@@ -91,6 +91,7 @@ hashbrown.workspace = true
 half = { workspace = true, default-features = false, features = ["num-traits"] }
 rustc-hash.workspace = true
 indexmap.workspace = true
+libm = { version = "0.2", default-features = false }
 log.workspace = true
 # `half` requires 0.2.16 for `FromBytes` and `ToBytes`.
 num-traits = { version = "0.2.16", default-features = false }

naga/Cargo.toml

@@ -1171,46 +1171,34 @@ impl<'a> ConstantEvaluator<'a> {
                 component_wise_float!(self, span, [arg], |e| { Ok([e.floor()]) })
             }
             crate::MathFunction::Round => {
-                /// Rounds to the nearest integer, with ties biasing towards an even result.
-                ///
-                /// # TODO
-                ///
-                /// - `round_ties_even` is not available on `half::f16` yet.
-                /// - It is also not available on `no_std`
-                ///
-                /// This polyfill is shamelessly [~~stolen from~~ inspired by `ndarray-image`][polyfill source],
-                /// which has licensing compatible with ours. See also
-                /// <https://github.com/rust-lang/rust/issues/96710>.
-                ///
-                /// [polyfill source]: https://github.com/imeka/ndarray-ndimage/blob/8b14b4d6ecfbc96a8a052f802e342a7049c68d8f/src/lib.rs#L98
-                fn round_ties_even<T: num_traits::float::FloatCore>(x: T) -> T {
-                    let half = (T::one() + T::one()).recip();
-
-                    if x.fract().abs() != half {
-                        x.round()
-                    } else {
-                        let i = x.abs().trunc();
-
-                        let value = if (i * half).fract() == half {
-                            // -1.5, 1.5, 3.5, ...
-                            x.abs() + half
-                        } else {
-                            // -0.5, 0.5, 2.5, ...
-                            x.abs() - half
-                        };
-
-                        if x.signum() != value.signum() {
-                            -value
-                        } else {
-                            value
+                component_wise_float(self, span, [arg], |e| match e {
+                    Float::Abstract([e]) => Ok(Float::Abstract([libm::rint(e)])),
+                    Float::F32([e]) => Ok(Float::F32([libm::rintf(e)])),
+                    Float::F16([e]) => {
+                        // TODO: `round_ties_even` is not available on `half::f16` yet.
+                        //
+                        // This polyfill is shamelessly [~~stolen from~~ inspired by `ndarray-image`][polyfill source],
+                        // which has licensing compatible with ours. See also
+                        // <https://github.com/rust-lang/rust/issues/96710>.
+                        //
+                        // [polyfill source]: https://github.com/imeka/ndarray-ndimage/blob/8b14b4d6ecfbc96a8a052f802e342a7049c68d8f/src/lib.rs#L98
+                        fn round_ties_even(x: f64) -> f64 {
+                            let i = x as i64;
+                            let f = (x - i as f64).abs();
+                            if f == 0.5 {
+                                if i & 1 == 1 {
+                                    // -1.5, 1.5, 3.5, ...
+                                    (x.abs() + 0.5).copysign(x)
+                                } else {
+                                    (x.abs() - 0.5).copysign(x)
+                                }
+                            } else {
+                                x.round()
+                            }
                         }
-                    }
-                }
 
-                component_wise_float(self, span, [arg], |e| match e {
-                    Float::Abstract([e]) => Ok(Float::Abstract([round_ties_even(e)])),
-                    Float::F32([e]) => Ok(Float::F32([round_ties_even(e)])),
-                    Float::F16([e]) => Ok(Float::F16([round_ties_even(e)])),
+                        Ok(Float::F16([(f16::from_f64(round_ties_even(f64::from(e))))]))
+                    }
                 })
             }
             crate::MathFunction::Fract => {