Update mapreducethen docstrings

Author: andrewjradcliffe

src/vmapreducethen.jl

@@ -361,6 +361,35 @@ end
 ################
 # Threaded version
 
+"""
+    vtmapreducethen(f, op, g, A::AbstractArray; dims=:, init)
+
+Apply function `f` to each element of `A`, reduce the result over the dimensions
+`dims` using the binary function `op`, then apply `g` to the result. Equivalent to
+`g.(mapreduce(f, op, A, dims=dims, init=init))` but avoids the intermediate implied
+by said expression while also fusing the post-transform `g` such that the output array
+is populated in a single pass. Threaded.
+
+The reduction necessitates an initial value `init` which may be `<:Number` or a function
+which accepts a single type argument (e.g. `zero`);
+`init` is optional for binary operators `+`, `*`, `min`, and `max`.
+
+# Examples
+```jldoctest
+julia> vtmapreducethen(abs2, +, √, [1 2; 3 4], dims=1)    # L₂-norm; see `vnorm`
+1×2 Matrix{Float64}:
+ 3.16228  4.47214
+
+julia> vtmapreducethen(abs2, +, √, [1 2; 3 4], dims=2, init=1000.0)
+2×1 Matrix{Float64}:
+ 31.701734968294716
+ 32.01562118716424
+
+julia> vtmapreducethen(exp, +, log, [5 6; 7 8], dims=1)    # LSE, but recommend `vlogsumexp`
+1×2 Matrix{Float64}:
+ 7.12693  8.12693
+```
+"""
 function vtmapreducethen(f::F, op::OP, g::G, init::I, A::AbstractArray{T, N}, dims::NTuple{M, Int}) where {F, OP, G, I, T, N, M}
     Dᴬ = size(A)
     Dᴮ′ = ntuple(d -> d ∈ dims ? 1 : Dᴬ[d], Val(N))

src/vmapreducethen_vararg.jl

@@ -415,7 +415,7 @@ end
 """
     vtmapreducethen(f, op, g, init, As::Vararg{AbstractArray, N}) where {N}
 
-Version of mapreducethen for `f` : ℝᴺ → ℝ, then `g` : ℝ → ℝ, with reduction occurring over
+Version of `mapreducethen` for `f` : ℝᴺ → ℝ, then `g` : ℝ → ℝ, with reduction occurring over
 all dimensions.
 """
 vtmapreducethen(f::F, op::OP, g::G, init::I, As::Vararg{AbstractArray, P}) where {F, OP, G, I, P} =
@@ -432,7 +432,7 @@ vtmapreducethen(f, op, g, As::Vararg{AbstractArray, P}; dims=:, init) where {P}
 """
     vtmapreducethen(f, op, g, init, As::Tuple{Vararg{AbstractArray}}, dims=:)
 
-Version of mapreducethen for `f` : ℝᴺ → ℝ, then `g` : ℝ → ℝ, with reduction over given `dims`.
+Version of `mapreducethen` for `f` : ℝᴺ → ℝ, then `g` : ℝ → ℝ, with reduction over given `dims`.
 """
 function vtmapreducethen(f::F, op::OP, g::G, init::I, As::Tuple{Vararg{AbstractArray, P}}, dims::NTuple{M, Int}) where {F, OP, G, I, M, P}
     ax = axes(As[1])