defs.h

Go to the documentation of this file.

 
#ifndef DEFS_H
#define DEFS_H
 
#include <cstdint>
#include <cmath>
#include <ostream>
 
namespace tzu {

enum class Side {
    BUY,   
    SELL,  
    NONE   
};

struct Signal {
    int64_t timestamp;  
    Side side;          
    double price;       
    double volume;      
    
    Signal(int64_t ts = 0, Side s = Side::NONE, double p = 0.0, double v = 1.0)
        : timestamp(ts), side(s), price(p), volume(v) {}
};

enum class OhlcvField {
    OPEN,    
    HIGH,    
    LOW,     
    CLOSE,   
    VOLUME   
};

struct Ohlcv {
    int64_t timestamp;  
    double open;        
    double high;        
    double low;         
    double close;       
    double volume;      
    
    Ohlcv(int64_t ts = 0, double o = 0.0, double h = 0.0, double l = 0.0,
          double c = 0.0, double v = 0.0)
        : timestamp(ts), open(o), high(h), low(l), close(c), volume(v) {}

    double getFieldValue(OhlcvField field) const {
        switch (field) {
            case OhlcvField::OPEN: return open;
            case OhlcvField::HIGH: return high;
            case OhlcvField::LOW: return low;
            case OhlcvField::CLOSE: return close;
            case OhlcvField::VOLUME: return volume;
        }
        return std::nan(""); // Should never reach here
    }
};

struct Tick {
    int64_t timestamp;
    double price = 0.0;
    double volume = 0.0;
    Side side = Side::NONE;
    Tick() = default;
    Tick(int64_t ts, double p, double v, Side s)
        : timestamp(ts), price(p), volume(v), side(s) {}
};

struct SingleValue {
    int64_t timestamp;
    double value = 0.0;
    SingleValue() = default;
    SingleValue(int64_t ts, double v) : timestamp(ts), value(v) {}
};

enum class DataType {
    OHLCV,
    TICK,
    SINGLE_VALUE,
};

struct Position {
    int64_t timestamp;
    double quantity;
    double price;
    Position(int64_t ts = 0, double q = 0.0, double p = 0.0)
        : timestamp(ts), quantity(q), price(p) {}
};

struct Trade {
    int64_t open_time;
    int64_t close_time;
    double open_price;
    double close_price;
    double quantity;
    double profit;
    bool closed;
    
    Trade() = default;
    Trade(int64_t ot =0 , int64_t ct = 0, double op = 0.0, double cp = 0.0,
            double q = 0.0, double p = 0.0, bool c = false) :
        open_time(ot), close_time(ct), open_price(op), close_price(cp),
        quantity(q), profit(p), closed(c) {}
};

struct PerformanceMetrics {
    double total_return = 0.0;
    double annual_return = 0.0;
    double max_drawdown = 0.0;
    double sharpe_ratio = 0.0;
    double years = 0.0;
    bool has_annual_return = false;
};

struct BuyAndHoldMetrics {
    double quantity = 0.0;
    double cash_left = 0.0;
    double final_value = 0.0;
    double total_return = 0.0;
    double annual_return = 0.0;
    bool has_annual_return = false;
    bool valid = false;
};
 
enum class TimeInterval {
    NANOSECONDS,
    MICROSECONDS,
    MILLISECONDS,
    SECONDS,
    MINUTES,
    HOURS,
    DAYS,
    WEEKS,
    MONTHS,
    YEARS
};
 
 
} // namespace tzu
 

inline std::ostream& operator<<(std::ostream& os, const tzu::Signal& signal) {
    os << "timestamp: " << signal.timestamp
       << " side: " 
       << (signal.side == tzu::Side::BUY 
               ? "BUY" 
               : signal.side == tzu::Side::SELL 
                ? "SELL" : "NONE")
       << " price: " << signal.price
       << " volume: " << signal.volume << ")";
    return os;
}
 
#endif // DEFS_H