Add generic fallback to all scalar functions

src/NaNMath.jl

@@ -9,9 +9,20 @@
         ($f)(x::Float64) = ccall(($(string(f)),libm), Float64, (Float64,), x)
         ($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
 end
 
+for f in (:sqrt,)
+    @eval ($f)(x) = (Base.$f)(x)
+end
+
+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.
 sqrt(x::T) where {T<:AbstractFloat} = x < 0.0 ? T(NaN) : Base.sqrt(x)
@@ -22,11 +33,13 @@
 pow(x::Float32, y::Float32) = ccall((:powf,libm), Float32, (Float32,Float32), x, y)
 # We `promote` first before converting to floating pointing numbers to ensure that
 # e.g. `pow(::Float32, ::Int)` ends up calling `pow(::Float32, ::Float32)`
-pow(x::Number, y::Number) = pow(promote(x, y)...)
-pow(x::T, y::T) where {T<:Number} = pow(float(x), float(y))
+pow(x::Real, y::Real) = pow(promote(x, y)...)
+pow(x::T, y::T) where {T<:Real} = pow(float(x), float(y))
+pow(x, y) = ^(x, y)
 
 # The following combinations are safe, so we can fall back to ^
 pow(x::Number, y::Integer) = x^y
+pow(x::Real, y::Integer) = x^y
 pow(x::Complex, y::Complex) = x^y
 
 """

test/runtests.jl

@@ -83,3 +83,18 @@ using Test
 @test isnan(NaNMath.max(NaN, NaN))
 @test isnan(NaNMath.max(NaN))
 @test NaNMath.max(NaN, NaN, 0.0, 1.0) == 1.0
+
+# Test forwarding
+x = 1 + 2im
+for f in (:sin, :cos, :tan, :asin, :acos, :acosh, :atanh, :log, :log2, :log10,
+          :log1p, :sqrt)
+    @test @eval (NaNMath.$f)(x) == $f(x)
+end
+
+struct A end
+Base.isless(::A, ::A) = false
+y = A()
+for f in (:max, :min)
+    @test @eval (NaNMath.$f)(y, y) == $f(y, y)
+end
+@test NaNMath.pow(x, x) == ^(x, x)