Suppose you want to model an open risk position for a single asset (e.g. BTC) due to incoming stream of trades. The open risk will eventually be closed down over time through the hedging. You probably don’t want to give equal weight to open risk due to trades from last hour and the ones from five minutes ago. Instead, given 2 trade of equal price, quantity, and direction, you would expect the older trade should be hedged over time while the recent trade is not hedged yet if the risk delta is hedged independently.

Think of it like a history of trades…open risk due to older trades should eventually blur into the background, but the newer one is unhedged!!

Before that, I want to thank Mark, who introduced me this simple yet powerful tool to track rolling stats!

Summarizing Unweighted Values

Let’s say we have a sequence of values $x_1, x_2, …$ arriving at times $t_1, t_2, …$. Instead of storing every value, we track the sum of first three raw moments $s_k = \sum_{i=1}^{n}{x_i^k}$ and derive count, mean, and variance using these raw moments. Neat, right? But that’s for equally weighted data. But how about things that are constantly changing?

Exponential Decay

To apply exponential decay, we introduce a weight $w_i$ for each data point: $w_i(t) = \rho^{t-t_i}$ where $\rho$ is a decay factor of [0, 1]. Setting $\rho = 1$ gives us the regular moving average while $\rho = 0$ is just “last value only”. With this tweak, the new moment equation is: $s_k(t) = \sum_{i=1}^{n}{w_i(t)x_i^k} = \sum_{i=1}^{n}{\rho^{t-t_i} x_i^k}$ and the update equations become $s_k \leftarrow \rho^{\max{0,t-t_{max}}} s_k + x^k$. With this weighted raw moments, we can compute the weighted count, mean, and variance.

To determine $\rho$, we define $\rho=2^{-1/\tau}$ where $\tau$ represents the half-life of each data (i.e. how long it takes for each value to lose half it’s weight).

For more details on this approach, please check out Stefan Karpinski’s original paper on EDMA

Implementation

Here is my ported implementation of Edma in C#

public sealed class Edma
{
    private const int MomentSize = 3;
    private readonly double _halfLifeS;
    private readonly double _rho;
    private readonly double[] _weightedMoments = new double[MomentSize];
    private DateTime _maxTs = DateTime.MinValue;

    public Edma(double halfLifeS)
    {
        _halfLifeS = halfLifeS;
        _rho = Math.Pow(2, -1 / halfLifeS);
    }

    public void Reset()
    {
        _maxTs = DateTime.MinValue;
        Array.Clear(_weightedMoments);
    }

    public void InsertData(DateTime timestamp, double data)
    {
        var timeDiffS = Math.Max((timestamp - _maxTs).TotalSeconds, 0);
        for (var i = 0; i < MomentSize; i++)
        {
            _weightedMoments[i] = Math.Pow(_rho, timeDiffS) * _weightedMoments[i] + Math.Pow(data, i);
        }

        _maxTs = timestamp > _maxTs ? timestamp : _maxTs;
    }

    private double GetEffectiveMomentAt(int moment, DateTime timestamp)
    {
        var timeDiffS = Math.Max((timestamp - _maxTs).TotalSeconds, 0);
        return Math.Pow(_rho, timeDiffS) * _weightedMoments[moment];
    }

    public double GetWeightedCountAt(DateTime timestamp) => GetEffectiveMomentAt(0, timestamp);
    
    public double GetWeightedAverageAt(DateTime timestamp) {
        var weightedZerothMoment = GetEffectiveMomentAt(0, timestamp);
        var weightedFirstMoment = GetEffectiveMomentAt(1, timestamp);
        return weightedZerothMoment == 0 ? 0 : weightedFirstMoment / weightedZerothMoment;
    }
    
    public double GetWeightedVarianceAt(DateTime timestamp) {
        var weightedZerothMoment = GetEffectiveMomentAt(0, timestamp);
        var weightedFirstMoment = GetEffectiveMomentAt(1, timestamp);
        var weightedSecondMoment = GetEffectiveMomentAt(2, timestamp);

        return weightedZerothMoment > 1
            ? (weightedSecondMoment - Math.Pow(weightedFirstMoment, 2) / weightedZerothMoment) / (weightedZerothMoment - 1)
            : 0;
    }
}

Wrapping up

EDMA is a simple yet powerful tool for managing the statistics of rolling data. It only requires storing and updating four values, a maximum timestamp and three weighted raw moments.

However, note that not every data would follow an exponential decay, and hence EDMA might not be the right tool to model the decaying statistics… there is linear, sigmoid, step, polynomial, etc.

Reference

1. Stefan Karpinski’s Paper on EDMA: https://github.com/StefanKarpinski/edma/