ma-filter.h

#pragma once
 
#include <dsplib/math.h>
#include <dsplib/array.h>
 
namespace dsplib {
 
template<typename T>
class MAFilter
{
public:
    explicit MAFilter(int len)
      : d_{nextpow2(len)}
      , w_{len}
      , buf_((1 << (d_ + 1)) - 1, T{0}) {
        DSPLIB_ASSERT(len >= 1, "window len must be positive");
    }
 
    explicit MAFilter(int len, const base_array<T>& init)
      : MAFilter{len} {
        DSPLIB_ASSERT(init.size() == w_, "init size mismatch");
        for (int i = 0; i < w_; i++) {
            this->process(init[i]);
        }
    }
 
    T process(const T& in) noexcept {
        if (w_ == 1) {
            return in;
        }
 
        int k = (1 << d_) - 1 + pos_;
        buf_[k] = in;
        while (k > 0) {
            k = (k - 1) >> 1;
            buf_[k] = buf_[2 * k + 1] + buf_[2 * k + 2];
        }
        pos_ = (pos_ + 1) % w_;
        return buf_[0] / w_;
    }
 
    base_array<T> process(span_t<T> in) noexcept {
        if (w_ == 1) {
            return in;
        }
 
        const int n = in.size();
        base_array<T> out(n);
        for (int i = 0; i < n; i++) {
            out[i] = process(in[i]);
        }
        return out;
    }
 
    T operator()(const T& x) noexcept {
        return this->process(x);
    }
 
    base_array<T> operator()(span_t<T> x) noexcept {
        return this->process(x);
    }
 
private:
    int d_;                
    int w_;                
    std::vector<T> buf_;   
    int pos_{0};           
};
 
using MAFilterR = MAFilter<real_t>;
 
using MAFilterC = MAFilter<cmplx_t>;
 
}   // namespace dsplib