dualea/Experts/Advisors/DualEA/Include/CMarketModelFeatures.mqh

#ifndef DUALEA_MARKET_MODEL_FEATURES_MQH
#define DUALEA_MARKET_MODEL_FEATURES_MQH

// Version 1: completed-bar market features, oldest bar first. No indicator
// state, gate outcomes, strategy decisions, or future observations are inputs.
#define MARKET_MODEL_FEATURE_COUNT 12

void MarketModelFeatureNames(string &names[])
{
   ArrayResize(names,MARKET_MODEL_FEATURE_COUNT);
   names[0]="mm_signed_logret1";
   names[1]="mm_signed_logret3";
   names[2]="mm_signed_logret12";
   names[3]="mm_signed_zscore12";
   names[4]="mm_return_std12";
   names[5]="mm_range";
   names[6]="mm_signed_body";
   names[7]="mm_spread";
   names[8]="mm_hour_sin";
   names[9]="mm_hour_cos";
   names[10]="mm_direction";
   names[11]="mm_atr14";
}

bool MarketModelFeaturesFromRates(const MqlRates &rates[],const int closed_index,
                                 const int direction,const double point,
                                 const datetime decision_time,double &features[])
{
   ArrayResize(features,0);
   if(ArrayGetAsSeries(rates) || closed_index<14 || closed_index>=ArraySize(rates) ||
      (direction!=0 && direction!=1) || !MathIsValidNumber(point) || point<=0.0 ||
      decision_time<rates[closed_index].time+PeriodSeconds(PERIOD_H1))
      return false;

   // Only this explicit backward window is read. Later array entries may
   // contain future prices during training and must never affect features.
   for(int i=closed_index-14;i<=closed_index;i++)
   {
      if(rates[i].time<=0 || (i>closed_index-14 && rates[i].time<=rates[i-1].time) ||
         !MathIsValidNumber(rates[i].open) || !MathIsValidNumber(rates[i].high) ||
         !MathIsValidNumber(rates[i].low) || !MathIsValidNumber(rates[i].close) ||
         rates[i].open<=0.0 || rates[i].low<=0.0 || rates[i].close<=0.0 ||
         rates[i].high<rates[i].low || rates[i].high<MathMax(rates[i].open,rates[i].close) ||
         rates[i].low>MathMin(rates[i].open,rates[i].close) || rates[i].spread<0)
         return false;
   }

   double side=direction==0 ? 1.0 : -1.0;
   double last=rates[closed_index].close;
   double mean=0.0,return_mean=0.0;
   double returns[12];
   for(int i=0;i<12;i++)
   {
      int index=closed_index-i;
      mean+=rates[index].close/12.0;
      returns[i]=MathLog(rates[index].close/rates[index-1].close);
      return_mean+=returns[i]/12.0;
   }
   double price_var=0.0,return_var=0.0;
   for(int i=0;i<12;i++)
   {
      double delta=rates[closed_index-i].close-mean;
      price_var+=delta*delta/12.0;
      double return_delta=returns[i]-return_mean;
      return_var+=return_delta*return_delta/12.0;
   }
   double atr=0.0;
   for(int i=0;i<14;i++)
   {
      int index=closed_index-i;
      double previous=rates[index-1].close;
      double tr=MathMax(rates[index].high-rates[index].low,
                        MathMax(MathAbs(rates[index].high-previous),MathAbs(rates[index].low-previous)));
      atr+=tr/14.0;
   }
   MqlDateTime dt;
   if(!TimeToStruct(decision_time,dt)) return false;
   double hour_angle=2.0*3.14159265358979323846*dt.hour/24.0;
   ArrayResize(features,MARKET_MODEL_FEATURE_COUNT);
   features[0]=side*returns[0];
   features[1]=side*MathLog(last/rates[closed_index-3].close);
   features[2]=side*MathLog(last/rates[closed_index-12].close);
   features[3]=price_var>0.0 ? side*(last-mean)/MathSqrt(price_var) : 0.0;
   features[4]=MathSqrt(return_var);
   features[5]=(rates[closed_index].high-rates[closed_index].low)/last;
   features[6]=side*(last-rates[closed_index].open)/last;
   features[7]=(double)rates[closed_index].spread*point/last;
   features[8]=MathSin(hour_angle);
   features[9]=MathCos(hour_angle);
   features[10]=side;
   features[11]=atr/last;
   for(int i=0;i<MARKET_MODEL_FEATURE_COUNT;i++)
      if(!MathIsValidNumber(features[i])) { ArrayResize(features,0); return false; }
   return true;
}

bool BuildMarketModelFeatures(const string symbol,const ENUM_TIMEFRAMES tf,
                              const datetime decision_time,const int direction,
                              double &features[])
{
   ArrayResize(features,0);
   int seconds=PeriodSeconds(tf);
   if(seconds<=0 || decision_time<=0) return false;
   int decision_shift=iBarShift(symbol,tf,decision_time,false);
   if(decision_shift<0) return false;
   MqlRates rates[];
   ArraySetAsSeries(rates,false);
   int copied=CopyRates(symbol,tf,decision_shift+1,64,rates);
   if(copied<15) return false;
   int last=copied-1;
   if(rates[last].time+seconds>decision_time) return false;
   double point=SymbolInfoDouble(symbol,SYMBOL_POINT);
   return MarketModelFeaturesFromRates(rates,last,direction,point,decision_time,features);
}

// Broker symbols retain their identity when matching the active symbol. Only
// feature identifiers are normalized; punctuation is never silently stripped
// from a broker symbol to claim support for a different instrument.
string NormalizeUniversalModelSymbol(string symbol)
{
   StringToLower(symbol);
   string normalized="";
   for(int i=0;i<StringLen(symbol);i++)
   {
      ushort character=StringGetCharacter(symbol,i);
      if((character>='a' && character<='z') || (character>='0' && character<='9'))
         normalized+=ShortToString(character);
      else
         normalized+="_";
   }
   return normalized;
}

bool ValidateUniversalModelSymbols(const string &symbols[])
{
   int count=ArraySize(symbols);
   if(count<=0) return false;
   for(int i=0;i<count;i++)
   {
      if(symbols[i]=="") return false;
      string normalized=NormalizeUniversalModelSymbol(symbols[i]);
      for(int j=0;j<i;j++)
         if(normalized==NormalizeUniversalModelSymbol(symbols[j])) return false;
   }
   return true;
}

bool UniversalModelFeatureNames(const string &symbols[],string &names[])
{
   ArrayResize(names,0);
   if(!ValidateUniversalModelSymbols(symbols)) return false;
   MarketModelFeatureNames(names);
   int count=ArraySize(symbols);
   ArrayResize(names,MARKET_MODEL_FEATURE_COUNT+4*count);
   for(int i=0;i<count;i++)
   {
      int offset=MARKET_MODEL_FEATURE_COUNT+4*i;
      string prefix="sym_"+NormalizeUniversalModelSymbol(symbols[i]);
      names[offset]=prefix+"_flag";
      names[offset+1]=prefix+"_ret1";
      names[offset+2]=prefix+"_ret3";
      names[offset+3]=prefix+"_zscore";
   }
   return true;
}

bool ExpandUniversalModelFeatures(const double &base[],const string symbol,
                                  const string &symbols[],double &features[])
{
   ArrayResize(features,0);
   if(ArraySize(base)!=MARKET_MODEL_FEATURE_COUNT || !ValidateUniversalModelSymbols(symbols))
      return false;
   int active=-1;
   for(int i=0;i<ArraySize(symbols);i++)
      if(StringCompare(symbol,symbols[i],false)==0) {active=i;break;}
   if(active<0) return false;
   for(int i=0;i<MARKET_MODEL_FEATURE_COUNT;i++)
      if(!MathIsValidNumber(base[i])) return false;
   if(base[4]<0.0) return false;
   int count=MARKET_MODEL_FEATURE_COUNT+4*ArraySize(symbols);
   ArrayResize(features,count);
   ArrayInitialize(features,0.0);
   for(int i=0;i<MARKET_MODEL_FEATURE_COUNT;i++) features[i]=base[i];
   int offset=MARKET_MODEL_FEATURE_COUNT+4*active;
   double scale=MathMax(base[4],1e-8);
   features[offset]=1.0;
   features[offset+1]=base[0]/scale;
   features[offset+2]=base[1]/scale;
   features[offset+3]=base[3];
   for(int i=0;i<count;i++)
      if(!MathIsValidNumber(features[i])) {ArrayResize(features,0);return false;}
   return true;
}

bool UniversalModelFeaturesFromRates(const MqlRates &rates[],const int closed_index,
                                     const int direction,const double point,
                                     const datetime decision_time,const string symbol,
                                     const string &symbols[],double &features[])
{
   double base[];
   if(!MarketModelFeaturesFromRates(rates,closed_index,direction,point,decision_time,base))
   {
      ArrayResize(features,0);
      return false;
   }
   return ExpandUniversalModelFeatures(base,symbol,symbols,features);
}
#endif