Wrapping methods used by multiple structs

General Usage
,
1

For use running incremental statistics over windowed data, I have some structs that share struct-function-like methods. Here is an example that keeps track of the maximum value encountered as it runs over a windowed data stream.

abstract type Accumulator{T} end

mutable struct AccumMax{T} <: Accumulator{T}
    max::T
    AccumMax(::Type{T}=Float64) where {T} =
        (T <: Integer) ? new{T}(typemin(T)) : new{T}(floatmin(T))
end

(accum::AccumMax{T})() where {T} = (accum.max)
(accum::AccumMax{T})(x) where {T} = 
    (accum.max = ifelse(accum.max < x, T(x), accum.max))

julia> accum = AccumMax(Float32)
AccumMax{Float32}(1.1754944f-38)
julia> accum(17.0f0) # the one-arg form accumulates the value
17.0f0
jula> accum(5.0f0); 
julia> accum()  # the no-args form retrieves the accumulated value
17.0f0

I want to offer AccumMaxAbs that does what AccumMax does using abs(x) in place of x. This is not too hard to do in a way that keeps interoperability with e.g. AccumMin so AccumMinAbs can be realized the same way.

(accum::AccumMax{T})(x, fx::F=identity) where {T,F<:Function} = 
    (x = fx(x); accum.max = ifelse(accum.max < x, T(x), accum.max))

[currently I recode each explicitly … there are more than two]
It would be great if there were a way to auto-generate the Abs versions; I am not concerned so much about making Abs versions by hand – I am opaque as to how one approaches modifying the internal calculation in the third statement in a more detailed accumulator. I would like to turn the following into an exponentially weighted version of itself knowing how the modification should be, without entirely recoding it (I would like to offer an exponentially weighted variant of most Accumulators).

 
mutable struct AccumMeanVariance{T} <: Accumulator{T}
    n::Int
    mean::T
    svar::T
    AccumMeanVariance(::Type{T}=Float64) where {T} = new{T}(0, zero(T), zero(T))
end

function (accum::AccumMeanVariance{T})() where {T}
    unbiased_var = accum.svar / (accum.n - 1)
    (a.mean, unbiased_var)
end

function (accum::AccumMeanVariance{T})(x) where {T}
    if !iszero(accum.n)
        oldmean = accum.mean
        accum.mean = oldmean + (x - oldmean) / accum.n
        accum.svar = accum.svar + (x - oldmean) * (x - accum.mean)
    else
        acccum.mean = x  # svar is zero already
    end
end

the exponentially weighted version of this is

mutable struct AccumExpWMeanVariance{T} <: Accumulator{T}
    n::Int
    alpha::T
    mean::T
    svar::T
    AccumExpWMeanVariance(::Type{T}=Float64; alpha::T=0.5) where {T} =
       new{T}(0, alpha, zero(T), zero(T))
end

function (accum::AccumExpWMeanVariance{T})() where {T}
    unbiased_var = accum.svar / (accum.n = 1)
    (accum.mean, unbiased_var)
end

function (accum::AccumExpWMeanVariance{T})(x) where {T}
    accum.n += 1
    diff = x - accum.mean
    incr = accum.alpha * diff
    accum.mean += accum.alpha * (x - a.mean)
    accum.svar = (one(T) - accum.alpha) * (accum.svar + diff * incr)
end