fix up up up

Author: seiko2plus

npsr/precise.h

@@ -46,21 +46,38 @@ struct Subnormal {
 class FPExceptions {
  public:
   static constexpr auto kNone = 0;
+// guard against missing macros on some platforms
+// (e.g. Emscripten)
+#ifdef FE_INVALID
   static constexpr auto kInvalid = FE_INVALID;
+#else
+  static constexpr auto kInvalid = 0;
+#endif
+#ifdef FE_DIVBYZERO
   static constexpr auto kDivByZero = FE_DIVBYZERO;
+#else
+  static constexpr auto kDivByZero = 0;
+#endif
+#ifdef FE_OVERFLOW
   static constexpr auto kOverflow = FE_OVERFLOW;
+#else
+  static constexpr auto kOverflow = 0;
+#endif
+#ifdef FE_UNDERFLOW
   static constexpr auto kUnderflow = FE_UNDERFLOW;
+#else
+  static constexpr auto kUnderflow = 0;
+#endif
+  static constexpr auto kAll = kInvalid | kDivByZero | kOverflow | kUnderflow;
 
   void Raise(int errors) noexcept { mask_ |= errors; }
 
  protected:
-  void Load() noexcept {
-    loaded_ = std::fegetexceptflag(&saved_, FE_ALL_EXCEPT) == 0;
-  }
+  void Load() noexcept { loaded_ = std::fegetexceptflag(&saved_, kAll) == 0; }
 
   ~FPExceptions() noexcept {
     if (loaded_) {
-      std::fesetexceptflag(&saved_, FE_ALL_EXCEPT);
+      std::fesetexceptflag(&saved_, kAll);
     }
     if (mask_ != kNone) {
       std::feraiseexcept(mask_);

npsr/trig/inl.h

@@ -55,25 +55,26 @@ HWY_API V SinCos(Prec &prec, V x) {
   constexpr bool kIsSingle = std::is_same_v<TFromV<V>, float>;
   const DFromV<V> d;
   V ret;
-
   // Step 1: Select base algorithm based on accuracy requirements
   if constexpr (Prec::kLowAccuracy) {
     // Low precision: Cody-Waite reduction with degree-9 polynomial
-    // Error: ~1-2 ULP
+    // Error: ~2 ULP and 3~ for non-fma
     ret = Low<IS_COS>(x);
   } else {
     // High precision: π/16 reduction with table lookup + polynomial
-    // Error: ~0.5 ULP
+    // Error: ~1 ULP
     ret = High<IS_COS>(x);
   }
-
   // Step 2: Handle special cases (NaN, Inf) if enabled
   auto is_finite = IsFinite(x);
   if constexpr (Prec::kSpecialCases) {
     // IEEE 754 requires: sin(±∞) = NaN, cos(±∞) = NaN
     ret = IfThenElse(is_finite, ret, NaN(d));
+    // -0.0 should return -0.0 for sine
+    if constexpr (!IS_COS) {
+      ret = IfThenElse(Eq(x, Set(d, 0.0)), x, ret);
+    }
   }
-
   // Step 3: Handle very large arguments if enabled
   // For |x| > threshold, standard algorithms lose precision due to
   // catastrophic cancellation in x - n*π reduction
@@ -91,12 +92,10 @@ HWY_API V SinCos(Prec &prec, V x) {
       ret = IfThenElse(has_large_arg, Extended<IS_COS>(x), ret);
     }
   }
-
   // Step 4: Raise invalid operation exception for infinity inputs
   if constexpr (Prec::kExceptions) {
     prec.Raise(!AllFalse(d, IsInf(x)) ? FPExceptions::kInvalid : 0);
   }
-
   return ret;
 }
 

tools/sollya/cli.py

@@ -64,11 +64,11 @@ def format_duration(seconds: float) -> str:
     """Format duration in human-readable format."""
     match seconds:
         case s if s < 1:
-            return f"{s*1000:.0f}ms"
+            return f"{s * 1000:.0f}ms"
         case s if s < 60:
             return f"{s:.1f}s"
         case s:
-            return f"{int(s//60)}m {int(s%60)}s"
+            return f"{int(s // 60)}m {int(s % 60)}s"
 
 
 def check_sollya_available() -> bool: