From 164e0da8a2e787e335b0c33966799b9ef62a606f Mon Sep 17 00:00:00 2001 From: Simon Byrne Date: Sat, 3 Nov 2018 14:21:29 -0700 Subject: [PATCH 1/5] add more methods and tests for reductions over empty arrays --- base/reduce.jl | 9 +++++++-- test/reduce.jl | 18 ++++++++++++++++++ 2 files changed, 25 insertions(+), 2 deletions(-) diff --git a/base/reduce.jl b/base/reduce.jl index 0fbcc5a8a2a45..fd396ae946ab2 100644 --- a/base/reduce.jl +++ b/base/reduce.jl @@ -231,6 +231,9 @@ reduce_empty(::typeof(*), ::Type{<:AbstractChar}) = "" reduce_empty(::typeof(&), ::Type{Bool}) = true reduce_empty(::typeof(|), ::Type{Bool}) = false +reduce_empty(::typeof(max), T::Type{<:AbstractFloat}) = typemin(T) +reduce_empty(::typeof(min), T::Type{<:AbstractFloat}) = typemax(T) + reduce_empty(::typeof(add_sum), T) = reduce_empty(+, T) reduce_empty(::typeof(add_sum), ::Type{T}) where {T<:SmallSigned} = zero(Int) reduce_empty(::typeof(add_sum), ::Type{T}) where {T<:SmallUnsigned} = zero(UInt) @@ -252,8 +255,10 @@ mapreduce_empty(::typeof(identity), op, T) = reduce_empty(op, T) mapreduce_empty(::typeof(abs), op, T) = abs(reduce_empty(op, T)) mapreduce_empty(::typeof(abs2), op, T) = abs2(reduce_empty(op, T)) -mapreduce_empty(f::typeof(abs), ::typeof(max), T) = abs(zero(T)) -mapreduce_empty(f::typeof(abs2), ::typeof(max), T) = abs2(zero(T)) +mapreduce_empty(::typeof(abs), ::typeof(max), T) = abs(zero(T)) +mapreduce_empty(::typeof(abs), ::typeof(min), T::Type{<:AbstractFloat}) = typemax(T) +mapreduce_empty(::typeof(abs2), ::typeof(max), T) = abs2(zero(T)) +mapreduce_empty(::typeof(abs2), ::typeof(min), T::Type{<:AbstractFloat}) = typemax(T) mapreduce_empty_iter(f, op, itr, ::HasEltype) = mapreduce_empty(f, op, eltype(itr)) mapreduce_empty_iter(f, op::typeof(&), itr, ::EltypeUnknown) = true diff --git a/test/reduce.jl b/test/reduce.jl index f2bdd30d21684..e45c83b89b67d 100644 --- a/test/reduce.jl +++ b/test/reduce.jl @@ -52,6 +52,8 @@ using .Main.OffsetArrays @test mapreduce(abs2, +, Float64[]) === 0.0 @test mapreduce(abs2, max, Float64[]) === 0.0 @test mapreduce(abs, max, Float64[]) === 0.0 +@test mapreduce(abs2, min, Float64[]) === Inf +@test mapreduce(abs, min, Float64[]) === Inf @test_throws ArgumentError mapreduce(abs2, &, Float64[]) @test_throws ArgumentError mapreduce(abs2, |, Float64[]) @@ -177,6 +179,22 @@ prod2(itr) = invoke(prod, Tuple{Any}, itr) @test_throws ArgumentError maximum(Int[]) @test_throws ArgumentError minimum(Int[]) +@test maximum(Float64[]) === -Inf +@test minimum(Float64[]) === +Inf + +@test maximum(Float32[]) === -Inf32 +@test minimum(Float32[]) === +Inf32 + +@test maximum(abs, Int[]) === 0 +@test_throws ArgumentError minimum(abs, Int[]) + +@test maximum(abs, Float64[]) === 0.0 +@test minimum(abs, Float64[]) === +Inf + +@test maximum(abs, Float32[]) === 0.0f0 +@test minimum(abs, Float32[]) === +Inf32 + + @test maximum(5) == 5 @test minimum(5) == 5 @test extrema(5) == (5, 5) From 41706b303db1f7a668a0de0fa82e860dcfc736cf Mon Sep 17 00:00:00 2001 From: Jameson Nash Date: Fri, 9 Apr 2021 18:45:12 -0400 Subject: [PATCH 2/5] Update base/reduce.jl --- base/reduce.jl | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/base/reduce.jl b/base/reduce.jl index 8b3d5db94d4cc..6c3988c6b8752 100644 --- a/base/reduce.jl +++ b/base/reduce.jl @@ -318,8 +318,8 @@ reduce_empty(::typeof(*), ::Type{<:AbstractChar}) = "" reduce_empty(::typeof(&), ::Type{Bool}) = true reduce_empty(::typeof(|), ::Type{Bool}) = false -reduce_empty(::typeof(max), ::Type{<:AbstractFloat}) where {T} = typemin(T) -reduce_empty(::typeof(min), ::Type{<:AbstractFloat}) where {T} = typemax(T) +reduce_empty(::typeof(max), T::Type{<:AbstractFloat}) = typemin(T) +reduce_empty(::typeof(min), T::Type{<:AbstractFloat}) = typemax(T) reduce_empty(::typeof(add_sum), ::Type{Union{}}) = _empty_reduce_error() reduce_empty(::typeof(add_sum), ::Type{T}) where {T} = reduce_empty(+, T) From 10880a31f2f864747a84a80d67af961f453f1e38 Mon Sep 17 00:00:00 2001 From: Simon Byrne Date: Tue, 23 Nov 2021 13:50:03 -0800 Subject: [PATCH 3/5] Update base/reduce.jl Co-authored-by: Takafumi Arakaki --- base/reduce.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/base/reduce.jl b/base/reduce.jl index 6c3988c6b8752..5b22a515b37d7 100644 --- a/base/reduce.jl +++ b/base/reduce.jl @@ -350,7 +350,7 @@ mapreduce_empty(::typeof(abs), op, T) = abs(reduce_empty(op, T)) mapreduce_empty(::typeof(abs2), op, T) = abs2(reduce_empty(op, T)) mapreduce_empty(::typeof(abs), ::typeof(max), T) = abs(zero(T)) -mapreduce_empty(::typeof(abs), ::typeof(min), T::Type{<:AbstractFloat}) = typemax(T) +mapreduce_empty(::typeof(abs), ::typeof(min), T) = typemax(abs(zero(T))) mapreduce_empty(::typeof(abs2), ::typeof(max), T) = abs2(zero(T)) mapreduce_empty(::typeof(abs2), ::typeof(min), T::Type{<:AbstractFloat}) = typemax(T) From c4bfbc23f763bf4e941aea43783ed7b2ccb3fcfe Mon Sep 17 00:00:00 2001 From: Simon Byrne Date: Tue, 23 Nov 2021 13:50:11 -0800 Subject: [PATCH 4/5] Update base/reduce.jl Co-authored-by: Takafumi Arakaki --- base/reduce.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/base/reduce.jl b/base/reduce.jl index 5b22a515b37d7..a6f1f66f1f0f3 100644 --- a/base/reduce.jl +++ b/base/reduce.jl @@ -352,7 +352,7 @@ mapreduce_empty(::typeof(abs2), op, T) = abs2(reduce_empty(op, T)) mapreduce_empty(::typeof(abs), ::typeof(max), T) = abs(zero(T)) mapreduce_empty(::typeof(abs), ::typeof(min), T) = typemax(abs(zero(T))) mapreduce_empty(::typeof(abs2), ::typeof(max), T) = abs2(zero(T)) -mapreduce_empty(::typeof(abs2), ::typeof(min), T::Type{<:AbstractFloat}) = typemax(T) +mapreduce_empty(::typeof(abs2), ::typeof(min), T) = typemax(abs2(zero(T))) # For backward compatibility: mapreduce_empty_iter(f, op, itr, ItrEltype) = From d1cdd532fb55b8fa8aa6a32817529bff72fd0028 Mon Sep 17 00:00:00 2001 From: Simon Byrne Date: Tue, 23 Nov 2021 13:50:20 -0800 Subject: [PATCH 5/5] Update base/reduce.jl Co-authored-by: Takafumi Arakaki --- base/reduce.jl | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/base/reduce.jl b/base/reduce.jl index a6f1f66f1f0f3..a3ac14673f857 100644 --- a/base/reduce.jl +++ b/base/reduce.jl @@ -318,8 +318,8 @@ reduce_empty(::typeof(*), ::Type{<:AbstractChar}) = "" reduce_empty(::typeof(&), ::Type{Bool}) = true reduce_empty(::typeof(|), ::Type{Bool}) = false -reduce_empty(::typeof(max), T::Type{<:AbstractFloat}) = typemin(T) -reduce_empty(::typeof(min), T::Type{<:AbstractFloat}) = typemax(T) +reduce_empty(::typeof(max), T) = typemin(T) +reduce_empty(::typeof(min), T) = typemax(T) reduce_empty(::typeof(add_sum), ::Type{Union{}}) = _empty_reduce_error() reduce_empty(::typeof(add_sum), ::Type{T}) where {T} = reduce_empty(+, T)