WIP: The great pairwise reduction refactor

NEWS.md

@@ -58,6 +58,12 @@ New library features
 Standard library changes
 ------------------------
 
+* Empty dimensional reductions (`reduce`, `mapreduce`, `sum`, `minimum`, etc., with the `dims` keyword
+  selecting one or more dimensions) now behave like their whole-array (`dims=:`) counterparts,
+  only returning values in unambiguous cases and erroring otherwise.  For example,
+  `minimum([], dims=2)` is now an error; it would previously return an empty array.
+  This can be addressed by specifying an `init` keyword argument as the error message directs.
+
 #### JuliaSyntaxHighlighting
 
 #### LinearAlgebra

base/broadcast.jl

@@ -236,13 +236,11 @@ Base.similar(::Broadcasted{ArrayConflict}, ::Type{Bool}, dims) =
     similar(BitArray, dims)
 
 @inline Base.axes(bc::Broadcasted) = _axes(bc, bc.axes)
+@inline Base.axes(bc::Broadcasted, d::Integer) = get(axes(bc), d, OneTo(1))
 _axes(::Broadcasted, axes::Tuple) = axes
 @inline _axes(bc::Broadcasted, ::Nothing)  = combine_axes(bc.args...)
 _axes(bc::Broadcasted{<:AbstractArrayStyle{0}}, ::Nothing) = ()
 
-@inline Base.axes(bc::Broadcasted{<:Any, <:NTuple{N}}, d::Integer) where N =
-    d <= N ? axes(bc)[d] : OneTo(1)
-
 BroadcastStyle(::Type{<:Broadcasted{Style}}) where {Style} = Style()
 BroadcastStyle(::Type{<:Broadcasted{S}}) where {S<:Union{Nothing,Unknown}} =
     throw(ArgumentError("Broadcasted{Unknown} wrappers do not have a style assigned"))
@@ -266,6 +264,7 @@ Base.ndims(bc::Broadcasted) = ndims(typeof(bc))
 Base.ndims(::Type{<:Broadcasted{<:Any,<:NTuple{N,Any}}}) where {N} = N
 
 Base.size(bc::Broadcasted) = map(length, axes(bc))
+Base.size(bc::Broadcasted, d::Integer) = length(axes(bc, d))
 Base.length(bc::Broadcasted) = prod(size(bc))
 
 function Base.iterate(bc::Broadcasted)

base/cartesian.jl

@@ -402,7 +402,7 @@ function exprresolve_conditional(ex::Expr)
                 return true, exprresolve_cond_dict[callee](ex.args[2], ex.args[3])
             end
         end
-    elseif Meta.isexpr(ex, :block, 2) && ex.args[1] isa LineNumberNode
+    elseif ex.head === :block && length(ex.args) == 2 && ex.args[1] isa LineNumberNode
         return exprresolve_conditional(ex.args[2])
     end
     false, false

base/deprecated.jl

@@ -27,6 +27,7 @@ const __internal_changes_list = (
     :codeinfonargs,  # #54341
     :ocnopartial,
     :printcodeinfocalls,
+    :reducerefactor,
     # Add new change names above this line
 )
 
@@ -558,3 +559,29 @@ true
 isbindingresolved
 
 # END 1.12 deprecations
+
+# BEGIN 1.13 deprecations
+
+## These are all mapreduce internals that were not exported or public, but have deprecations to minimize disruptions
+@deprecate reducedim_init(f, op, A::AbstractArray, region) (v = mapreduce_empty(f, op, eltype(A)); fill!(mapreduce_similar(A, typeof(v), reduced_indices(A,region)), v)) false
+const _dep_message_reducedim_init = ", these internals have been removed. To customize the array returned by dimensional reductions, implement mapreduce_similar instead"
+deprecate(Base, :reducedim_init)
+deprecate(Base, Symbol("#reducedim_init"))
+
+@deprecate (reducedim_initarray(A::Union{Base.AbstractBroadcasted, AbstractArray}, region, init, ::Type{T}) where {T}) fill!(mapreduce_similar(A,T,reduced_indices(A,region)), init) false
+@deprecate reducedim_initarray(A::Union{Base.AbstractBroadcasted, AbstractArray}, region, init) fill!(mapreduce_similar(A,typeof(init),reduced_indices(A,region)), init) false
+const _dep_message_reducedim_init = ", these internals have been removed. To customize the array returned by dimensional reductions, implement mapreduce_similar instead"
+deprecate(Base, :reducedim_initarray)
+deprecate(Base, Symbol("#reducedim_initarray"))
+
+@deprecate _mapreduce_dim(f, op, nt, A::Union{Base.AbstractBroadcasted, AbstractArray}, dims) mapreducedim(f, op, A, nt, dims) false
+
+@deprecate_binding mapreducedim! Base.mapreduce! false
+@deprecate_binding _mapreducedim! Base.mapreduce! false
+@deprecate_binding reducedim! Base.reduce! false
+
+@deprecate mapreduce_impl(f, op, A::AbstractArrayOrBroadcasted, ifirst::Integer, ilast::Integer, blksize::Int=pairwise_blocksize(f, op)) Base.mapreduce_pairwise(f, op, A, _InitialValue(), ifirst:ilast) false
+@deprecate _mapreduce(f, op, A) Base.mapreduce_pairwise(f, op, A, Base._InitialValue()) false
+@deprecate _mapreduce(f, op, _, A) Base.mapreduce_pairwise(f, op, A, Base._InitialValue()) false
+
+# END 1.13 deprecations

base/dict.jl

@@ -846,7 +846,15 @@ function iterate(d::ImmutableDict{K,V}, t=d) where {K, V}
     !isdefined(t, :parent) && return nothing
     (Pair{K,V}(t.key, t.value), t.parent)
 end
-length(t::ImmutableDict) = count(Returns(true), t)
+# length is defined in terms of iteration; using a higher-order function to do the iteration
+# is likely to call `length` again, so this is a manual for loop:
+function length(t::ImmutableDict)
+    r = 0
+    for _ in t
+        r+=1
+    end
+    return r
+end
 isempty(t::ImmutableDict) = !isdefined(t, :parent)
 empty(::ImmutableDict, ::Type{K}, ::Type{V}) where {K, V} = ImmutableDict{K,V}()
 

base/docs/Docs.jl

@@ -841,7 +841,8 @@ See also: [`names`](@ref), [`Docs.hasdoc`](@ref), [`Base.ispublic`](@ref).
 """
 function undocumented_names(mod::Module; private::Bool=false)
     filter!(names(mod; all=true)) do sym
-        !hasdoc(mod, sym) && !startswith(string(sym), '#') &&
+        !Base.isdeprecated(mod, sym) &&
+            !hasdoc(mod, sym) && !startswith(string(sym), '#') &&
             (private || Base.ispublic(mod, sym))
     end
 end

base/fastmath.jl

@@ -401,19 +401,14 @@ minimum_fast(a; kw...) = Base.reduce(min_fast, a; kw...)
 maximum_fast(f, a; kw...) = Base.mapreduce(f, max_fast, a; kw...)
 minimum_fast(f, a; kw...) = Base.mapreduce(f, min_fast, a; kw...)
 
-Base.reducedim_init(f, ::typeof(max_fast), A::AbstractArray, region) =
-    Base.reducedim_init(f, max, A::AbstractArray, region)
-Base.reducedim_init(f, ::typeof(min_fast), A::AbstractArray, region) =
-    Base.reducedim_init(f, min, A::AbstractArray, region)
-
 maximum!_fast(r::AbstractArray, A::AbstractArray; kw...) =
     maximum!_fast(identity, r, A; kw...)
 minimum!_fast(r::AbstractArray, A::AbstractArray; kw...) =
     minimum!_fast(identity, r, A; kw...)
 
 maximum!_fast(f::Function, r::AbstractArray, A::AbstractArray; init::Bool=true) =
-    Base.mapreducedim!(f, max_fast, Base.initarray!(r, f, max, init, A), A)
+    Base.mapreduce!(f, max_fast, r, A; update=!init)
 minimum!_fast(f::Function, r::AbstractArray, A::AbstractArray; init::Bool=true) =
-    Base.mapreducedim!(f, min_fast, Base.initarray!(r, f, min, init, A), A)
+    Base.mapreduce!(f, min_fast, r, A; update=!init)
 
 end

base/intfuncs.jl

@@ -838,7 +838,7 @@ function oct(x::Unsigned, pad::Int, neg::Bool)
 end
 
 # 2-digit decimal characters ("00":"99")
-const _dec_d100 = UInt16[
+const _dec_d100 = [
 # generating expression: UInt16[(0x30 + i % 10) << 0x8 + (0x30 + i ÷ 10) for i = 0:99]
 #    0 0,    0 1,    0 2,    0 3, and so on in little-endian
   0x3030, 0x3130, 0x3230, 0x3330, 0x3430, 0x3530, 0x3630, 0x3730, 0x3830, 0x3930,
@@ -928,8 +928,16 @@ function hex(x::Unsigned, pad::Int, neg::Bool)
     unsafe_takestring(a)
 end
 
-const base36digits = UInt8['0':'9';'a':'z']
-const base62digits = UInt8['0':'9';'A':'Z';'a':'z']
+# UInt8['0':'9';'a':'z']
+const base36digits = [0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
+    0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
+    0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a]
+# UInt8['0':'9';'A':'Z';'a':'z']
+const base62digits = [0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
+    0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
+    0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a,
+    0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
+    0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a]
 
 function _base(base::Integer, x::Integer, pad::Int, neg::Bool)
     (x >= 0) | (base < 0) || throw(DomainError(x, "For negative `x`, `base` must be negative."))

base/iterators.jl

@@ -192,6 +192,7 @@ enumerate(iter) = Enumerate(iter)
 
 length(e::Enumerate) = length(e.itr)
 size(e::Enumerate) = size(e.itr)
+axes(e::Enumerate) = axes(e.itr)
 @propagate_inbounds function iterate(e::Enumerate, state=(1,))
     i, rest = state[1], tail(state)
     n = iterate(e.itr, rest...)

base/mathconstants.jl

@@ -96,7 +96,7 @@ julia> Base.MathConstants.eulergamma
 julia> dx = 10^-6;
 
 julia> sum(-exp(-x) * log(x) for x in dx:dx:100) * dx
-0.5772078382499133
+0.5772078382090373
 ```
 """
 γ, const eulergamma = γ
@@ -129,7 +129,7 @@ julia> Base.MathConstants.catalan
 catalan = 0.9159655941772...
 
 julia> sum(log(x)/(1+x^2) for x in 1:0.01:10^6) * 0.01
-0.9159466120554123
+0.9159466120556183
 ```
 """
 catalan

base/missing.jl

@@ -269,100 +269,71 @@ function show(io::IO, s::SkipMissing)
     print(io, ')')
 end
 
-# Optimized mapreduce implementation
-# The generic method is faster when !(eltype(A) >: Missing) since it does not need
-# additional loops to identify the two first non-missing values of each block
-mapreduce(f, op, itr::SkipMissing{<:AbstractArray}) =
-    _mapreduce(f, op, IndexStyle(itr.x), eltype(itr.x) >: Missing ? itr : itr.x)
-
-function _mapreduce(f, op, ::IndexLinear, itr::SkipMissing{<:AbstractArray})
-    A = itr.x
-    ai = missing
-    inds = LinearIndices(A)
-    i = first(inds)
-    ilast = last(inds)
-    for outer i in i:ilast
-        @inbounds ai = A[i]
+# Simple optimization: catch skipmissings that wrap iterators that don't include Missing
+function mapreduce(f::F, op::G, itr::SkipMissing; init=Base._InitialValue()) where {F,G}
+    (IteratorEltype(itr.x) === HasEltype() && !(eltype(itr.x) >: Missing)) && return mapreduce(f, op, itr.x; init)
+    return mapreduce_pairwise(f, op, itr, init)
+end
+
+function mapreduce_pairwise(f::F, op::G, itr::SkipMissing{<:AbstractArray}, init) where {F,G}
+    v = mapreduce_skipmissing_pairwise(f, op, itr.x, init, eachindex(itr.x))
+    return ismissing(v) ? _mapreduce_start(f, op, itr, init) : v
+end
+
+# This is based on mapreduce_pairwise, but with special sauce that allows one or both of the pairwise splits
+# to not process any elements; returning `missing` as the sentinel in such a situation
+function mapreduce_skipmissing_pairwise(f::F, op::G, A, init, inds) where {F,G}
+    if length(inds) <= max(10, pairwise_blocksize(f, op))
+        return mapreduce_skipmissing_kernel(f, op, A, init, inds)
+    else
+        p1, p2 = halves(inds)
+        v1 = mapreduce_skipmissing_pairwise(f, op, A, init, p1)
+        v2 = mapreduce_skipmissing_pairwise(f, op, A, init, p2)
+        return ismissing(v1) ? v2 : ismissing(v2) ? v1 : op(v1, v2)
+    end
+end
+
+function mapreduce_skipmissing_kernel(f, op, A, init, inds::AbstractUnitRange)
+    i1, iN = first(inds), last(inds)
+    i = i1; ai = missing
+    for outer i in i1:iN
+        ai = @inbounds A[i]
         !ismissing(ai) && break
     end
-    ismissing(ai) && return mapreduce_empty(f, op, eltype(itr))
-    a1::eltype(itr) = ai
-    i == typemax(typeof(i)) && return mapreduce_first(f, op, a1)
-    i += 1
-    ai = missing
-    for outer i in i:ilast
+    ismissing(ai) && return missing
+    v = _mapreduce_start(f, op, A, init, ai)
+    i == typemax(typeof(i)) && return v
+    for i in i+1:iN
         @inbounds ai = A[i]
-        !ismissing(ai) && break
+        if !ismissing(ai)
+            v = op(v, f(ai))
+        end
     end
-    ismissing(ai) && return mapreduce_first(f, op, a1)
-    # We know A contains at least two non-missing entries: the result cannot be nothing
-    something(mapreduce_impl(f, op, itr, first(inds), last(inds)))
+    return v
 end
 
-_mapreduce(f, op, ::IndexCartesian, itr::SkipMissing) = mapfoldl(f, op, itr)
-
-mapreduce_impl(f, op, A::SkipMissing, ifirst::Integer, ilast::Integer) =
-    mapreduce_impl(f, op, A, ifirst, ilast, pairwise_blocksize(f, op))
-
-# Returns nothing when the input contains only missing values, and Some(x) otherwise
-@noinline function mapreduce_impl(f, op, itr::SkipMissing{<:AbstractArray},
-                                  ifirst::Integer, ilast::Integer, blksize::Int)
-    A = itr.x
-    if ifirst > ilast
-        return nothing
-    elseif ifirst == ilast
-        @inbounds a1 = A[ifirst]
-        if ismissing(a1)
-            return nothing
-        else
-            return Some(mapreduce_first(f, op, a1))
-        end
-    elseif ilast - ifirst < blksize
-        # sequential portion
-        ai = missing
-        i = ifirst
-        for outer i in i:ilast
-            @inbounds ai = A[i]
-            !ismissing(ai) && break
-        end
-        ismissing(ai) && return nothing
-        a1 = ai::eltype(itr)
-        i == typemax(typeof(i)) && return Some(mapreduce_first(f, op, a1))
-        i += 1
-        ai = missing
-        for outer i in i:ilast
-            @inbounds ai = A[i]
-            !ismissing(ai) && break
-        end
-        ismissing(ai) && return Some(mapreduce_first(f, op, a1))
-        a2 = ai::eltype(itr)
-        i == typemax(typeof(i)) && return Some(op(f(a1), f(a2)))
-        i += 1
-        v = op(f(a1), f(a2))
-        @simd for i = i:ilast
-            @inbounds ai = A[i]
-            if !ismissing(ai)
-                v = op(v, f(ai))
-            end
-        end
-        return Some(v)
-    else
-        # pairwise portion
-        imid = ifirst + (ilast - ifirst) >> 1
-        v1 = mapreduce_impl(f, op, itr, ifirst, imid, blksize)
-        v2 = mapreduce_impl(f, op, itr, imid+1, ilast, blksize)
-        if v1 === nothing && v2 === nothing
-            return nothing
-        elseif v1 === nothing
-            return v2
-        elseif v2 === nothing
-            return v1
-        else
-            return Some(op(something(v1), something(v2)))
+function mapreduce_skipmissing_kernel(f, op, A, init, inds)
+    it = iterate(inds)
+    local s
+    ai = missing
+    while it !== nothing
+        i, s = it
+        ai = @inbounds A[i]
+        !ismissing(ai) && break
+        it = iterate(inds, s)
+    end
+    ismissing(ai) && return missing
+    v = _mapreduce_start(f, op, A, init, ai)
+    for i in Iterators.rest(inds, s)
+        @inbounds ai = A[i]
+        if !ismissing(ai)
+            v = op(v, f(ai))
         end
     end
+    return v
 end
 
+
 """
     filter(f, itr::SkipMissing{<:AbstractArray})