microstructure.hpp

Go to the documentation of this file.

#pragma once
 
 
#include <cstddef>
#include <cstdint>
#include <limits>
 
#include "itch/book/l3_book.hpp"
 
namespace itch::analytics {
 
[[nodiscard]] inline auto spread(const book::Bbo& bbo) -> double {
    if (!bbo.has_bid || !bbo.has_ask) {
        return std::numeric_limits<double>::quiet_NaN();
    }
    return bbo.ask_price.to_double() - bbo.bid_price.to_double();
}
 
[[nodiscard]] inline auto mid_price(const book::Bbo& bbo) -> double {
    if (!bbo.has_bid || !bbo.has_ask) {
        return std::numeric_limits<double>::quiet_NaN();
    }
    return (bbo.bid_price.to_double() + bbo.ask_price.to_double()) / 2.0;
}
 
[[nodiscard]] inline auto queue_imbalance(const book::Bbo& bbo) -> double {
    const double bid   = static_cast<double>(bbo.bid_shares);
    const double ask   = static_cast<double>(bbo.ask_shares);
    const double total = bid + ask;
    if (total <= 0.0) {
        return std::numeric_limits<double>::quiet_NaN();
    }
    return (bid - ask) / total;
}
 
[[nodiscard]] inline auto depth_at_level(
    const book::L3Book& book, book::Side side, std::size_t levels
) -> std::uint64_t {
    std::uint64_t total = 0;
    for (const auto& level : book.depth(side, levels)) {
        total += level.shares;
    }
    return total;
}
 
[[nodiscard]] inline auto order_flow_imbalance(const book::Bbo& previous, const book::Bbo& current)
    -> double {
    const double prev_bid_price = previous.bid_price.to_double();
    const double curr_bid_price = current.bid_price.to_double();
    const double prev_ask_price = previous.ask_price.to_double();
    const double curr_ask_price = current.ask_price.to_double();
    const double prev_bid_size  = static_cast<double>(previous.bid_shares);
    const double curr_bid_size  = static_cast<double>(current.bid_shares);
    const double prev_ask_size  = static_cast<double>(previous.ask_shares);
    const double curr_ask_size  = static_cast<double>(current.ask_shares);
 
    double bid_flow = 0.0;
    if (curr_bid_price > prev_bid_price) {
        bid_flow = curr_bid_size;
    } else if (curr_bid_price == prev_bid_price) {
        bid_flow = curr_bid_size - prev_bid_size;
    } else {
        bid_flow = -prev_bid_size;
    }
 
    double ask_flow = 0.0;
    if (curr_ask_price > prev_ask_price) {
        ask_flow = prev_ask_size;
    } else if (curr_ask_price == prev_ask_price) {
        ask_flow = curr_ask_size - prev_ask_size;
    } else {
        ask_flow = -curr_ask_size;
    }
 
    return bid_flow - ask_flow;
}
 
}  // namespace itch::analytics