Candle.struct.h

//+------------------------------------------------------------------+
//|                                                EA31337 framework |
//|                                 Copyright 2016-2023, EA31337 Ltd |
//|                                        https://ea31337.github.io |
//+------------------------------------------------------------------+

/*
 * This file is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

/**
 * @file
 * Includes Bar's structs.
 */

#ifndef __MQL__
// Allows the preprocessor to include a header file when it is needed.
#pragma once
#endif

// Forward class declaration.
class Serializer;

// Includes.
#include "Bar.enum.h"
#include "Platform/Chart/Chart.enum.h"
#include "Serializer/Serializable.h"
#include "Serializer/Serializer.enum.h"
#include "Serializer/Serializer.h"
#include "Serializer/SerializerNode.enum.h"
#include "Std.h"

/* Structure for storing OHLC values. */
template <typename T>
struct CandleOHLC
#ifndef __MQL__
    : public Serializable
#endif
{
  T open, high, low, close;

  // Struct constructors.
  CandleOHLC(T _open = 0, T _high = 0, T _low = 0, T _close = 0) : open(_open), high(_high), low(_low), close(_close) {}
  CandleOHLC(ARRAY_REF(T, _prices)) {
    int _size = ArraySize(_prices);
    close = _prices[0];
    open = _prices[_size - 1];
    high = fmax(close, open);
    low = fmin(close, open);
    for (int i = 0; i < _size; i++) {
      high = fmax(high, _prices[i]);
      low = fmin(low, _prices[i]);
    }
  }
  // Struct methods.
  // Getters
  bool GetPivots(ENUM_PP_TYPE _type, T &_pp, T &_r1, T &_r2, T &_r3, T &_r4, T &_s1, T &_s2, T &_s3, T &_s4) {
    T _range = GetRange();
    switch (_type) {
      case PP_CAMARILLA:
        // A set of eight very probable levels which resemble support and resistance values for a current trend.
        _pp = GetPivot();
        _r1 = (T)(close + _range * 1.1 / 12);
        _r2 = (T)(close + _range * 1.1 / 6);
        _r3 = (T)(close + _range * 1.1 / 4);
        _r4 = (T)(close + _range * 1.1 / 2);
        _s1 = (T)(close - _range * 1.1 / 12);
        _s2 = (T)(close - _range * 1.1 / 6);
        _s3 = (T)(close - _range * 1.1 / 4);
        _s4 = (T)(close - _range * 1.1 / 2);
        break;
      case PP_CLASSIC:
        _pp = GetPivot();
        _r1 = (2 * _pp) - low;   // R1 = (H - L) * 1.1 / 12 + C (1.0833)
        _r2 = _pp + _range;      // R2 = (H - L) * 1.1 / 6 + C (1.1666)
        _r3 = _pp + _range * 2;  // R3 = (H - L) * 1.1 / 4 + C (1.25)
        _r4 = _pp + _range * 3;  // R4 = (H - L) * 1.1 / 2 + C (1.5)
        _s1 = (2 * _pp) - high;  // S1 = C - (H - L) * 1.1 / 12 (1.0833)
        _s2 = _pp - _range;      // S2 = C - (H - L) * 1.1 / 6 (1.1666)
        _s3 = _pp - _range * 2;  // S3 = C - (H - L) * 1.1 / 4 (1.25)
        _s4 = _pp - _range * 3;  // S4 = C - (H - L) * 1.1 / 2 (1.5)
        break;
      case PP_FIBONACCI:
        _pp = GetPivot();
        _r1 = (float)(_pp + 0.382 * _range);
        _r2 = (float)(_pp + 0.618 * _range);
        _r3 = _pp + _range;
        _r4 = _r1 + _range;  // ?
        _s1 = (float)(_pp - 0.382 * _range);
        _s2 = (float)(_pp - 0.618 * _range);
        _s3 = _pp - _range;
        _s4 = _s1 - _range;  // ?
        break;
      case PP_FLOOR:
        // Most basic and popular type of pivots used in Forex trading technical analysis.
        _pp = GetPivot();              // Pivot (P) = (H + L + C) / 3
        _r1 = (2 * _pp) - low;         // Resistance (R1) = (2 * P) - L
        _r2 = _pp + _range;            // R2 = P + H - L
        _r3 = high + 2 * (_pp - low);  // R3 = H + 2 * (P - L)
        _r4 = _r3;
        _s1 = (2 * _pp) - high;        // Support (S1) = (2 * P) - H
        _s2 = _pp - _range;            // S2 = P - H + L
        _s3 = low - 2 * (high - _pp);  // S3 = L - 2 * (H - P)
        _s4 = _s3;                     // ?
        break;
      case PP_TOM_DEMARK:
        // Tom DeMark's pivot point (predicted lows and highs of the period).
        _pp = GetPivotDeMark();
        _r1 = (2 * _pp) - low;  // New High = X / 2 - L.
        _r2 = _pp + _range;
        _r3 = _r1 + _range;
        _r4 = _r2 + _range;      // ?
        _s1 = (2 * _pp) - high;  // New Low = X / 2 - H.
        _s2 = _pp - _range;
        _s3 = _s1 - _range;
        _s4 = _s2 - _range;  // ?
        break;
      case PP_WOODIE:
        // Woodie's pivot point are giving more weight to the Close price of the previous period.
        // They are similar to floor pivot points, but are calculated in a somewhat different way.
        _pp = GetWeighted();    // Pivot (P) = (H + L + 2 * C) / 4
        _r1 = (2 * _pp) - low;  // Resistance (R1) = (2 * P) - L
        _r2 = _pp + _range;     // R2 = P + H - L
        _r3 = _r1 + _range;
        _r4 = _r2 + _range;      // ?
        _s1 = (2 * _pp) - high;  // Support (S1) = (2 * P) - H
        _s2 = _pp - _range;      // S2 = P - H + L
        _s3 = _s1 - _range;
        _s4 = _s2 - _range;  // ?
        break;
      default:
        break;
    }
    return _r4 > _r3 && _r3 > _r2 && _r2 > _r1 && _r1 > _pp && _pp > _s1 && _s1 > _s2 && _s2 > _s3 && _s3 > _s4;
  }
  T GetAppliedPrice(ENUM_APPLIED_PRICE _ap) const { return CandleOHLC::GetAppliedPrice(_ap, open, high, low, close); }
  T GetBody() const { return close - open; }
  T GetBodyAbs() const { return fabs(close - open); }
  T GetBodyInPct(int _hundreds = 100) const { return GetRange() > 0 ? _hundreds / GetRange() * GetBodyAbs() : 0; }
  T GetChangeInPct(int _hundreds = 100) const { return (close - open) / open * _hundreds; }
  T GetClose() const { return close; }
  T GetHigh() const { return high; }
  T GetLow() const { return low; }
  T GetMaxOC() const { return fmax(open, close); }
  T GetMedian() const { return (high + low) / 2; }
  T GetMinOC() const { return fmin(open, close); }
  T GetOpen() const { return open; }
  T GetPivot() const { return GetTypical(); }
  T GetPivotDeMark() const {
    // If Close < Open Then X = H + 2 * L + C
    // If Close > Open Then X = 2 * H + L + C
    // If Close = Open Then X = H + L + 2 * C
    T _pp = open > close ? (high + (2 * low) + close) / 4 : ((2 * high) + low + close) / 4;
    return open == close ? (high + low + (2 * close)) / 4 : _pp;
  }
  T GetPivotWithOpen() const { return (open + high + low + close) / 4; }
  T GetPivotWithOpen(float _open) const { return (_open + high + low + close) / 4; }
  T GetRange() const { return high - low; }
  T GetRangeChangeInPct(int _hundreds = 100) const { return _hundreds - (_hundreds / open * fabs(open - GetRange())); }
  T GetRangeInPips(float _ppp) const { return GetRange() / _ppp; }
  T GetTypical() const { return (high + low + close) / 3; }
  T GetWeighted() const { return (high + low + close + close) / 4; }
  T GetWickMin() const { return fmin(GetWickLower(), GetWickUpper()); }
  T GetWickLower() const { return GetMinOC() - low; }
  T GetWickLowerInPct() const { return GetRange() > 0 ? 100 / GetRange() * GetWickLower() : 0; }
  T GetWickMax() const { return fmax(GetWickLower(), GetWickUpper()); }
  T GetWickSum() const { return GetWickLower() + GetWickUpper(); }
  T GetWickUpper() const { return high - GetMaxOC(); }
  T GetWickUpperInPct() const { return GetRange() > 0 ? 100 / GetRange() * GetWickUpper() : 0; }
  short GetType() const { return IsBull() ? 1 : (IsBear() ? -1 : 0); }
  void GetValues(ARRAY_REF(T, _out)) {
    ArrayResize(_out, 4);
    int _index = ArraySize(_out) - 4;
    _out[_index++] = open;
    _out[_index++] = high;
    _out[_index++] = low;
    _out[_index++] = close;
  }
  static T GetAppliedPrice(ENUM_APPLIED_PRICE _ap, T _o, T _h, T _l, T _c) {
    switch (_ap) {
      case PRICE_CLOSE:
        return _c;
      case PRICE_OPEN:
        return _o;
      case PRICE_HIGH:
        return _h;
      case PRICE_LOW:
        return _l;
      case PRICE_MEDIAN:
        return (_h + _l) / 2;
      case PRICE_TYPICAL:
        return (_h + _l + _c) / 3;
      case PRICE_WEIGHTED:
        return (_h + _l + _c + _c) / 4;
      default:
        return _o;
    }
  }
  // State checkers.
  bool IsBear() const { return open > close; }
  bool IsBull() const { return open < close; }
  bool IsValid() const { return high >= low && fmin(open, close) > 0; }
  // Serializers.
  SerializerNodeType Serialize(Serializer &s);
  // Converters.
  string ToCSV() { return StringFormat("%g,%g,%g,%g", open, high, low, close); }
};

/* Structure for storing OHLC values, number of ticks which formed the candle and both, open and close timestamp of the
 * candle. */
template <typename T>
struct CandleOCTOHLC : CandleOHLC<T> {
  bool is_complete;

  // Timestamp of where the candle is placed on the chart.
  int start_time;

  // Length of the candle in seconds.
  int length;

  // Open and close timestamps of ticks that were part of this candle.
  long open_timestamp_ms, close_timestamp_ms;

  // Number of ticks which formed the candle. Also known as volume.
  int volume;

  // Struct constructor.
  CandleOCTOHLC(T _open = 0, T _high = 0, T _low = 0, T _close = 0, int _start_time = -1, int _length = 0,
                long _open_timestamp_ms = -1, long _close_timestamp_ms = -1, int _volume = 0)
      : CandleOHLC<T>(_open, _high, _low, _close),
        is_complete(true),
        start_time(_start_time),
        length(_length),
        open_timestamp_ms(_open_timestamp_ms),
        close_timestamp_ms(_close_timestamp_ms),
        volume(_volume) {
    if (_open != 0) {
      volume = 1;
    }
  }

  // Struct constructor.
  CandleOCTOHLC(const CandleOCTOHLC &r) { THIS_REF = r; }

  // Virtual destructor. Required because of Emscripted warning, despite structure has no virtual methods:
  // warning: destructor called on non-final 'CandleOCTOHLC<double>' that has virtual functions but non-virtual
  // destructor [-Wdelete-non-abstract-non-virtual-dtor]
#ifndef __MQL__
  virtual ~CandleOCTOHLC() {}
#endif

  /**
   * Initializes candle with a given start time, lenght in seconds, first tick's timestamp and its price.
   */
  void Init(int _start_time, int _length, long _timestamp_ms = -1, T _price = 0) {
    is_complete = false;
    start_time = _start_time;
    length = _length;
    open_timestamp_ms = _timestamp_ms;
    close_timestamp_ms = _timestamp_ms;
    volume = _price != 0 ? 1 : 0;
    THIS_ATTR open = THIS_ATTR high = THIS_ATTR low = THIS_ATTR close = _price;
  }

  /**
   * Updates OHLC values taking into consideration tick's timestamp.
   */
  void Update(long _timestamp_ms, T _price) {
    if (!ContainsTimeMs(_timestamp_ms)) {
      Print("Error: Cannot update candle. Given time doesn't fit in candle's time-frame!");
      DebugBreak();
    }

    bool _is_init = open_timestamp_ms == -1;

    if (_is_init || _timestamp_ms < open_timestamp_ms) {
      open_timestamp_ms = _timestamp_ms;
      THIS_ATTR open = _price;
    }
    if (_is_init || _timestamp_ms > close_timestamp_ms) {
      close_timestamp_ms = _timestamp_ms;
      THIS_ATTR close = _price;
    }

    if (_is_init) {
      THIS_ATTR high = _price;
      THIS_ATTR low = _price;
    } else {
      THIS_ATTR high = MathMax(THIS_ATTR high, _price);
      THIS_ATTR low = MathMin(THIS_ATTR low, _price);
    }
    // Increasing candle's volume.
    ++volume;
  }

  /**
   * Method used by ItemsHistory.
   */
  long GetTimeMs() { return (long)start_time * 1000; }

  /**
   * Method used by ItemsHistory.
   */
  long GetLengthMs() { return (long)length * 1000; }

  /**
   * Returns candle's start time.
   */
  datetime GetTime() { return (datetime)start_time; }

  /**
   * Returns timestamp of open price.
   */
  long GetOpenTimestamp() { return open_timestamp_ms / 1000; }

  /**
   * Returns timestamp of close price.
   */
  long GetCloseTimestamp() { return close_timestamp_ms / 1000; }

  /**
   * Whether given time fits in the candle.
   */
  bool ContainsTimeMs(long _time_ms) {
    return _time_ms >= (long)start_time * 1000 && _time_ms < (long)(start_time + length) * 1000;
  }

  // Serializers.
  SerializerNodeType Serialize(Serializer &s);

  /**
   * Returns text representation of candle.
   */
  string ToString() {
    return StringFormat("%.5f %.5f %.5f %.5f [%s] @ %s - %s", THIS_ATTR open, THIS_ATTR high, THIS_ATTR low,
                        THIS_ATTR close, is_complete ? "Complete" : "Incomplete",
                        TimeToString(open_timestamp_ms, TIME_DATE | TIME_MINUTES | TIME_SECONDS),
                        TimeToString(close_timestamp_ms, TIME_DATE | TIME_MINUTES | TIME_SECONDS));
  }
};

/**
 * Structure for storing OHLC values with timestamp.
 */
template <typename T>
struct CandleTOHLC : CandleOHLC<T> {
  datetime time;
  // Struct constructors.
  CandleTOHLC(datetime _time = 0, T _open = 0, T _high = 0, T _low = 0, T _close = 0)
      : time(_time), CandleOHLC<T>(_open, _high, _low, _close) {}
  // Getters.
  datetime GetTime() { return time; }
  // Serializers.
  SerializerNodeType Serialize(Serializer &s);
  // Converters.
  string ToCSV() {
    return StringFormat("%d,%g,%g,%g,%g", time, THIS_ATTR open, THIS_ATTR high, THIS_ATTR low, THIS_ATTR close);
  }
};

/* Method to serialize CandleEntry structure. */
template <typename T>
#ifdef __MQL__
SerializerNodeType CandleOHLC::Serialize(Serializer &s) {
#else
SerializerNodeType CandleOHLC<T>::Serialize(Serializer &s) {
#endif
  // s.Pass(THIS_REF, "time", TimeToString(time));
  s.Pass(THIS_REF, "open", open, SERIALIZER_FIELD_FLAG_DYNAMIC);
  s.Pass(THIS_REF, "high", high, SERIALIZER_FIELD_FLAG_DYNAMIC);
  s.Pass(THIS_REF, "low", low, SERIALIZER_FIELD_FLAG_DYNAMIC);
  s.Pass(THIS_REF, "close", close, SERIALIZER_FIELD_FLAG_DYNAMIC);
  return SerializerNodeObject;
}

/* Method to serialize CandleEntry structure. */
template <typename T>
#ifdef __MQL__
SerializerNodeType CandleTOHLC::Serialize(Serializer &s) {
#else
SerializerNodeType CandleTOHLC<T>::Serialize(Serializer &s) {
#endif
  s.Pass(THIS_REF, "time", time);
  s.Pass(THIS_REF, "open", THIS_ATTR open, SERIALIZER_FIELD_FLAG_DYNAMIC);
  s.Pass(THIS_REF, "high", THIS_ATTR high, SERIALIZER_FIELD_FLAG_DYNAMIC);
  s.Pass(THIS_REF, "low", THIS_ATTR low, SERIALIZER_FIELD_FLAG_DYNAMIC);
  s.Pass(THIS_REF, "close", THIS_ATTR close, SERIALIZER_FIELD_FLAG_DYNAMIC);
  return SerializerNodeObject;
}

/* Method to serialize CandleEntry structure. */
template <typename T>
#ifdef __MQL__
SerializerNodeType CandleOCTOHLC::Serialize(Serializer &s) {
#else
SerializerNodeType CandleOCTOHLC<T>::Serialize(Serializer &s) {
#endif
  s.Pass(THIS_REF, "is_complete", is_complete, SERIALIZER_FIELD_FLAG_DYNAMIC);
  s.Pass(THIS_REF, "open_timestamp_ms", open_timestamp_ms, SERIALIZER_FIELD_FLAG_DYNAMIC);
  s.Pass(THIS_REF, "close_timestamp_ms", close_timestamp_ms, SERIALIZER_FIELD_FLAG_DYNAMIC);
  s.Pass(THIS_REF, "open", THIS_ATTR open, SERIALIZER_FIELD_FLAG_DYNAMIC);
  s.Pass(THIS_REF, "high", THIS_ATTR high, SERIALIZER_FIELD_FLAG_DYNAMIC);
  s.Pass(THIS_REF, "low", THIS_ATTR low, SERIALIZER_FIELD_FLAG_DYNAMIC);
  s.Pass(THIS_REF, "close", THIS_ATTR close, SERIALIZER_FIELD_FLAG_DYNAMIC);
  s.Pass(THIS_REF, "volume", volume, SERIALIZER_FIELD_FLAG_DYNAMIC);
  return SerializerNodeObject;
}