//+------------------------------------------------------------------+ //| OMV Features.mqh | //| Copyright 2026, Allan Munene Mutiiria. | //| https://t.me/Forex_Algo_Trader | //+------------------------------------------------------------------+ #property copyright "Copyright 2026, Allan Munene Mutiiria." #property link "https://t.me/Forex_Algo_Trader" #ifndef OMV_FEATURES_MQH #define OMV_FEATURES_MQH //+------------------------------------------------------------------+ //| Feature limits | //+------------------------------------------------------------------+ #define OF_INPUTS 16 // Numbers the model reads on every bar #define OF_WARMUP 50 // Bars of history each number needs behind it #define OF_FLOOR 1e-9 // Smallest divisor allowed, so a flat run is safe //+------------------------------------------------------------------+ //| Name what each of the sixteen numbers measures | //+------------------------------------------------------------------+ string OmvFeatureName(const int i) { //--- Return the name for each feature index switch(i) { case 0: return "return 1 bar"; case 1: return "return 3 bars"; case 2: return "return 6 bars"; case 3: return "return 12 bars"; case 4: return "return 24 bars"; case 5: return "place in 20 range"; case 6: return "place in 50 range"; case 7: return "volatility regime"; case 8: return "body share"; case 9: return "upper wick"; case 10: return "lower wick"; case 11: return "from fast mean"; case 12: return "from slow mean"; case 13: return "mean separation"; case 14: return "hour as sine"; case 15: return "hour as cosine"; } //--- Name anything outside the sixteen by its place return "input " + IntegerToString(i); } //+------------------------------------------------------------------+ //| One bar's worth of model input | //+------------------------------------------------------------------+ struct OmvFeatures { // Hold the sixteen numbers in the order the model was trained on double value[OF_INPUTS]; // Stamp the bar these came from datetime when; // Report whether every number came out usable bool ready; }; //+------------------------------------------------------------------+ //| Builder that mirrors the training script exactly | //+------------------------------------------------------------------+ class COmvFeatures { private: // Keep the bars the numbers are built from, oldest first double m_open[]; double m_high[]; double m_low[]; double m_close[]; datetime m_time[]; // Count the bars held int m_bars; // Explain why the last build failed string m_error; double TrueRange(const int i) const; double RangeMean(const int i, const int n) const; double RollingHigh(const int i, const int n) const; double RollingLow(const int i, const int n) const; void Smooth(const double &src[], const int span, double &out[]) const; double Back(const double &src[], const int i, const int n) const; public: COmvFeatures(void); bool Load(const string symbol, const ENUM_TIMEFRAMES period, const int bars); bool Build(const int i, OmvFeatures &out) const; int Bars(void) const { return m_bars; } string Error(void) const { return m_error; } datetime TimeAt(const int i) const { return (i >= 0 && i < m_bars) ? m_time[i] : 0; } int IndexOf(const datetime stamp) const; }; //+------------------------------------------------------------------+ //| Construct an empty builder | //+------------------------------------------------------------------+ COmvFeatures::COmvFeatures(void) { //--- Start holding nothing m_bars = 0; m_error = ""; } //+------------------------------------------------------------------+ //| Take the bars the numbers will be built from | //+------------------------------------------------------------------+ bool COmvFeatures::Load(const string symbol, const ENUM_TIMEFRAMES period, const int bars) { //--- Refuse a request too short to fill the warm up if(bars <= OF_WARMUP) { m_error = "ask for more than " + IntegerToString(OF_WARMUP) + " bars"; return false; } //--- Take the rates in one call MqlRates rates[]; const int got = CopyRates(symbol, period, 0, bars, rates); if(got <= OF_WARMUP) { m_error = "only " + IntegerToString(got) + " bars came back for " + symbol; return false; } //--- Size the stores to what arrived ArrayResize(m_open, got); ArrayResize(m_high, got); ArrayResize(m_low, got); ArrayResize(m_close, got); ArrayResize(m_time, got); //--- Copy oldest first, which is the order the training script worked in for(int i = 0; i < got; i++) { //--- CopyRates already hands these back oldest first m_open[i] = rates[i].open; m_high[i] = rates[i].high; m_low[i] = rates[i].low; m_close[i] = rates[i].close; m_time[i] = rates[i].time; } m_bars = got; m_error = ""; //--- Report success return true; } //+------------------------------------------------------------------+ //| Find which held bar carries a given stamp | //+------------------------------------------------------------------+ int COmvFeatures::IndexOf(const datetime stamp) const { //--- Walk the stamps for an exact match for(int i = 0; i < m_bars; i++) if(m_time[i] == stamp) return i; //--- Report that no bar carries it return -1; } //+------------------------------------------------------------------+ //| Measure a bar, counting any gap from the bar before it | //+------------------------------------------------------------------+ double COmvFeatures::TrueRange(const int i) const { //--- The first bar has nothing before it, so it compares against itself const double prev = (i > 0) ? m_close[i - 1] : m_close[0]; //--- Take the widest of the three spans the bar covers const double a = m_high[i] - m_low[i]; const double b = MathAbs(m_high[i] - prev); const double c = MathAbs(m_low[i] - prev); return MathMax(a, MathMax(b, c)); } //+------------------------------------------------------------------+ //| Average the true range over the last n bars, ending at one | //+------------------------------------------------------------------+ double COmvFeatures::RangeMean(const int i, const int n) const { //--- Before the window fills, the training script averaged the opening run const int from = (i < n) ? 0 : i - n + 1; const int upto = (i < n) ? n - 1 : i; //--- Add every value the window covers double total = 0.0; int seen = 0; for(int k = from; k <= upto && k < m_bars; k++) { //--- Take the true range of this bar total += TrueRange(k); seen++; } //--- Report the average of what was covered return (seen > 0) ? total / seen : 0.0; } //+------------------------------------------------------------------+ //| Take the highest high over the last n bars | //+------------------------------------------------------------------+ double COmvFeatures::RollingHigh(const int i, const int n) const { //--- Walk back at most n bars, stopping at the start const int from = (i - n + 1 > 0) ? i - n + 1 : 0; double top = m_high[from]; for(int k = from; k <= i; k++) if(m_high[k] > top) top = m_high[k]; //--- Report the highest found return top; } //+------------------------------------------------------------------+ //| Take the lowest low over the last n bars | //+------------------------------------------------------------------+ double COmvFeatures::RollingLow(const int i, const int n) const { //--- Walk back at most n bars, stopping at the start const int from = (i - n + 1 > 0) ? i - n + 1 : 0; double floor = m_low[from]; for(int k = from; k <= i; k++) if(m_low[k] < floor) floor = m_low[k]; //--- Report the lowest found return floor; } //+------------------------------------------------------------------+ //| Smooth a series, seeding from its first value | //+------------------------------------------------------------------+ void COmvFeatures::Smooth(const double &src[], const int span, double &out[]) const { //--- Size the result to the series ArrayResize(out, m_bars); if(m_bars <= 0) return; //--- Seed from the first value, which is where the terminal's own average differs out[0] = src[0]; const double k = 2.0 / (span + 1.0); for(int i = 1; i < m_bars; i++) out[i] = src[i] * k + out[i - 1] * (1.0 - k); } //+------------------------------------------------------------------+ //| Reach back n bars, clamping at the start of the series | //+------------------------------------------------------------------+ double COmvFeatures::Back(const double &src[], const int i, const int n) const { //--- Before the series is long enough, the training script held the first value return (i - n >= 0) ? src[i - n] : src[0]; } //+------------------------------------------------------------------+ //| Build the sixteen numbers for one bar | //+------------------------------------------------------------------+ bool COmvFeatures::Build(const int i, OmvFeatures &out) const { //--- Start with nothing filled out.ready = false; out.when = 0; for(int k = 0; k < OF_INPUTS; k++) out.value[k] = 0.0; //--- Refuse a bar with too little history behind it if(i < OF_WARMUP || i >= m_bars) return false; //--- Measure how far the market has been moving lately const double atr14 = RangeMean(i, 14); const double atr50 = RangeMean(i, 50); const double safe = MathMax(atr14, OF_FLOOR); //--- Measure the ranges the price sits inside const double hi20 = RollingHigh(i, 20), lo20 = RollingLow(i, 20); const double hi50 = RollingHigh(i, 50), lo50 = RollingLow(i, 50); const double span20 = MathMax(hi20 - lo20, OF_FLOOR); const double span50 = MathMax(hi50 - lo50, OF_FLOOR); //--- Smooth the closes twice, at the two spans the model was trained on double ema12[], ema50[]; Smooth(m_close, 12, ema12); Smooth(m_close, 50, ema50); //--- Measure the bar itself const double rng = MathMax(m_high[i] - m_low[i], OF_FLOOR); const double topBody = MathMax(m_open[i], m_close[i]); const double lowBody = MathMin(m_open[i], m_close[i]); //--- Take the hour the bar opened, which the model reads as an angle MqlDateTime parts; TimeToStruct(m_time[i], parts); const double angle = 2.0 * M_PI * parts.hour / 24.0; //--- Fill the sixteen in the order the model was trained on out.value[0] = (m_close[i] - Back(m_close, i, 1)) / safe; out.value[1] = (m_close[i] - Back(m_close, i, 3)) / safe; out.value[2] = (m_close[i] - Back(m_close, i, 6)) / safe; out.value[3] = (m_close[i] - Back(m_close, i, 12)) / safe; out.value[4] = (m_close[i] - Back(m_close, i, 24)) / safe; out.value[5] = (m_close[i] - lo20) / span20; out.value[6] = (m_close[i] - lo50) / span50; out.value[7] = atr14 / MathMax(atr50, OF_FLOOR); out.value[8] = (m_close[i] - m_open[i]) / rng; out.value[9] = (m_high[i] - topBody) / rng; out.value[10] = (lowBody - m_low[i]) / rng; out.value[11] = (m_close[i] - ema12[i]) / safe; out.value[12] = (m_close[i] - ema50[i]) / safe; out.value[13] = (ema12[i] - ema50[i]) / safe; out.value[14] = MathSin(angle); out.value[15] = MathCos(angle); //--- Reject the bar when any number came out unusable for(int k = 0; k < OF_INPUTS; k++) if(!MathIsValidNumber(out.value[k])) return false; //--- Stamp the bar and report success out.when = m_time[i]; out.ready = true; return true; } #endif // OMV_FEATURES_MQH //+------------------------------------------------------------------+