use Base function rather than Libm ones since they're faster

Author: oscardssmith

src/NaNMath.jl

@@ -3,17 +3,54 @@ module NaNMath
 using OpenLibm_jll
 const libm = OpenLibm_jll.libopenlibm
 
-for f in (:sin, :cos, :tan, :asin, :acos, :acosh, :atanh, :log, :log2, :log10,
-          :lgamma, :log1p)
+for f in (:sin, :cos, :tan, :asin, :acos, :acosh, :atanh,
+          :log, :log2, :log10, :log1p, :lgamma)
+    @eval begin
+        function ($f)(x::Real)
+            fx = float(x)
+            x === xf && throw(MethodError($f, (x,)))
+            ($f)(fx)
+        end
+    end
+end
+
+for f in (:lgamma)
     @eval begin
         Base.@assume_effects :total ($f)(x::Float64) = ccall(($(string(f)),libm), Float64, (Float64,), x)
         Base.@assume_effects :total ($f)(x::Float32) = ccall(($(string(f,"f")),libm), Float32, (Float32,), x)
-        ($f)(x::Real) = ($f)(float(x))
-        if $f !== :lgamma
-            ($f)(x) = (Base.$f)(x)
+    end
+end
+
+for f in (:sin, :cos, :tan)
+    @eval begin
+        function ($f)(x::T) where T<:Union{Float16, Float32, Float64}
+            isinf(x) ? T(NaN) : (Base.$f)(x)
+        end
+    end
+end
+
+for f in (:asin, :acos, :atanh)
+    @eval begin
+        function ($f)(x::T) where T<:Union{Float16, Float32, Float64}
+            abs(x) > T(1) ? T(NaN) : (Base.$f)(x)
         end
     end
 end
+function acosh(x::T) where T<:Union{Float16, Float32, Float64}
+    x < T(1) ? T(NaN) : acosh(x)
+end
+
+for f in (:log, :log2, :log10)
+    @eval begin
+        function ($f)(x::T) where T<:Union{Float16, Float32, Float64}
+            x < 0 ? T(NaN) : (Base.$f)(x)
+        end
+    end
+end
+
+function log1p(x::T) where T<:Union{Float16, Float32, Float64}
+    x < T(-1) ? T(NaN) : Base.log1p(x)
+end
 
 for f in (:sqrt,)
     @eval ($f)(x) = (Base.$f)(x)
@@ -23,10 +60,8 @@ for f in (:max, :min)
     @eval ($f)(x, y) = (Base.$f)(x, y)
 end
 
-# Would be more efficient to remove the domain check in Base.sqrt(),
-# but this doesn't seem easy to do.
-Base.@assume_effects :nothrow sqrt(x::T) where {T<:Union{Float16, Float32, Float64}} = x < 0.0 ? T(NaN) : Base.sqrt(x)
-sqrt(x::T) where {T<:AbstractFloat} = x < 0.0 ? T(NaN) : Base.sqrt(x)
+sqrt(x::T) where {T<:Union{Float16, Float32, Float64}} = x < T(0) ? T(NaN) : Base.Intrinsics.sqrt_llvm(x)
+sqrt(x::T) where {T<:AbstractFloat} = x < T(0) ? T(NaN) : Base.sqrt(x)
 sqrt(x::Real) = sqrt(float(x))
 
 # Don't override built-in ^ operator