Remove bugged and typically slower minimum/maximum method (#58267)

This method intends to be a SIMD-able optimization for reductions with
`min` and `max`, but it fails to achieve those goals on nearly every
architecture. For example, on my Mac M1 the generic implementation is
more than **6x** faster than this method.

Fixes #45932, fixes #36412, fixes #36081.

---------

Co-authored-by: Mosè Giordano <[email protected]>
(cherry picked from commit 99ba3c7)

Author: 2 people

base/reduce.jl

@@ -609,63 +609,6 @@ julia> prod(1:5; init = 1.0)
 prod(a; kw...) = mapreduce(identity, mul_prod, a; kw...)
 
 ## maximum, minimum, & extrema
-_fast(::typeof(min),x,y) = min(x,y)
-_fast(::typeof(max),x,y) = max(x,y)
-function _fast(::typeof(max), x::AbstractFloat, y::AbstractFloat)
-    ifelse(isnan(x),
-        x,
-        ifelse(x > y, x, y))
-end
-
-function _fast(::typeof(min),x::AbstractFloat, y::AbstractFloat)
-    ifelse(isnan(x),
-        x,
-        ifelse(x < y, x, y))
-end
-
-isbadzero(::typeof(max), x::AbstractFloat) = (x == zero(x)) & signbit(x)
-isbadzero(::typeof(min), x::AbstractFloat) = (x == zero(x)) & !signbit(x)
-isbadzero(op, x) = false
-isgoodzero(::typeof(max), x) = isbadzero(min, x)
-isgoodzero(::typeof(min), x) = isbadzero(max, x)
-
-function mapreduce_impl(f, op::Union{typeof(max), typeof(min)},
-                        A::AbstractArrayOrBroadcasted, first::Int, last::Int)
-    a1 = @inbounds A[first]
-    v1 = mapreduce_first(f, op, a1)
-    v2 = v3 = v4 = v1
-    chunk_len = 256
-    start = first + 1
-    simdstop  = start + chunk_len - 4
-    while simdstop <= last - 3
-        for i in start:4:simdstop
-            v1 = _fast(op, v1, f(@inbounds(A[i+0])))
-            v2 = _fast(op, v2, f(@inbounds(A[i+1])))
-            v3 = _fast(op, v3, f(@inbounds(A[i+2])))
-            v4 = _fast(op, v4, f(@inbounds(A[i+3])))
-        end
-        checkbounds(A, simdstop+3)
-        start += chunk_len
-        simdstop += chunk_len
-    end
-    v = op(op(v1,v2),op(v3,v4))
-    for i in start:last
-        @inbounds ai = A[i]
-        v = op(v, f(ai))
-    end
-
-    # enforce correct order of 0.0 and -0.0
-    # e.g. maximum([0.0, -0.0]) === 0.0
-    # should hold
-    if isbadzero(op, v)
-        for i in first:last
-            x = @inbounds A[i]
-            isgoodzero(op,x) && return x
-        end
-    end
-    return v
-end
-
 """
     maximum(f, itr; [init])
 

test/reduce.jl

@@ -299,19 +299,37 @@ end
             arr = zeros(N)
             @test minimum(arr) === 0.0
             @test maximum(arr) === 0.0
+            @test minimum(abs, arr) === 0.0
+            @test maximum(abs, arr) === 0.0
+            @test minimum(-, arr) === -0.0
+            @test maximum(-, arr) === -0.0
 
             arr[i] = -0.0
             @test minimum(arr) === -0.0
             @test maximum(arr) ===  0.0
+            @test minimum(abs, arr) === 0.0
+            @test maximum(abs, arr) === 0.0
+            @test minimum(-, arr) === -0.0
+            @test maximum(-, arr) ===  0.0
 
             arr = -zeros(N)
             @test minimum(arr) === -0.0
             @test maximum(arr) === -0.0
+            @test minimum(abs, arr) === 0.0
+            @test maximum(abs, arr) === 0.0
+            @test minimum(-, arr) === 0.0
+            @test maximum(-, arr) === 0.0
             arr[i] = 0.0
             @test minimum(arr) === -0.0
-            @test maximum(arr) === 0.0
+            @test maximum(arr) ===  0.0
+            @test minimum(abs, arr) === 0.0
+            @test maximum(abs, arr) === 0.0
+            @test minimum(-, arr) === -0.0
+            @test maximum(-, arr) ===  0.0
         end
     end
+
+    @test minimum(abs, fill(-0.0, 16)) === mapreduce(abs, (x,y)->min(x,y), fill(-0.0, 16)) === 0.0
 end
 
 @testset "maximum works on generic order #30320" begin