Better fix

Author: nalimilan

base/reducedim.jl

@@ -150,15 +150,9 @@ for (f1, f2, initval, typeextreme) in ((:min, :max, :Inf, :typemax), (:max, :min
             if v0 isa Number && isnan(v0)
                 # v0 is NaN
                 v0 = oftype(v0, $initval)
-            elseif ismissing(v0)
-                if !all(ismissing, A)
-                    v0 = mapreduce(f, $f2, skipmissing(A))
-                end
-            elseif isunordered(v0) # v0 is a third-party unordered value
-                Tnm = nonmissingtype(Tr)
-                # TODO: Some types, like BigInt, don't support typemin/typemax.
-                # So a Matrix{Union{BigInt, T}} can still error here.
-                v0 = $typeextreme(Tnm)
+            elseif isunordered(v0) && !all(isunordered, A1)
+                # v0 is missing or a third-party unordered value
+                v0 = mapreduce(f, $f2, Iterators.filter(!isunordered, A1))
             end
             # v0 may have changed type.
             Tr = v0 isa T ? T : typeof(v0)
@@ -189,12 +183,11 @@ function reducedim_init(f::ExtremaMap, op::typeof(_extrema_rf), A::AbstractArray
 
     # but NaNs and missing need to be avoided as initial values
     if v0[1] isa Number && isnan(v0[1])
+        # v0 is NaN
         v0 = oftype(v0[1], Inf), oftype(v0[2], -Inf)
-    elseif isunordered(v0[1])
+    elseif isunordered(v0[1]) && !all(isunordered, A1)
         # v0 is missing or a third-party unordered value
-        # TODO: Some types, like BigInt, don't support typemin/typemax.
-        # So a Matrix{Union{BigInt, Missing}} can still error here.
-        v0 = typemax(nonmissingtype(Tmin)), typemin(nonmissingtype(Tmax))
+        v0 = reverse(mapreduce(f, op, Iterators.filter(!isunordered, A1)))
     end
     # v0 may have changed type.
     Tmin = v0[1] isa T ? T : typeof(v0[1])

test/reduce.jl

@@ -377,16 +377,6 @@ end
 @test maximum(Vector(Int16(1):Int16(100))) === Int16(100)
 @test maximum(Int32[1,2]) === Int32(2)
 
-@testset "minimum/maximum over dims with missing (#35308)" begin
-    for T in (Int, Float64, BigInt, BigFloat)
-        x = Union{T, Missing}[1 missing; 2 missing]
-        @test isequal(minimum(x, dims=1), reshape([1, missing], 1, :))
-        @test isequal(maximum(x, dims=1), reshape([2, missing], 1, :))
-        @test isequal(minimum(x, dims=2), reshape([missing, missing], :, 1))
-        @test isequal(maximum(x, dims=2), reshape([missing, missing], :, 1))
-    end
-end
-
 A = circshift(reshape(1:24,2,3,4), (0,1,1))
 @test extrema(A,dims=1) == reshape([(23,24),(19,20),(21,22),(5,6),(1,2),(3,4),(11,12),(7,8),(9,10),(17,18),(13,14),(15,16)],1,3,4)
 @test extrema(A,dims=2) == reshape([(19,23),(20,24),(1,5),(2,6),(7,11),(8,12),(13,17),(14,18)],2,1,4)

test/reducedim.jl

@@ -608,7 +608,7 @@ end
 end
 @testset "NaN/missing test for extrema with dims #43599" begin
     for sz = (3, 10, 100)
-        for T in (Int, Float64, BigFloat)
+        for T in (Int, Float64, BigFloat, BigInt)
             Aₘ = Matrix{Union{T, Missing}}(rand(-sz:sz, sz, sz))
             Aₘ[rand(1:sz*sz, sz)] .= missing
             unordered_test_for_extrema(Aₘ)
@@ -622,9 +622,16 @@ end
         end
     end
 end
-@test_broken minimum([missing;BigInt(1)], dims = 1)
-@test_broken maximum([missing;BigInt(1)], dims = 1)
-@test_broken extrema([missing;BigInt(1)], dims = 1)
+
+@testset "minimum/maximum over dims with missing (#35308)" begin
+    for T in (Int, Float64, BigInt, BigFloat)
+        x = Union{T, Missing}[1 missing; 2 missing]
+        @test isequal(minimum(x, dims=1), reshape([1, missing], 1, :))
+        @test isequal(maximum(x, dims=1), reshape([2, missing], 1, :))
+        @test isequal(minimum(x, dims=2), reshape([missing, missing], :, 1))
+        @test isequal(maximum(x, dims=2), reshape([missing, missing], :, 1))
+    end
+end
 
 # issue #26709
 @testset "dimensional reduce with custom non-bitstype types" begin