//+------------------------------------------------------------------+
//|                                                       Warrior_EA |
//|                                                     AnimateDread |
//|                                                                  |
//+------------------------------------------------------------------+
#include "ExpertSignalCustom.mqh"
#include "..\AI\Network.mqh"
class CExpertSignalAIBase : public CExpertSignalCustom
  {
protected:
   string              ID;
   CiOpen              m_Open;
   CiClose             m_Close;
   CiHigh              m_High;
   CiLow               m_Low;
   CiVolumes           m_Volumes;
   CiTime              m_Time;
   CiAD                m_AD;
   CiADX               m_ADX;
   CiAC                m_AC;
   CiAlligator         m_Alligator;
   CiAO                m_AO;
   CiBWMFI             m_BWMFI;
   CiGator             m_Gator;
   CiBands             m_Bands;
   CiCCI               m_CCI;
   CiMACD              m_MACD;
   CiMFI               m_MFI;
   CiOBV               m_OBV;
   CiRSI               m_RSI;
   CiRVI               m_RVI;
   CiStochastic        m_STOCH;
   CiSAR               m_SAR;
   CiWPR               m_WPR;
   CNet               *Net;
   CArrayDouble       *TempData;
   double              dError;
   double              dUndefine;
   double              dForecast;
   double              dPrevSignal;
   datetime            dtStudied;
   bool                bEventStudy;
   //--- variables
   int                 m_buttonHandle;   // Handle for the play/pause button
   bool                m_isPlaying;     // Flag to indicate whether training is playing or paused
   string              m_fileName;
   string              m_folderPath;
   int                 m_optimizationAlgo;
   int                 m_historyBars;
   int                 m_outputNeuronsCount;
   int                 m_minNeuronsCount;
   int                 m_initialNeuronsCount;
   int                 m_neuronsCount;
   double              m_neuronsReduction;
   int                 m_hiddenLayersCount;
   int                 m_studyPeriod;
   int                 m_minTrainYear;
   bool                m_isInitialized;
   int                 m_stopTrainWR;
   int                 m_fractalPeriods;
   //--- functions
   virtual bool        InitIndicators(CIndicators *indicators);
   void                DrawObject(datetime time, double signal, double high, double low);
   void                DeleteObject(datetime time);
   void                PurgeChart(void);
   ENUM_SIGNAL         DoubleToSignal(double value);
   bool                ResizeBuffers(int barIndex);
   bool                RefreshData();
   bool                BufferTempData(int idx);
   void                Train(datetime StartTrainBar = 0);
   //--- method of initialization of the indicators
   bool              InitOpen(CIndicators *indicators);
   bool              InitClose(CIndicators *indicators);
   bool              InitHigh(CIndicators *indicators);
   bool              InitLow(CIndicators *indicators);
   bool              InitVolumes(CIndicators *indicators);
   bool              InitTime(CIndicators *indicators);
   bool              InitAC(CIndicators *indicators);
   bool              InitAlligator(CIndicators *indicators);
   bool              InitAO(CIndicators *indicators);
   bool              InitBWMFI(CIndicators *indicators);
   bool              InitGator(CIndicators *indicators);
   bool              InitAD(CIndicators *indicators);
   bool              InitADX(CIndicators *indicators);
   bool              InitBands(CIndicators *indicators);
   bool              InitCCI(CIndicators *indicators);
   bool              InitMACD(CIndicators *indicators);
   bool              InitMFI(CIndicators *indicators);
   bool              InitOBV(CIndicators *indicators);
   bool              InitRSI(CIndicators *indicators);
   bool              InitRVI(CIndicators *indicators);
   bool              InitSTOCH(CIndicators *indicators);
   bool              InitSAR(CIndicators *indicators);
   bool              InitWPR(CIndicators *indicators);
   bool              SaveTopologyConfiguration(string fileName, int initialNeuronsCount, int hiddenLayersCount, double neuronsReduction, int minNeuronsCount, int optimizationAlgo, int historyBars, int outputNeuronsCount, int neuronsCount, int studyPeriod, int minTrainYear, bool isInitialized, int stopTrainWR, int fractalPeriods);
   bool              LoadAndCompareTopologyConfiguration(string fileName, int initialNeuronsCount, int hiddenLayersCount, double neuronsReduction, int minNeuronsCount, int optimizationAlgo, int historyBars, int outputNeuronsCount, int neuronsCount, int studyPeriod, int minTrainYear, bool isInitialized, int stopTrainWR, int fractalPeriods);
   //--- input data
   bool                m_useVolumes;
   bool                m_useTime;
   bool                m_useATR;
   bool                m_useAC;
   bool                m_useAlligator;
   bool                m_useAO;
   bool                m_useBWMFI;
   bool                m_useGator;
   bool                m_useAD;
   bool                m_useADX;
   bool                m_useBands;
   bool                m_useCCI;
   bool                m_useMACD;
   bool                m_useMFI;
   bool                m_useOBV;
   bool                m_useRSI;
   bool                m_useRVI;
   bool                m_useSTOCH;
   bool                m_useSAR;
   bool                m_useWPR;

public:
                     CExpertSignalAIBase(void);
                    ~CExpertSignalAIBase(void);
   //--- methods of setting adjustable parameters
   void              OptimizationAlgo(int algo) { m_optimizationAlgo = algo; }
   void              InitialNeuronsCount(int value) { m_initialNeuronsCount = value; }
   void              OutputNeuronsCount(int value) { m_outputNeuronsCount = value; }
   void              MinNeuronsCount(int value) { m_minNeuronsCount = value; }
   void              HiddenLayersCount(int value) { m_hiddenLayersCount = value; }
   void              NeuronsReduction(int value) { m_neuronsReduction = value; }
   void              StopTrainWR(int value) { m_stopTrainWR = value; }
   void              HistoryBars(int value) { m_historyBars = value; }
   void              StudyPeriod(int value) { m_studyPeriod = value; }
   void              MinTrainYear(int value) { m_minTrainYear = value; }
   void              UseVolumes(bool value) { m_useVolumes = value; }
   void              UseTime(bool value) { m_useTime = value; }
   void              UseATR(bool value) { m_useATR = value; }
   void              UseAC(bool value) { m_useAC = value; }
   void              UseAlligator(bool value) { m_useAlligator = value; }
   void              UseAO(bool value) { m_useAO = value; };
   void              UseBWMFI(bool value) { m_useBWMFI = value; };
   void              UseGator(bool value) { m_useGator = value; };
   void              UseAD(bool value) { m_useAD = value; }
   void              UseADX(bool value) { m_useADX = value; }
   void              UseBands(bool value) { m_useBands = value; }
   void              UseCCI(bool value) { m_useCCI = value; }
   void              UseMACD(bool value) { m_useMACD = value; }
   void              UseMFI(bool value) { m_useMFI = value; }
   void              UseOBV(bool value) { m_useOBV = value; }
   void              UseRSI(bool value) { m_useRSI = value; }
   void              UseRVI(bool value) { m_useRVI = value; }
   void              UseSTOCH(bool value) { m_useSTOCH = value; }
   void              UseSAR(bool value) { m_useSAR = value; }
   void              UseWPR(bool value) { m_useWPR = value; }
  };
//+------------------------------------------------------------------+
//| Constructor                                                      |
//+------------------------------------------------------------------+
CExpertSignalAIBase::CExpertSignalAIBase(void) :
   ID("NULL"),
   m_neuronsCount(0),
   m_studyPeriod(10),
   m_minTrainYear(1970),
   m_optimizationAlgo(0),
   m_initialNeuronsCount(1000),
   m_outputNeuronsCount(3),
   m_minNeuronsCount(20),
   m_neuronsReduction(0.5),
   m_hiddenLayersCount(4),
   m_historyBars(14),
   m_stopTrainWR(70),
   m_fractalPeriods(5),
   m_useVolumes(true),
   m_useTime(true),
   m_useATR(true),
   m_useAC(false),
   m_useAlligator(false),
   m_useAO(false),
   m_useBWMFI(false),
   m_useGator(false),
   m_useAD(false),
   m_useADX(false),
   m_useBands(false),
   m_useCCI(false),
   m_useMACD(false),
   m_useMFI(false),
   m_useOBV(false),
   m_useRSI(false),
   m_useRVI(false),
   m_useSTOCH(false),
   m_useSAR(false),
   m_useWPR(false),
   Net(NULL),
   TempData(NULL),
   dError(-1),
   dUndefine(0),
   dForecast(0),
   dPrevSignal(0),
   dtStudied(0),
   bEventStudy(false),
   m_isInitialized(false)
  {
  }
//+------------------------------------------------------------------+
//| Destructor                                                       |
//+------------------------------------------------------------------+
CExpertSignalAIBase::~CExpertSignalAIBase(void)
  {
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool CExpertSignalAIBase::InitIndicators(CIndicators *indicators)
  {
   PurgeChart();
   if(!InitOpen(indicators))
      return false;
   if(!InitClose(indicators))
      return false;
   if(!InitLow(indicators))
      return false;
   if(!InitHigh(indicators))
      return false;
   m_neuronsCount = 3; // set by default for price data
   if(m_useVolumes)
     {
      m_neuronsCount++;
      if(!InitVolumes(indicators))
         return false;
     }
   if(m_useTime)
     {
      m_neuronsCount += 6;
      if(!InitTime(indicators))
         return false;
     }
   if(m_useATR)
     {
      //already init in the base class
      m_neuronsCount++;
     }
   if(m_useAC)
     {
      if(!InitAC(indicators))
         return false;
      m_neuronsCount++;
     }
   if(m_useAlligator)
     {
      if(!InitAlligator(indicators))
         return false;
      m_neuronsCount += 12;
     }
   if(m_useAO)
     {
      if(!InitAO(indicators))
         return false;
      m_neuronsCount++;
     }
   if(m_useBWMFI)
     {
      if(!InitBWMFI(indicators))
         return false;
      m_neuronsCount++;
     }
   if(m_useGator)
     {
      if(!InitGator(indicators))
         return false;
      m_neuronsCount += 8;
     }
   if(m_useAD)
     {
      if(!InitAD(indicators))
         return false;
      m_neuronsCount++;
     }
   if(m_useADX)
     {
      if(!InitADX(indicators))
         return false;
      m_neuronsCount += 3;
     }
   if(m_useBands)
     {
      if(!InitBands(indicators))
         return false;
      m_neuronsCount += 12;
     }
   if(m_useCCI)
     {
      if(!InitCCI(indicators))
         return false;
      m_neuronsCount++;
     }
   if(m_useMACD)
     {
      if(!InitMACD(indicators))
         return false;
      m_neuronsCount += 2;
     }
   if(m_useMFI)
     {
      if(!InitMFI(indicators))
         return false;
      m_neuronsCount++;
     }
   if(m_useOBV)
     {
      if(!InitOBV(indicators))
         return false;
      m_neuronsCount++;
     }
   if(m_useRSI)
     {
      if(!InitRSI(indicators))
         return false;
      m_neuronsCount++;
     }
   if(m_useRVI)
     {
      if(!InitRVI(indicators))
         return false;
      m_neuronsCount += 2;
     }
   if(m_useSTOCH)
     {
      if(!InitSTOCH(indicators))
         return false;
      m_neuronsCount += 2;
     }
   if(m_useSAR)
     {
      if(!InitSAR(indicators))
         return false;
      m_neuronsCount += 4;
     }
   if(m_useWPR)
     {
      if(!InitWPR(indicators))
         return false;
      m_neuronsCount++;
     }
   if(!FolderCreate(m_folderPath, FILE_COMMON))
     {
      if(GetLastError() != 5010) // If the error is not because the folder already exists
        {
         Print("Failed to create folder: " + m_folderPath);
        }
      else
        {
         ResetLastError(); // Reset the error code
        }
     }
   return true;
  }
//+------------------------------------------------------------------+
//| Training and Signal Methods                                      |
//+------------------------------------------------------------------+
void CExpertSignalAIBase::Train(datetime StartTrainBar = 0)
  {
   int count = 0;
//---
   MqlDateTime start_time;
   TimeCurrent(start_time);
   start_time.year -= m_studyPeriod;
   if(start_time.year <= 0 || start_time.year < m_minTrainYear)
      start_time.year = m_minTrainYear;
   datetime st_time = StructToTime(start_time);
   dtStudied = MathMax(StartTrainBar, st_time);
   double prev_up = -1;
   double prev_for = -1;
   double prev_er = -1;
   datetime bar_time = 0;
   bool stop = IsStopped();
//---
   do
     {
      int bars = (int)MathMin(Bars(m_symbol.Name(), PERIOD_CURRENT, dtStudied, TimeCurrent()) + m_historyBars, Bars(m_symbol.Name(), PERIOD_CURRENT));
      prev_up = dUndefine;
      prev_for = dForecast;
      prev_er = dError;
      ENUM_SIGNAL bar = Neutral;
      long tick = 0;
      if(!ResizeBuffers(bars) || !RefreshData())
        {
         break;
         return;
        }
      stop = IsStopped();
      bool add_loop = false;
      // Iterate over the bars
      for(int i = (int)(bars - MathMax(m_historyBars, 0) - 1); i >= 0 && !stop; i--)
        {
         string s;
         if(m_outputNeuronsCount == 1)
           {
            s = StringFormat(
                   ID + " : Study -> Era %d\n" +
                   "Bar %d of %d -> %.2f%%\n" +
                   "Accuracy: %.2f%%\n" +
                   "Mean Squared Error: %.2f\n" +
                   "Recent Average Error: %.2f\n" +
                   "Signal Neuron: %.5f\n" +
                   "Forecast: %s -> %.2f",
                   count,
                   bars - i + 1, bars, (double)(bars - i + 1.0) / bars * 100,
                   dForecast,
                   dError,
                   Net.getRecentAverageError(),
                   TempData[0],
                   EnumToString(DoubleToSignal(dPrevSignal)), dPrevSignal
                );
           }
         else
            if(m_outputNeuronsCount == 3)
              {
               s = StringFormat(
                      ID + " : Study -> Era %d\n" +
                      "Bar %d of %d -> %.2f%%\n" +
                      "Accuracy: %.2f%%\n" +
                      "Mean Squared Error: %.2f\n" +
                      "Recent Average Error: %.2f\n" +
                      "Buy Neuron: %.5f - Sell Neuron: %.5f - Neutral Neuron: %.5f\n" +
                      "Forecast: %s -> %.2f",
                      count,
                      bars - i + 1, bars, (double)(bars - i + 1.0) / bars * 100,
                      dForecast,
                      dError,
                      Net.getRecentAverageError(),
                      TempData[0], TempData[1], TempData[2],
                      EnumToString(DoubleToSignal(dPrevSignal)), dPrevSignal
                   );
              }
            else
              {
               s = "Invalid neuron count!";
              }
         Comment(s);
         if(add_loop && i < (int)(bars - MathMax(m_historyBars, 0) - 1) && i > 1 && m_Time.GetData(i) > dtStudied && dPrevSignal != -2)
           {
            TempData.Clear();
            bool sell = false, buy = false;
            for(int j = 1; j <= m_fractalPeriods; j++)
              {
               if(m_Low.GetData(i) < m_Low.GetData(i + j) && m_Low.GetData(i) < m_Low.GetData(i - j))
                  buy = true;
               if(m_High.GetData(i) > m_High.GetData(i + j) && m_High.GetData(i) > m_High.GetData(i - j))
                  sell = true;
              }
            if(m_outputNeuronsCount == 1)
              {
               TempData.Add(buy && !sell ? 1 : !buy && sell ? -1 : 0);
              }
            else
               if(m_outputNeuronsCount == 3)
                 {
                  TempData.Add(buy ? 1.0 : 0.0);        // 1 for buy
                  TempData.Add(sell ? 1.0 : 0.0);       // 1 for sell
                  TempData.Add((!buy && !sell) ? 1.0 : 0.0); // 1 for neutral
                 }
            if(TempData.Total() > 0)
              {
               Net.backProp(TempData);
               if(DoubleToSignal(dPrevSignal) == Buy || DoubleToSignal(dPrevSignal) == Sell || DoubleToSignal(dPrevSignal) == Neutral)
                 {
                  if(DoubleToSignal(dPrevSignal) == DoubleToSignal(TempData.At(0)))
                     dForecast += (100 - dForecast) / Net.recentAverageSmoothingFactor;
                  else
                     dForecast -= dForecast / Net.recentAverageSmoothingFactor;
                  dUndefine -= dUndefine / Net.recentAverageSmoothingFactor;
                 }
               else
                 {
                  if((buy && sell))
                     dUndefine += (100 - dUndefine) / Net.recentAverageSmoothingFactor;
                 }
              }
           }
         TempData.Clear();
         int r = i + (int)m_historyBars;
         if(r > bars)
            continue;
         for(int b = 0; b < (int)m_historyBars; b++)
           {
            int bar_t = r + b;
            if(!BufferTempData(bar_t))
              {
               break;
               return;
              }
           }
         if(TempData.Total() >= (int)m_historyBars * m_neuronsCount)
           {
            add_loop = true;
            Net.feedForward(TempData);
            Net.getResults(TempData);
            if(m_outputNeuronsCount == 1)
               dPrevSignal = TempData[0];
            else
               if(m_outputNeuronsCount == 3)
                 {
                  double sum = 0;
                  for(int res = 0; res < 3; res++)
                    {
                     double temp = exp(TempData.At(res));
                     sum += temp;
                     TempData.Update(res, temp);
                    }
                  for(int res = 0; res < 3; res++)
                     TempData.Update(res, TempData.At(res) / sum);
                  //---
                  switch(TempData.Maximum(0, 3))
                    {
                     case 0:
                        dPrevSignal = TempData[0]; // Buy signal
                        break;
                     case 1:
                        dPrevSignal = -TempData[1]; // Sell signal
                        break;
                     case 2:
                        dPrevSignal = 0; // Neutral signal
                        break;
                     default:
                        dPrevSignal = 0; // Default to Neutral if something goes wrong
                        break;
                    }
                 }
            bar_time = m_Time.GetData(i);
            if(i > 0)
              {
               if(DoubleToSignal(dPrevSignal) == Neutral)
                  DeleteObject(bar_time);
               else
                  DrawObject(bar_time, dPrevSignal, m_High.GetData(i), m_Low.GetData(i));
              }
           }
         stop = IsStopped();
        }
      if(add_loop)
         count++;
      if(!stop)
        {
         dError = Net.getRecentAverageError();
         if(add_loop)
           {
            Net.Save(m_fileName + ".nnw", dError, dUndefine, dForecast, dtStudied, true);
           }
        }
     }
   while((dForecast < m_stopTrainWR || dError >= 0.1 || MathAbs(dError - prev_er) >= 0.01 || MathAbs(dUndefine - prev_up) >= 0.1 || MathAbs(dForecast - prev_for) >= 0.1) && !stop);
   if(count > 0)
     {
      dtStudied = bar_time;
     }
  }
//+------------------------------------------------------------------+
//| Converts a double to ENUM_SIGNAL                                 |
//+------------------------------------------------------------------+
ENUM_SIGNAL CExpertSignalAIBase::DoubleToSignal(double value)
  {
   value = NormalizeDouble(value, 2); // Round 'value' to two decimal places
   if(value > 0.50 && value <= 1.0)
      return Buy;
   else
      if(value < -0.50 && value >= -1.0)
         return Sell;
      else
         if(value >= -0.50 && value <= 0.50)
            return Neutral;
         else
            return Undefine;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CExpertSignalAIBase::DrawObject(datetime time, double signal, double high, double low)
  {
   double price = 0;
   int arrow = 0;
   color clr = 0;
   ENUM_ARROW_ANCHOR anch = ANCHOR_BOTTOM;
   switch(DoubleToSignal(signal))
     {
      case Buy:
         price = low;
         arrow = 217;
         clr = clrBlue;
         anch = ANCHOR_TOP;
         break;
      case Sell:
         price = high;
         arrow = 218;
         clr = clrRed;
         anch = ANCHOR_BOTTOM;
         break;
     }
   if(price == 0 || arrow == 0)
      return;
   string name = TimeToString(time);
   if(ObjectFind(0, name) < 0)
     {
      ResetLastError();
      if(!ObjectCreate(0, name, OBJ_ARROW, 0, time, 0))
        {
         printf("Error of creating object %d", GetLastError());
         return;
        }
     }
   ObjectSetDouble(0, name, OBJPROP_PRICE, price);
   ObjectSetInteger(0, name, OBJPROP_ARROWCODE, arrow);
   ObjectSetInteger(0, name, OBJPROP_COLOR, clr);
   ObjectSetInteger(0, name, OBJPROP_ANCHOR, anch);
   ObjectSetString(0, name, OBJPROP_TOOLTIP, EnumToString(DoubleToSignal(signal)) + " " + DoubleToString(signal, 5));
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CExpertSignalAIBase::DeleteObject(datetime time)
  {
   string name = TimeToString(time);
   if(ObjectFind(0, name) >= 0)
      ObjectDelete(0, name);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool CExpertSignalAIBase::ResizeBuffers(int barIndex)
  {
   if(!m_Open.BufferResize(barIndex) || !m_Close.BufferResize(barIndex) || !m_High.BufferResize(barIndex) || !m_Low.BufferResize(barIndex))
      return false;
   if(m_useVolumes)
     {
      if(!m_Volumes.BufferResize(barIndex))
         return false;
     }
   if(m_useTime)
     {
      if(!m_Time.BufferResize(barIndex))
         return false;
     }
   if(m_useATR)
     {
      if(!m_ATR.BufferResize(barIndex))
         return false;
     }
   if(m_useAC)
     {
      if(!m_AC.BufferResize(barIndex))
         return false;
     }
   if(m_useAlligator)
     {
      if(!m_Alligator.BufferResize(barIndex))
         return false;
     }
   if(m_useAO)
     {
      if(!m_AO.BufferResize(barIndex))
         return false;
     }
   if(m_useBWMFI)
     {
      if(!m_BWMFI.BufferResize(barIndex))
         return false;
     }
   if(m_useGator)
     {
      if(!m_Gator.BufferResize(barIndex))
         return false;
     }
   if(m_useAD)
     {
      if(!m_AD.BufferResize(barIndex))
         return false;
     }
   if(m_useADX)
     {
      if(!m_ADX.BufferResize(barIndex))
         return false;
     }
   if(m_useBands)
     {
      if(!m_Bands.BufferResize(barIndex))
         return false;
     }
   if(m_useCCI)
     {
      if(!m_CCI.BufferResize(barIndex))
         return false;
     }
   if(m_useMACD)
     {
      if(!m_MACD.BufferResize(barIndex))
         return false;
     }
   if(m_useMFI)
     {
      if(!m_MFI.BufferResize(barIndex))
         return false;
     }
   if(m_useOBV)
     {
      if(!m_OBV.BufferResize(barIndex))
         return false;
     }
   if(m_useRSI)
     {
      if(!m_RSI.BufferResize(barIndex))
         return false;
     }
   if(m_useRVI)
     {
      if(!m_RVI.BufferResize(barIndex))
         return false;
     }
   if(m_useSTOCH)
     {
      if(!m_STOCH.BufferResize(barIndex))
         return false;
     }
   if(m_useSAR)
     {
      if(!m_SAR.BufferResize(barIndex))
         return false;
     }
   if(m_useWPR)
     {
      if(!m_WPR.BufferResize(barIndex))
         return false;
     }
   return true;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool CExpertSignalAIBase::RefreshData()
  {
   m_Open.Refresh(OBJ_ALL_PERIODS);
   m_Close.Refresh(OBJ_ALL_PERIODS);
   m_High.Refresh(OBJ_ALL_PERIODS);
   m_Low.Refresh(OBJ_ALL_PERIODS);
   if(m_useVolumes)
     {
      m_Volumes.Refresh(OBJ_ALL_PERIODS);
     }
   if(m_useTime)
     {
      m_Time.Refresh(OBJ_ALL_PERIODS);
     }
   if(m_useATR)
     {
      m_ATR.Refresh(OBJ_ALL_PERIODS);
     }
   if(m_useAC)
     {
      m_AC.Refresh(OBJ_ALL_PERIODS);
     }
   if(m_useAlligator)
     {
      m_Alligator.Refresh(OBJ_ALL_PERIODS);
     }
   if(m_useAO)
     {
      m_AO.Refresh(OBJ_ALL_PERIODS);
     }
   if(m_useBWMFI)
     {
      m_BWMFI.Refresh(OBJ_ALL_PERIODS);
     }
   if(m_useGator)
     {
      m_Gator.Refresh(OBJ_ALL_PERIODS);
     }
   if(m_useAD)
     {
      m_AD.Refresh(OBJ_ALL_PERIODS);
     }
   if(m_useADX)
     {
      m_ADX.Refresh(OBJ_ALL_PERIODS);
     }
   if(m_useBands)
     {
      m_Bands.Refresh(OBJ_ALL_PERIODS);
     }
   if(m_useCCI)
     {
      m_CCI.Refresh(OBJ_ALL_PERIODS);
     }
   if(m_useMACD)
     {
      m_MACD.Refresh(OBJ_ALL_PERIODS);
     }
   if(m_useMFI)
     {
      m_MFI.Refresh(OBJ_ALL_PERIODS);
     }
   if(m_useOBV)
     {
      m_OBV.Refresh(OBJ_ALL_PERIODS);
     }
   if(m_useRSI)
     {
      m_RSI.Refresh(OBJ_ALL_PERIODS);
     }
   if(m_useRVI)
     {
      m_RVI.Refresh(OBJ_ALL_PERIODS);
     }
   if(m_useSTOCH)
     {
      m_STOCH.Refresh(OBJ_ALL_PERIODS);
     }
   if(m_useSAR)
     {
      m_SAR.Refresh(OBJ_ALL_PERIODS);
     }
   if(m_useWPR)
     {
      m_WPR.Refresh(OBJ_ALL_PERIODS);
     }
   return true;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool CExpertSignalAIBase::BufferTempData(int idx)
  {
   double open = m_Open.GetData(idx);
   double close = m_Close.GetData(idx);
   double high = m_High.GetData(idx);
   double low = m_Low.GetData(idx);
   MqlDateTime sTime;
   TimeToStruct(m_Time.GetData(idx), sTime);
   if(open == EMPTY_VALUE)
      return false;
   if(!TempData.Add(close - open) ||
      !TempData.Add(high - open) ||
      !TempData.Add(low - open))
     {
      return false;
     }
   if(m_useVolumes)
     {
      if(!TempData.Add(m_Volumes.Main(idx) - m_Volumes.Main(idx + 1)))
         return false;
     }
   if(m_useTime)
     {
      // Normalize time (cyclical encoding)
      if(!TempData.Add(sin(2 * M_PI * sTime.hour / 24.0)))
         return false;
      if(!TempData.Add(cos(2 * M_PI * sTime.hour / 24.0)))
         return false;
      if(!TempData.Add(sin(2 * M_PI * sTime.day_of_week / 7.0)))
         return false;
      if(!TempData.Add(cos(2 * M_PI * sTime.day_of_week / 7.0)))
         return false;
      if(!TempData.Add(sin(2 * M_PI * sTime.mon / 12.0)))
         return false;
      if(!TempData.Add(cos(2 * M_PI * sTime.mon / 12.0)))
         return false;
     }
   if(m_useATR)
     {
      if(!TempData.Add(m_ATR.Main(idx)))
         return false;
     }
   if(m_useAC)
     {
      if(!TempData.Add(m_AC.Main(idx)))
         return false;
     }
   if(m_useAlligator)
     {
      if(!TempData.Add(m_Alligator.Jaw(idx) - open)
         ||
         (!TempData.Add(m_Alligator.Teeth(idx) - open))
         ||
         (!TempData.Add(m_Alligator.Lips(idx) - open))
         ||
         (!TempData.Add(m_Alligator.Jaw(idx) - close))
         ||
         (!TempData.Add(m_Alligator.Teeth(idx) - close))
         ||
         (!TempData.Add(m_Alligator.Lips(idx) - close))
         ||
         (!TempData.Add(m_Alligator.Jaw(idx) - high))
         ||
         (!TempData.Add(m_Alligator.Teeth(idx) - high))
         ||
         (!TempData.Add(m_Alligator.Lips(idx) - high))
         ||
         (!TempData.Add(m_Alligator.Jaw(idx) - low))
         ||
         (!TempData.Add(m_Alligator.Teeth(idx) - low))
         ||
         (!TempData.Add(m_Alligator.Lips(idx) - low)))
         return false;
     }
   if(m_useAO)
     {
      if(!TempData.Add(m_AO.Main(idx)))
         return false;
     }
   if(m_useBWMFI)
     {
      if(!TempData.Add(m_BWMFI.Main(idx)))
         return false;
     }
   if(m_useGator)
     {
      if(!TempData.Add(m_Gator.Upper(idx) - open) ||
         (!TempData.Add(m_Gator.Lower(idx) - open)) ||
         (!TempData.Add(m_Gator.Upper(idx) - close)) ||
         (!TempData.Add(m_Gator.Lower(idx) - close)) ||
         (!TempData.Add(m_Gator.Upper(idx) - high)) ||
         (!TempData.Add(m_Gator.Lower(idx) - high)) ||
         (!TempData.Add(m_Gator.Upper(idx) - low)) ||
         (!TempData.Add(m_Gator.Lower(idx) - low)))
         return false;
     }
   if(m_useAD)
     {
      if(!TempData.Add(m_AD.Main(idx) - m_AD.Main(idx + 1)))
         return false;
     }
   if(m_useADX)
     {
      if(!TempData.Add(m_ADX.Main(idx)) || !TempData.Add(m_ADX.Plus(idx)) || !TempData.Add(m_ADX.Minus(idx)))
         return false;
     }
   if(m_useBands)
     {
      if(!TempData.Add(m_Bands.Upper(idx) - open) ||
         (!TempData.Add(m_Bands.Base(idx) - open)) ||
         (!TempData.Add(m_Bands.Lower(idx) - open)) ||
         (!TempData.Add(m_Bands.Upper(idx) - close)) ||
         (!TempData.Add(m_Bands.Base(idx) - close)) ||
         (!TempData.Add(m_Bands.Lower(idx) - close)) ||
         (!TempData.Add(m_Bands.Upper(idx) - high)) ||
         (!TempData.Add(m_Bands.Base(idx) - high)) ||
         (!TempData.Add(m_Bands.Lower(idx) - high)) ||
         (!TempData.Add(m_Bands.Upper(idx) - low)) ||
         (!TempData.Add(m_Bands.Base(idx) - low)) ||
         (!TempData.Add(m_Bands.Lower(idx) - low)))
         return false;
     }
   if(m_useCCI)
     {
      if(!TempData.Add(m_CCI.Main(idx)))
         return false;
     }
   if(m_useMACD)
     {
      if(!TempData.Add(m_MACD.Main(idx)) || !TempData.Add(m_MACD.Signal(idx)))
         return false;
     }
   if(m_useMFI)
     {
      if(!TempData.Add(m_MFI.Main(idx)))
         return false;
     }
   if(m_useOBV)
     {
      if(!TempData.Add(m_OBV.Main(idx) - m_OBV.Main(idx + 1)))
         return false;
     }
   if(m_useRSI)
     {
      if(!TempData.Add(m_RSI.Main(idx)))
         return false;
     }
   if(m_useRVI)
     {
      if(!TempData.Add(m_RVI.Main(idx)) || !TempData.Add(m_RVI.Signal(idx)))
         return false;
     }
   if(m_useSTOCH)
     {
      if(!TempData.Add(m_STOCH.Main(idx)) || !TempData.Add(m_STOCH.Signal(idx)))
         return false;
     }
   if(m_useSAR)
     {
      if(!TempData.Add(m_SAR.Main(idx) - open) ||
         (!TempData.Add(m_SAR.Main(idx) - close)) ||
         (!TempData.Add(m_SAR.Main(idx) - high)) ||
         (!TempData.Add(m_SAR.Main(idx) - low)))
         return false;
     }
   if(m_useWPR)
     {
      if(!TempData.Add(m_WPR.Main(idx)))
         return false;
     }
   return true;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool CExpertSignalAIBase::SaveTopologyConfiguration(string fileName, int initialNeuronsCount, int hiddenLayersCount, double neuronsReduction, int minNeuronsCount, int optimizationAlgo, int historyBars, int outputNeuronsCount, int neuronsCount, int studyPeriod, int minTrainYear, bool isInitialized, int stopTrainWR, int fractalPeriods)
  {
   string configFileName = fileName + ".cfg";
   int handle = FileOpen(configFileName, FILE_WRITE | FILE_BIN | FILE_COMMON);
   if(handle == INVALID_HANDLE)
     {
      Print("Error: Unable to open file ", configFileName);
      ResetLastError();
      return false;
     }
   if(FileWriteInteger(handle, initialNeuronsCount) < sizeof(int))
     {
      Print("Error writing initialNeuronsCount : Error code: ", GetLastError());
      ResetLastError();
      return false;
     }
   if(FileWriteInteger(handle, hiddenLayersCount) < sizeof(int))
     {
      Print("Error writing hiddenLayersCount : Error code: ", GetLastError());
      ResetLastError();
      return false;
     }
   if(FileWriteDouble(handle, neuronsReduction) < sizeof(double))
     {
      Print("Error writing neuronsReduction : Error code: ", GetLastError());
      ResetLastError();
      return false;
     }
   if(FileWriteInteger(handle, minNeuronsCount) < sizeof(int))
     {
      Print("Error writing minNeuronsCount : Error code: ", GetLastError());
      ResetLastError();
      return false;
     }
   if(FileWriteInteger(handle, optimizationAlgo) < sizeof(int))
     {
      Print("Error writing optimizationAlgo : Error code: ", GetLastError());
      ResetLastError();
      return false;
     }
   if(FileWriteInteger(handle, historyBars) < sizeof(int))
     {
      Print("Error writing historyBars : Error code: ", GetLastError());
      ResetLastError();
      return false;
     }
   if(FileWriteInteger(handle, outputNeuronsCount) < sizeof(int))
     {
      Print("Error writing outputNeuronsCount : Error code: ", GetLastError());
      ResetLastError();
      return false;
     }
   if(FileWriteInteger(handle, neuronsCount) < sizeof(int))
     {
      Print("Error writing neuronsCount : Error code: ", GetLastError());
      ResetLastError();
      return false;
     }
   if(FileWriteInteger(handle, studyPeriod) < sizeof(int))
     {
      Print("Error writing studyPeriod : Error code: ", GetLastError());
      ResetLastError();
      return false;
     }
   if(FileWriteInteger(handle, minTrainYear) < sizeof(int))
     {
      Print("Error writing minTrainYear : Error code: ", GetLastError());
      ResetLastError();
      return false;
     }
   if(FileWriteInteger(handle, isInitialized) < sizeof(int))
     {
      Print("Error writing isInitialized : Error code: ", GetLastError());
      ResetLastError();
      return false;
     }
   if(FileWriteInteger(handle, stopTrainWR) < sizeof(int))
     {
      Print("Error writing stopTrainWR : Error code: ", GetLastError());
      ResetLastError();
      return false;
     }
   if(FileWriteInteger(handle, fractalPeriods) < sizeof(int))
     {
      Print("Error writing fractalPeriods : Error code: ", GetLastError());
      ResetLastError();
      return false;
     }
   FileClose(handle);
   return true;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool CExpertSignalAIBase::LoadAndCompareTopologyConfiguration(string fileName, int initialNeuronsCount, int hiddenLayersCount, double neuronsReduction, int minNeuronsCount, int optimizationAlgo, int historyBars, int outputNeuronsCount, int neuronsCount, int studyPeriod, int minTrainYear, bool isInitialized, int stopTrainWR, int fractalPeriods)
  {
   string configFileName = fileName + ".cfg";
   if(!FileIsExist(configFileName, FILE_COMMON))
     {
      Print("Error: File ", configFileName, " does not exist");
      return false;
     }
   int handle = FileOpen(configFileName, FILE_READ | FILE_BIN | FILE_COMMON);
   if(handle == INVALID_HANDLE)
     {
      Print("Error: Unable to open file ", configFileName);
      return false;
     }
   int savedInitialNeurons = FileReadInteger(handle);
   int savedHiddenLayers = FileReadInteger(handle);
   double savedReductionFactor = FileReadDouble(handle);
   int savedMinNeurons = FileReadInteger(handle);
   int savedOptimizationAlgo = FileReadInteger(handle);
   int savedHistoryBars = FileReadInteger(handle);
   int savedOutputNeuronsCount = FileReadInteger(handle);
   int savedNeuronsCount = FileReadInteger(handle);
   int savedStudyPeriod = FileReadInteger(handle);
   int savedMinTrainYear = FileReadInteger(handle);
   bool savedIsInitialized = FileReadInteger(handle);
   int savedStopTrainWR = FileReadInteger(handle);
   int savedFractalPeriods = FileReadInteger(handle);
   FileClose(handle);
   if(savedInitialNeurons != initialNeuronsCount ||
      savedHiddenLayers != hiddenLayersCount ||
      savedReductionFactor != neuronsReduction ||
      savedMinNeurons != minNeuronsCount ||
      savedOptimizationAlgo != optimizationAlgo ||
      savedHistoryBars != historyBars ||
      savedOutputNeuronsCount != outputNeuronsCount ||
      savedNeuronsCount != neuronsCount ||
      savedStudyPeriod != studyPeriod ||
      savedMinTrainYear != minTrainYear ||
      savedIsInitialized != isInitialized ||
      savedStopTrainWR != stopTrainWR ||
      savedFractalPeriods != fractalPeriods)
     {
      Print("Error: Configuration mismatch. Deleting file ", configFileName);
      FileDelete(configFileName, FILE_COMMON);
      return false;
     }
   return true;
  }
//+------------------------------------------------------------------+
//| PurgeChart - Removes all visual objects from the current chart   |
//+------------------------------------------------------------------+
void CExpertSignalAIBase::PurgeChart(void)
  {
// Specify the current chart ID (0 for the current chart)
   long chartID = 0;
// Remove all objects of any type (use specific type if needed)
   ObjectsDeleteAll(chartID);
  }
//+------------------------------------------------------------------+
//| Initialize Open indicators.                                      |
//+------------------------------------------------------------------+
bool CExpertSignalAIBase::InitOpen(CIndicators * indicators)
  {
//--- check pointer
   if(indicators == NULL)
      return (false);
//--- add object to collection
   if(!indicators.Add(GetPointer(m_Open)))
     {
      printf(__FUNCTION__ + ": error adding object");
      return (false);
     }
//--- initialize object
   if(!m_Open.Create(m_symbol.Name(), m_period))
     {
      printf(__FUNCTION__ + ": error initializing object");
      return (false);
     }
//--- ok
   return (true);
  }
//+------------------------------------------------------------------+
//| Initialize Close indicators.                                     |
//+------------------------------------------------------------------+
bool CExpertSignalAIBase::InitClose(CIndicators * indicators)
  {
//--- check pointer
   if(indicators == NULL)
      return (false);
//--- add object to collection
   if(!indicators.Add(GetPointer(m_Close)))
     {
      printf(__FUNCTION__ + ": error adding object");
      return (false);
     }
//--- initialize object
   if(!m_Close.Create(m_symbol.Name(), m_period))
     {
      printf(__FUNCTION__ + ": error initializing object");
      return (false);
     }
//--- ok
   return (true);
  }
//+------------------------------------------------------------------+
//| Initialize High indicators.                                      |
//+------------------------------------------------------------------+
bool CExpertSignalAIBase::InitHigh(CIndicators * indicators)
  {
//--- check pointer
   if(indicators == NULL)
      return (false);
//--- add object to collection
   if(!indicators.Add(GetPointer(m_High)))
     {
      printf(__FUNCTION__ + ": error adding object");
      return (false);
     }
//--- initialize object
   if(!m_High.Create(m_symbol.Name(), m_period))
     {
      printf(__FUNCTION__ + ": error initializing object");
      return (false);
     }
//--- ok
   return (true);
  }
//+------------------------------------------------------------------+
//| Initialize Low indicators.                                       |
//+------------------------------------------------------------------+
bool CExpertSignalAIBase::InitLow(CIndicators * indicators)
  {
//--- check pointer
   if(indicators == NULL)
      return (false);
//--- add object to collection
   if(!indicators.Add(GetPointer(m_Low)))
     {
      printf(__FUNCTION__ + ": error adding object");
      return (false);
     }
//--- initialize object
   if(!m_Low.Create(m_symbol.Name(), m_period))
     {
      printf(__FUNCTION__ + ": error initializing object");
      return (false);
     }
//--- ok
   return (true);
  }
//+------------------------------------------------------------------+
//| Initialize Time indicators.                                      |
//+------------------------------------------------------------------+
bool CExpertSignalAIBase::InitTime(CIndicators * indicators)
  {
//--- check pointer
   if(indicators == NULL)
      return (false);
//--- add object to collection
   if(!indicators.Add(GetPointer(m_Time)))
     {
      printf(__FUNCTION__ + ": error adding object");
      return (false);
     }
//--- initialize object
   if(!m_Time.Create(m_symbol.Name(), m_period))
     {
      printf(__FUNCTION__ + ": error initializing object");
      return (false);
     }
//--- ok
   return (true);
  }
//+------------------------------------------------------------------+
//| Initialize Volumes indicators.                                   |
//+------------------------------------------------------------------+
bool CExpertSignalAIBase::InitVolumes(CIndicators * indicators)
  {
//--- check pointer
   if(indicators == NULL)
      return (false);
//--- add object to collection
   if(!indicators.Add(GetPointer(m_Volumes)))
     {
      printf(__FUNCTION__ + ": error adding object");
      return (false);
     }
//--- initialize object
   if(!m_Volumes.Create(m_symbol.Name(), m_period, VolumeData))
     {
      printf(__FUNCTION__ + ": error initializing object");
      return (false);
     }
//--- ok
   return (true);
  }
//+------------------------------------------------------------------+
//| Initialize AC indicators.                                        |
//+------------------------------------------------------------------+
bool CExpertSignalAIBase::InitAC(CIndicators * indicators)
  {
//--- check pointer
   if(indicators == NULL)
      return (false);
//--- add object to collection
   if(!indicators.Add(GetPointer(m_AC)))
     {
      printf(__FUNCTION__ + ": error adding object");
      return (false);
     }
//--- initialize object
   if(!m_AC.Create(m_symbol.Name(), m_period))
     {
      printf(__FUNCTION__ + ": error initializing object");
      return (false);
     }
//--- ok
   return (true);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool CExpertSignalAIBase::InitAlligator(CIndicators * indicators)
  {
//--- check pointer
   if(indicators == NULL)
      return (false);
   int idx = StartIndex();
//--- add object to collection
   if(!indicators.Add(GetPointer(m_Alligator)))
     {
      printf(__FUNCTION__ + ": error adding object");
      return (false);
     }
//--- initialize object
   if(!m_Alligator.Create(m_symbol.Name(), m_period, 13, idx, 8, idx, 5, idx, MODE_SMMA, PRICE_MEDIAN))
     {
      printf(__FUNCTION__ + ": error initializing object");
      return (false);
     }
//--- ok
   return (true);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool CExpertSignalAIBase::InitAO(CIndicators * indicators)
  {
//--- check pointer
   if(indicators == NULL)
      return (false);
//--- add object to collection
   if(!indicators.Add(GetPointer(m_AO)))
     {
      printf(__FUNCTION__ + ": error adding object");
      return (false);
     }
//--- initialize object
   if(!m_AO.Create(m_symbol.Name(), m_period))
     {
      printf(__FUNCTION__ + ": error initializing object");
      return (false);
     }
//--- ok
   return (true);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool CExpertSignalAIBase::InitBWMFI(CIndicators * indicators)
  {
//--- check pointer
   if(indicators == NULL)
      return (false);
//--- add object to collection
   if(!indicators.Add(GetPointer(m_BWMFI)))
     {
      printf(__FUNCTION__ + ": error adding object");
      return (false);
     }
//--- initialize object
   if(!m_BWMFI.Create(m_symbol.Name(), m_period, VolumeData))
     {
      printf(__FUNCTION__ + ": error initializing object");
      return (false);
     }
//--- ok
   return (true);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool CExpertSignalAIBase::InitGator(CIndicators * indicators)
  {
//--- check pointer
   if(indicators == NULL)
      return (false);
   int idx = StartIndex();
//--- add object to collection
   if(!indicators.Add(GetPointer(m_Gator)))
     {
      printf(__FUNCTION__ + ": error adding object");
      return (false);
     }
//--- initialize object
   if(!m_Gator.Create(m_symbol.Name(), m_period, 13, idx, 8, idx, 5, idx, MODE_SMMA, PRICE_MEDIAN))
     {
      printf(__FUNCTION__ + ": error initializing object");
      return (false);
     }
//--- ok
   return (true);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool CExpertSignalAIBase::InitAD(CIndicators * indicators)
  {
//--- check pointer
   if(indicators == NULL)
      return (false);
//--- add object to collection
   if(!indicators.Add(GetPointer(m_AD)))
     {
      printf(__FUNCTION__ + ": error adding object");
      return (false);
     }
//--- initialize object
   if(!m_AD.Create(m_symbol.Name(), m_period, VolumeData))
     {
      printf(__FUNCTION__ + ": error initializing object");
      return (false);
     }
//--- ok
   return (true);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool CExpertSignalAIBase::InitADX(CIndicators * indicators)
  {
//--- check pointer
   if(indicators == NULL)
      return (false);
//--- add object to collection
   if(!indicators.Add(GetPointer(m_ADX)))
     {
      printf(__FUNCTION__ + ": error adding object");
      return (false);
     }
//--- initialize object
   if(!m_ADX.Create(m_symbol.Name(), m_period, 14))
     {
      printf(__FUNCTION__ + ": error initializing object");
      return (false);
     }
//--- ok
   return (true);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool CExpertSignalAIBase::InitBands(CIndicators * indicators)
  {
   int idx = StartIndex();
//--- check pointer
   if(indicators == NULL)
      return (false);
//--- add object to collection
   if(!indicators.Add(GetPointer(m_Bands)))
     {
      printf(__FUNCTION__ + ": error adding object");
      return (false);
     }
//--- initialize object
   if(!m_Bands.Create(m_symbol.Name(), m_period, 20, idx, 2.0, PRICE_CLOSE))
     {
      printf(__FUNCTION__ + ": error initializing object");
      return (false);
     }
//--- ok
   return (true);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool CExpertSignalAIBase::InitCCI(CIndicators * indicators)
  {
//--- check pointer
   if(indicators == NULL)
      return (false);
//--- add object to collection
   if(!indicators.Add(GetPointer(m_CCI)))
     {
      printf(__FUNCTION__ + ": error adding object");
      return (false);
     }
//--- initialize object
   if(!m_CCI.Create(m_symbol.Name(), m_period, 14, PRICE_TYPICAL))
     {
      printf(__FUNCTION__ + ": error initializing object");
      return (false);
     }
//--- ok
   return (true);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool CExpertSignalAIBase::InitMACD(CIndicators * indicators)
  {
//--- check pointer
   if(indicators == NULL)
      return (false);
//--- add object to collection
   if(!indicators.Add(GetPointer(m_MACD)))
     {
      printf(__FUNCTION__ + ": error adding object");
      return (false);
     }
//--- initialize object
   if(!m_MACD.Create(m_symbol.Name(), m_period, 12, 26, 9, PRICE_CLOSE))
     {
      printf(__FUNCTION__ + ": error initializing object");
      return (false);
     }
//--- ok
   return (true);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool CExpertSignalAIBase::InitMFI(CIndicators * indicators)
  {
//--- check pointer
   if(indicators == NULL)
      return (false);
//--- add object to collection
   if(!indicators.Add(GetPointer(m_MFI)))
     {
      printf(__FUNCTION__ + ": error adding object");
      return (false);
     }
//--- initialize object
   if(!m_MFI.Create(m_symbol.Name(), m_period, 14, VolumeData))
     {
      printf(__FUNCTION__ + ": error initializing object");
      return (false);
     }
//--- ok
   return (true);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool CExpertSignalAIBase::InitOBV(CIndicators * indicators)
  {
//--- check pointer
   if(indicators == NULL)
      return (false);
//--- add object to collection
   if(!indicators.Add(GetPointer(m_OBV)))
     {
      printf(__FUNCTION__ + ": error adding object");
      return (false);
     }
//--- initialize object
   if(!m_OBV.Create(m_symbol.Name(), m_period, VolumeData))
     {
      printf(__FUNCTION__ + ": error initializing object");
      return (false);
     }
//--- ok
   return (true);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool CExpertSignalAIBase::InitRSI(CIndicators * indicators)
  {
//--- check pointer
   if(indicators == NULL)
      return (false);
//--- add object to collection
   if(!indicators.Add(GetPointer(m_RSI)))
     {
      printf(__FUNCTION__ + ": error adding object");
      return (false);
     }
//--- initialize object
   if(!m_RSI.Create(m_symbol.Name(), m_period, 14, PRICE_CLOSE))
     {
      printf(__FUNCTION__ + ": error initializing object");
      return (false);
     }
//--- ok
   return (true);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool CExpertSignalAIBase::InitRVI(CIndicators * indicators)
  {
//--- check pointer
   if(indicators == NULL)
      return (false);
//--- add object to collection
   if(!indicators.Add(GetPointer(m_RVI)))
     {
      printf(__FUNCTION__ + ": error adding object");
      return (false);
     }
//--- initialize object
   if(!m_RVI.Create(m_symbol.Name(), m_period, 10))
     {
      printf(__FUNCTION__ + ": error initializing object");
      return (false);
     }
//--- ok
   return (true);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool CExpertSignalAIBase::InitSTOCH(CIndicators * indicators)
  {
//--- check pointer
   if(indicators == NULL)
      return (false);
//--- add object to collection
   if(!indicators.Add(GetPointer(m_STOCH)))
     {
      printf(__FUNCTION__ + ": error adding object");
      return (false);
     }
//--- initialize object
   if(!m_STOCH.Create(m_symbol.Name(), m_period, 5, 3, 3, MODE_SMA, STO_LOWHIGH))
     {
      printf(__FUNCTION__ + ": error initializing object");
      return (false);
     }
//--- ok
   return (true);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool CExpertSignalAIBase::InitSAR(CIndicators * indicators)
  {
//--- check pointer
   if(indicators == NULL)
      return (false);
//--- add object to collection
   if(!indicators.Add(GetPointer(m_SAR)))
     {
      printf(__FUNCTION__ + ": error adding object");
      return (false);
     }
//--- initialize object
   if(!m_SAR.Create(m_symbol.Name(), m_period, 0.02, 0.2))
     {
      printf(__FUNCTION__ + ": error initializing object");
      return (false);
     }
//--- ok
   return (true);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool CExpertSignalAIBase::InitWPR(CIndicators * indicators)
  {
//--- check pointer
   if(indicators == NULL)
      return (false);
//--- add object to collection
   if(!indicators.Add(GetPointer(m_WPR)))
     {
      printf(__FUNCTION__ + ": error adding object");
      return (false);
     }
//--- initialize object
   if(!m_WPR.Create(m_symbol.Name(), m_period, 14))
     {
      printf(__FUNCTION__ + ": error initializing object");
      return (false);
     }
//--- ok
   return (true);
  }
//+------------------------------------------------------------------+