vwap.hpp

Go to the documentation of this file.

#pragma once
 
 
#include <cstdint>
#include <limits>
 
#include "itch/price.hpp"
 
namespace itch::analytics {
 
class Vwap {
   public:
    auto add(StandardPrice price, std::uint64_t shares) -> void {
        m_price_volume += price.to_double() * static_cast<double>(shares);
        m_volume += shares;
    }
 
    [[nodiscard]] auto value() const -> double {
        if (m_volume == 0) {
            return std::numeric_limits<double>::quiet_NaN();
        }
        return m_price_volume / static_cast<double>(m_volume);
    }
 
    [[nodiscard]] auto volume() const noexcept -> std::uint64_t { return m_volume; }
 
    auto reset() noexcept -> void {
        m_price_volume = 0.0;
        m_volume       = 0;
    }
 
   private:
    double        m_price_volume {0.0};
    std::uint64_t m_volume {0};
};
 
class Twap {
   public:
    auto add(StandardPrice price, std::uint64_t timestamp) -> void {
        if (m_has_sample && timestamp > m_last_timestamp) {
            const double elapsed = static_cast<double>(timestamp - m_last_timestamp);
            m_price_time += m_last_price * elapsed;
            m_total_time += elapsed;
        }
        m_last_price     = price.to_double();
        m_last_timestamp = timestamp;
        m_has_sample     = true;
    }
 
    [[nodiscard]] auto value() const -> double {
        if (m_total_time <= 0.0) {
            return m_has_sample ? m_last_price : std::numeric_limits<double>::quiet_NaN();
        }
        return m_price_time / m_total_time;
    }
 
    auto reset() noexcept -> void {
        m_price_time     = 0.0;
        m_total_time     = 0.0;
        m_last_price     = 0.0;
        m_last_timestamp = 0;
        m_has_sample     = false;
    }
 
   private:
    double        m_price_time {0.0};
    double        m_total_time {0.0};
    double        m_last_price {0.0};
    std::uint64_t m_last_timestamp {0};
    bool          m_has_sample {false};
};
 
}  // namespace itch::analytics