moving_average.h

Go to the documentation of this file.

 
#ifndef __SABLIB_MOVING_AVERAGE_H__
#define __SABLIB_MOVING_AVERAGE_H__
 
#include <cmath>
#include <stdexcept>
#include <vector>
 
#include "../misc/expand.h"
 
namespace sablib {

const std::vector<double> WeightedMovingAverage(const std::vector<double> & y, const std::vector<double> & w);

template <typename Derived>
const typename Derived::PlainObject WeightedMovingAverage(
    const Eigen::MatrixBase<Derived> & y, const Eigen::MatrixBase<Derived> & w
)
{
    // Although parameters are received as MatrixBase<Derived>, only vector classes are allowed.
    // Others will be rejected at compile time.
    static_assert(Derived::IsVectorAtCompileTime, "Error: y and w are not vector.");
 
    if(y.size() == 0 || w.size() == 0) {
        throw std::invalid_argument("WeightedMovingAverage(): the length of y or w is zero.");
    }
 
    using PlainObject = typename Derived::PlainObject;
 
    int points = w.size();
    int n = points / 2;
    PlainObject yy = ExpandBoundaries(y, n);
    PlainObject result = PlainObject::Zero(y.size());
 
    if(y.cols() == 1) {
        for(int i = 0; i < y.size(); i++) {
            result(i) = (yy.block(i, 0, points, 1).array() * w.array()).matrix().sum();
        }
    }
    else if(y.rows() == 1) {
        for(int i = 0; i < y.size(); i++) {
            result(i) = (yy.block(0, i, 1, points).array() * w.array()).matrix().sum();
        }
    }
 
    return result;
}

const std::vector<double> MovingAverage(const std::vector<double> & y, const unsigned int n);

template <typename Derived>
const typename Derived::PlainObject MovingAverage(const Eigen::MatrixBase<Derived> & y, const unsigned int n)
{
    using PlainObject = typename Derived::PlainObject;
 
    if(n == 0) {
        throw std::invalid_argument("MovingAverage(): n is zero.");
    }
 
    int points = 2 * n + 1;
    PlainObject w = PlainObject::Ones(points) / points;
 
    return WeightedMovingAverage(y, w);
}

const std::vector<double> GaussianKernel(const unsigned int n, const double sigma);

inline const std::vector<double> GaussianFilter(const std::vector<double> & y, const unsigned int n, const double sigma)
{
    return WeightedMovingAverage(y, GaussianKernel(n, sigma));
}
 
}; // namespace sablib
 
#endif // __SABLIB_MOVING_AVERAGE_H__