fix min/maximum for inputs containing both missing and NaN

Author: N5N3

base/reduce.jl

@@ -627,6 +627,13 @@ isgoodzero(::typeof(min), x) = isbadzero(max, x)
 
 function mapreduce_impl(f, op::Union{typeof(max), typeof(min)},
                         A::AbstractArrayOrBroadcasted, first::Int, last::Int)
+    # 1. This optimization gives different result from general fallback, if the inputs `f.(A)`
+    #    contains both 'missing' and 'Nan'.
+    # 2. For Integer cases, general fallback seems faster.
+    # Based the above reasons, only use this for AbstractFloat cases.
+    Eltype = _return_type(i -> f(A[i]), Tuple{Int})
+    Eltype <: AbstractFloat ||
+        return invoke(mapreduce_impl,Tuple{Any,Any,AbstractArrayOrBroadcasted,Int,Int},f,op,A,first,last)
     a1 = @inbounds A[first]
     v1 = mapreduce_first(f, op, a1)
     v2 = v3 = v4 = v1
@@ -635,10 +642,10 @@ function mapreduce_impl(f, op::Union{typeof(max), typeof(min)},
     simdstop  = start + chunk_len - 4
     while simdstop <= last - 3
         # short circuit in case of NaN or missing
-        (v1 == v1) === true || return v1
-        (v2 == v2) === true || return v2
-        (v3 == v3) === true || return v3
-        (v4 == v4) === true || return v4
+        v1 == v1 || return v1
+        v2 == v2 || return v2
+        v3 == v3 || return v3
+        v4 == v4 || return v4
         @inbounds for i in start:4:simdstop
             v1 = _fast(op, v1, f(A[i+0]))
             v2 = _fast(op, v2, f(A[i+1]))

test/reduce.jl

@@ -388,6 +388,9 @@ A = circshift(reshape(1:24,2,3,4), (0,1,1))
         @test maximum(x) === minimum(x) === missing
         @test extrema(x) === (missing, missing)
     end
+    # inputs containing both missing and NaN
+    minimum([NaN;zeros(255);missing]) === missing
+    maximum([NaN;zeros(255);missing]) === missing
 end
 
 # findmin, findmax, argmin, argmax