^L_Correlation_v2

//+------------------------------------------------------------------+
//|                                               ^L_Correlation.mq4 |
//|                                        Copyright © 2008, lotos4u |
//|                                                lotos4u@gmail.com |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2008, lotos4u"
#property link      "lotos4u@gmail.com"

//+------------------------------------------------------------------+
//| defines                                                          |
//+------------------------------------------------------------------+
#define CLOSE_MODE 0 //öåíà çàêðûòèÿ áàðà
#define CLOSEOPEN_MODE 1 //ðàçíèöà ìåæäó öåíîé çàêðûòèÿ è îòêðûòèÿ áàðà
#define CLOSE_RELATIVE_MODE 2 //îòíîøåíèå öåíû çàêðûòèÿ ê ìàêñèìàëüíîé öåíå áàðà
#define CLOSEOPEN_RELATIVE_MODE 3 //îòíîøåíèå ðàçíèöû öåí çàêðûòèÿ è îòêðûòèÿ ê ìàêñèìàëüíîé öåíå áàðà
#define FULL_AVG_MODE 4 //ñðåäíåå çíà÷åíèå áàðà (ñóììà íà 4)
#define FULL_AVG_RELATIVE_MODE 5 //ñðåäíåå çíà÷åíèå áàðà, äåëåííîå íà ìàêñèìàëüíîå

#define HIGHLOW_MODE 6 //ðàçíèöà ìåæäó ìàêñèìàëüíîé è ìèíèìàëüíîé öåíîé áàðà
#define HIGHLOW_AVG_MODE 7 //ñðåäíåå çíà÷åíèå áàðà ïî ìàêñ. è ìèí. öåíàì
#define HIGHLOW_RELATIVE_MODE 8 //îòíîøåíèå ðàçíèöû ìåæäó ìàêñ. è ìèí. öåíîé áàðà ê ìàêñ. öåíå
#define HIGHLOW_AVG_RELATIVE_MODE 9 //îòíîøåíèå ñðåäíåãî çíà÷åíèÿ áàðà (ïî ìàêñ. è ìèí. öåíàì) ê ìàêñ. öåíå áàðà


#property indicator_separate_window

#property indicator_minimum -1
#property indicator_maximum 1

#property indicator_buffers 3

#property indicator_color1 Aqua //Êîýôôèöèåíò êîððåëÿöèè
#property indicator_color2 Blue //Ñêîëüçÿùåå ñðåäíåå îò êîýô. êîððåëÿöèè
#property indicator_color3 Red //Ñóùåñòâåííûé òî÷êè êîýôôèöèåíòà êîððåëÿöèè

#property indicator_width1 1 //Òîëùèíà ëèíèè êîý. êîððåëÿöèè
#property indicator_width2 2 //Òîëùèíà ëèíèè ñêîëüçÿùåé ñðåäíåé
#property indicator_width3 1 //Ðàçìåð ñóùåñòâåííûõ òî÷åê

#property indicator_level1 0.75
#property indicator_level2 0.5
#property indicator_level3 0.0
#property indicator_level4 -0.5
#property indicator_level5 -0.75
#property indicator_levelcolor BlueViolet

#include <stderror.mqh>
#include <stdlib.mqh>

extern int      Mode = FULL_AVG_MODE;                     //Ïàðàìåòð îïðåäåëÿåò, ÷òî èìåííî êîððåëèðóåì
extern bool     AutoCorrelation = false;                  //Åñëè ÈÑÒÈÍÀ, òî ïàðàìåòð Pair èãíîðèðóåòñÿ è âû÷èñëÿåòñÿ àâòîêîððåëÿöèÿ ñî ñäâèãîì AutoCorrelationShift
extern string   Pair = "GBPUSD";                          //Ñèìâîëè÷åñêîå èìÿ èíñòðóìåíòà, êîððåëÿöèÿ ñ êîòîðûì èíòåðåñóåò

extern bool     ShowCorrelation = false;                   //Åñëè ÈÑÒÈÍÀ, òî êðèâàÿ êîýôôèöèåíòà êîððåëÿöèè îòîáðàæàåòñÿ
extern bool     ShowMA = false;                           //Åñëè ÈÑÒÈÍÀ, òî êðèâàÿ ñêîëüçÿùåé ñðåäíåé îòîáðàæàåòñÿ
extern bool     ShowHistogram = true;                     //Åñëè ÈÑÒÈÍÀ, òî ãèñòîãðàììà çíà÷åíèé êîýôôèöèåíòà êîððåëÿöèè îòîáðàæàåòñÿ
extern bool     ShowSummary = true;                       //Åñëè ÈÑÒÈÍÀ, òî èòîãîâàÿ íàäïèñü îòîáðàæàåòñÿ

extern int      ShowEssentialPoints = -1;                  //Êîëè÷åñòâî ñóùåñòâåííûõ òî÷åê äëÿ îòîáðàæåíèÿ. Åñëè =0, òî îòîáðàæàþòñÿ âñå òî÷êè, åñëè =-1, òî íå îòîáðàæàþòñÿ
extern int      ShowEssentialRanges = -1;                  //Êîëè÷åñòâî ãðàíèö ñóùåñòâåííûõ èíòåðâàëîâ (âåðòèêàëüíûå ëèíèè) äëÿ îòîáðàæåíèÿ. Åñëè =0, òî îòîáðàæàþòñÿ ãðàíèöû, åñëè =-1, òî íå îòîáðàæàþòñÿ
extern int      ShowEssentialRectangles = -1;              //Êîëè÷åñòâî ñóùåñòâåííûõ îáëàñòåé (ïðÿìîóãîëüíèêè íà ÷àðòå) äëÿ îòîáðàæåíèÿ. Åñëè =0, òî îòîáðàæàþòñÿ âñå îáëàñòè, åñëè =-1, òî íå îòîáðàæàþòñÿ

extern int      CorrelationRadius = 0;                    //Êîëè÷åñòâî áàðîâ, íà êîòîðûõ èùåòñÿ ñîîòâåòñòâèå äâóõ ñèãíàëîâ
extern int      MA_Period = 10;                           //Ïåðèîä ñêîëüçÿùåé ñðåäíåé
extern int      ResultingBars = 0;                        //Êîëè÷åñòâî áàðîâ, ïî êîòîðûì îïðåäåëÿåòñÿ èòîãîâîå ñðåäíåå çíà÷åíèå êîýôôèöèåíòà êîððåëÿöèè
extern int      AutoCorrelationShift = 0;                 // ðåæèìå àâòîêîððåëÿöèè ïàðàìåòð îïðåäåëÿåò êîëè÷åñòâî áàðîâ, íà êîòîðîå ñìåùàåì îðèãèíàëüíûé ñèíãàë (â ðåæèìå êîððåëÿöèè èãíîðèðóåòñÿ)
extern double   EssentialLevel = 0.7;                     //Ñóùåñòâåííûé óðîâåíü, ò.å. ýêñòðåìàëüíûå çíà÷åíèÿ êîýô.êîððåëÿöèè âûøå íåãî áóäóò ñ÷èòàòüñÿ ñóùåñòâåííûìè òî÷êàìè

extern string   FontName = "Verdana";                     //Èìÿ øðèôòà, êîòîðûì âûâîäèòñÿ èòîãîâàÿ ïîäïèñü â îêíå
extern int      FontSize = 9;                            //Ðàçìåð øðèôòà

extern color    FontColor = White;                        //Öâåò øðèôòà
extern color    CorrelationColor = indicator_color1;      //Öâåò êðèâîé êîýô. êîððåëÿöèè
extern color    MAColor = indicator_color2;               //Öâåò êðèâîé ñêîëüçÿùåé ñðåäíåé
extern color    HistoColor = Orange;                      //Öâåò ãèñòîãðàììû çíà÷åíèé êîýô. êîððåëÿöèè
extern color    EssentialPointsColor = indicator_color3;  //Öâåò ñóùåñòâåííûõ òî÷åê
extern color    EssentialRangesColor = Red;               //Öâåò ãðàíèö ñóùåñòâåííûõ îáëàñòåé
extern color    EssentialRectanglesColor = Olive;         //Öâåò ïðÿìîóãîëüíèêîâ ñóùåñòâåííûõ îáëàñòåé


double CorrelationBuffer[];
double AverageCorrelationBuffer[];
double EssentialPointsBuffer[];


double Correlation[], AvgCorrelation[], ArrayX[], ArrayY[], ValidX[], ValidY[];
double AverageX, AverageY, AverageXY, DispersionX, DispersionY, CovariationXY, HistogramMax = 0.0, AverageCorrelation;
int CalculateCounter, ValidDataCounter, AverageLength, ValidDataLength;
string ShortName = "L_Correlation", HistoName = " Histo ", SummaryLabel = " Label ";
int IndicatorWindow, HistogramBars = 200, HistogramValues[];





////////////////////////////////////////////////////////////////////////////////////////////
//Èíèöèàëèçàöèÿ èíäèêàòîðà
////////////////////////////////////////////////////////////////////////////////////////////
int init()
{
   //Åñëè ñèìâîë íå óêàçàí, òî êîððåëÿöèÿ áóäåò âû÷èñëÿòñÿ ñ ñàìèì ñèìâîëîì (ÍÎ ÝÒÎ ÍÅ Àâòîêîððåëÿöèÿ!)
   if(Pair == "")
      Pair = Symbol();

   //Àâòîìàòè÷åñêèé âûáîð ñäâèãà àâòîêîððåëÿöèè
   if(CorrelationRadius == 0)
   {
      switch(Period())
      {
         case PERIOD_M1: CorrelationRadius = 10; break;//10 min
         case PERIOD_M5: CorrelationRadius = 12; break;//hour
         case PERIOD_M15: CorrelationRadius = 12; break;//3 hours
         case PERIOD_M30: CorrelationRadius = 12; break;//6 hours
         case PERIOD_H1: CorrelationRadius = 12; break;//12 hours
         case PERIOD_H4: CorrelationRadius = 6; break;//week
         case PERIOD_D1: CorrelationRadius = 5; break;//month
         case PERIOD_W1: CorrelationRadius = 12; break;//year
         case PERIOD_MN1: CorrelationRadius = 6; break;//year
      }
   }
   
   //Àâòîìàòè÷åñêèé âûáîð ñäâèãà àâòîêîððåëÿöèè
   if(AutoCorrelation && AutoCorrelationShift == 0)
   {
      switch(Period())
      {
         case PERIOD_M1: AutoCorrelationShift = 60; break;//hour
         case PERIOD_M5: AutoCorrelationShift = 12; break;//hour
         case PERIOD_M15: AutoCorrelationShift = 96; break;//day
         case PERIOD_M30: AutoCorrelationShift = 48; break;//day
         case PERIOD_H1: AutoCorrelationShift = 120; break;//week
         case PERIOD_H4: AutoCorrelationShift = 30; break;//week
         case PERIOD_D1: AutoCorrelationShift = 22; break;//month
         case PERIOD_W1: AutoCorrelationShift = 52; break;//year
         case PERIOD_MN1: AutoCorrelationShift = 12; break;//year
      }
   }
      
   //Ôîðìèðóåì èìÿ îêíà â çàâèñèìîñòè îò òèïà è ïàðàìåòðîâ èíäèêàòîðà
   if(AutoCorrelation)
      ShortName = ShortName + " (" + Symbol() + " Auto, " + Mode + ", " + CorrelationRadius + ", " + AutoCorrelationShift + ", " + MA_Period + ")";
   else
      ShortName = ShortName + " (" + Symbol() + "-" + Pair + ", " + Mode + ", " + CorrelationRadius + ", " + MA_Period + ")";
   
   IndicatorShortName(ShortName);
   
   //Áóôåð ñ êîýôôèöèåíòîì êîððåëÿöèè
   SetIndexStyle(0, DRAW_LINE, EMPTY, EMPTY, CorrelationColor);
   SetIndexBuffer(0, CorrelationBuffer);
   SetIndexEmptyValue(0, 2.0);

   //Áóôåð ñî ñêîëüçÿùåé ñðåäíåé îò êîýô. êîððåëÿöèè
   SetIndexStyle(1, DRAW_LINE, EMPTY, EMPTY, MAColor);
   SetIndexBuffer(1, AverageCorrelationBuffer);
   SetIndexEmptyValue(1, 2.0);
   
   //Áóôåð ñ ñóùåñòâåííûìè òî÷êàìè
   SetIndexStyle(2, DRAW_ARROW, EMPTY, EMPTY, EssentialPointsColor);
   SetIndexArrow(2, 108);
   SetIndexBuffer(2, EssentialPointsBuffer);
   SetIndexEmptyValue(2, 2.0);
   
   CalculateCounter = 0;
   ValidDataCounter = 0;
   
   CreateSummaryLabels();
   
   return(0);
}
////////////////////////////////////////////////////////////////////////////////////////////




////////////////////////////////////////////////////////////////////////////////////////////
//Óäàëåíèå èíäèêàòîðà     
////////////////////////////////////////////////////////////////////////////////////////////
int deinit()
{
   CalculateCounter = 0;
   ValidDataCounter = 0;
   DeleteObjectsByPhrase(ShortName);
   return(0);
}
////////////////////////////////////////////////////////////////////////////////////////////





////////////////////////////////////////////////////////////////////////////////////////////
//
////////////////////////////////////////////////////////////////////////////////////////////
int start()
{
   CreateSummaryLabels();
    //Èíäèêàòîð ïåðåðèñîâûâàåòñÿ òîëüêî â íà÷àëå íîâîãî áàðà
   if(CalculateCounter > 0 && Volume[0] > 1)
   {
      return(0);
   }
   int error, essCounter, limit;
   string Name;
   IndicatorWindow = WindowFind(ShortName);

   if(AutoCorrelation)
      ValidDataLength = Bars;
   else
      ValidDataLength = MathMin(Bars, iBars(Pair, 0));

   CreateValidData();
   
   ArrayResize(Correlation, ValidDataLength);ArrayInitialize(Correlation, 0.0);ArraySetAsSeries(Correlation, true);
   ArrayResize(AvgCorrelation, ValidDataLength);ArrayInitialize(AvgCorrelation, 0.0);ArraySetAsSeries(AvgCorrelation, true);
   
   for(int i = 0; i < ValidDataLength; i++)
   {
      CreateDataArrays(i);
      Correlation[i]  = getCorrelation(ArrayX, ArrayY);
      
      if(ShowCorrelation)
         CorrelationBuffer[i] = Correlation[i];
   }
   
   //Ôîðìèðóåì ìàññèâ ñêîëüçÿùåé ñðåäíåé îò êîýô. êîððåëÿöèè
   for(i = 0; i < ValidDataLength; i++)
   {
      AvgCorrelation[i] = iMAOnArray(Correlation, 0, MA_Period, 0, MODE_SMA, i);
      if(ShowMA)//Åñëè òðåáóåòñÿ îòîáðàæåíèå - çàïèñûâàåì â áóôåð
         AverageCorrelationBuffer[i] = AvgCorrelation[i];
   }

   essCounter = 0;//Ñ÷åò÷èê ñóùåñòâåííûõ òî÷åê
   for(i = 0; i < ValidDataLength; i++)
   {
      if((MathAbs(Correlation[i]) > EssentialLevel) && ((MathAbs(Correlation[i]) > MathAbs(Correlation[i-1])) && (MathAbs(Correlation[i]) > MathAbs(Correlation[i+1]))))
      {
         essCounter++;//Åùå îäíà ñóùåñòâåííàÿ òî÷êà
         
         //Îòìåòêà äëÿ ñàìîé òî÷êè
         if((ShowEssentialPoints == 0) || (essCounter <= ShowEssentialPoints))
         {
            EssentialPointsBuffer[i] = Correlation[i];
         }

         //Ãðàíèöû ñóùåñòâåííûõ îáëàñòåé
         if(AutoCorrelation && (ShowEssentialRanges == 0) || (essCounter <= ShowEssentialRanges))
         {
            Name = ShortName + " VLine1 " + i;
            ObjectCreate(Name, OBJ_VLINE, 0, Time[i], Correlation[i]);
            ObjectSet(Name, OBJPROP_COLOR, EssentialRangesColor);

            Name = ShortName + " VLine2 " + i;
            ObjectCreate(Name, OBJ_VLINE, 0, Time[AutoCorrelationShift + i], Correlation[i]);
            ObjectSet(Name, OBJPROP_COLOR, EssentialRangesColor);
         }
         
         //Ïðÿìîóãîëüíèêè ñóùåñòâåííûõ îáëàñòåé
         if(AutoCorrelation && (ShowEssentialRectangles == 0) || (essCounter <= ShowEssentialRectangles))
         {
            Name = ShortName + " Rect1 " + i;
            ObjectCreate(Name, OBJ_RECTANGLE, 0, Time[CorrelationRadius + i], High[iHighest(Symbol(), 0, MODE_HIGH, CorrelationRadius, i)], Time[i], Low[iLowest(Symbol(), 0, MODE_LOW, CorrelationRadius, i)]);
            ObjectSet(Name, OBJPROP_COLOR, EssentialRectanglesColor);
            ObjectSet(Name, OBJPROP_BACK, true);

            Name = ShortName + " Rect2 " + i;
            ObjectCreate(Name, OBJ_RECTANGLE, 0, Time[CorrelationRadius + AutoCorrelationShift + i], High[iHighest(Symbol(), 0, MODE_HIGH, CorrelationRadius, AutoCorrelationShift+i)], Time[AutoCorrelationShift+i], Low[iLowest(Symbol(), 0, MODE_LOW, CorrelationRadius, AutoCorrelationShift+i)]);
            ObjectSet(Name, OBJPROP_COLOR, EssentialRectanglesColor);
            ObjectSet(Name, OBJPROP_BACK, true);
         }
      }
   }
   
   //Óòî÷íÿåì êîëè÷åñòâî áàðîâ, ïî êîòîðîìó ñ÷èòàòü ñðåäíèé êîýô. êîððåëÿöèè
   if(ResultingBars == 0)
      AverageLength = ValidDataCounter;
   else
      AverageLength = ResultingBars;
   
      
   //Ñðåäíèé êîýôôèöèåíò êîððåëÿöèè
   AverageCorrelation = iMAOnArray(Correlation, 0, AverageLength, 0, MODE_SMA, 0);
   
   
   //Îïðåäåëÿåì ìàññèâ, ïî êîòîðîìó áóäåò ñòðîèòüñÿ ãèñòîãðàììà çíà÷åíèé êîýôôèöèåíòà êîððåëÿöèè
   HistogramMax = 0.0;
   if(ValidDataLength > 0)
      CreateHistogramArray();
   
   
   //Ïîñòðîåíèå ãèñòîãðàììû çíà÷åíèé êîýôôèöèåíòà êîððåëÿöèè
   if(ShowHistogram && ValidDataLength > 0)
   {
      //Ñòèðàåì ñòàðóþ ãèñòîãðàììó
      DeleteObjectsByPhrase(ShortName + HistoName);
      double StartX, StartY, EndX, EndY;
      
      //Ñòðîèì ãèñòîãðàììó òðåíäîâûìè ëèíèÿìè
      for(i = -HistogramBars/2; i < HistogramBars/2; i++)
      {
         if(HistogramValues[i + HistogramBars/2] == 0)continue;
         
         Name = ShortName + HistoName + i;//Èìÿ îáúåêòà ñòîëáèêà ãèñòîãðàììû
         StartX  = Time[0];//Ãîðèçîíòàëüíàÿ êîîðäèíàòà íà÷àëà ñòîëáèêà
         StartY  = i*2.0/HistogramBars;//Âåðòèêàëüíàÿ êîîðäèíàòà íà÷àëà ñòîëáèêà
         EndX    = Time[0 + 1*HistogramValues[i + HistogramBars/2]];//Ãîðèçîíòàëüíàÿ êîîðäèíàòà êîíöà ñòîëáèêà
         EndY    = StartY;//Âåðòèêàëüíàÿ êîîðäèíàòà êîíöà ñòîëáèêà
         
         ObjectCreate(Name, OBJ_TREND, IndicatorWindow, StartX, StartY, EndX, EndY);
         ObjectSet(Name, OBJPROP_RAY, false);
         ObjectSet(Name, OBJPROP_BACK, true);
         ObjectSet(Name, OBJPROP_COLOR, HistoColor);
      }
   }
   
   //Âûâîä èòîãîâûõ ïîäïèñåé
   if(ShowSummary)
      ShowSummary(essCounter);
   
   CalculateCounter = MathMin(1, ValidDataLength);
   
   return(0);
}
////////////////////////////////////////////////////////////////////////////////////////////






////////////////////////////////////////////////////////////////////////////////////////////
//Ôîðìèðóåò ìàññèâ, ïî êîòîðîìó áóäåò ñòðîèòñÿ ãèñòîãðàììà çíà÷åíèé êîýôôèöèåíòà êîððåëÿöèè
//(Àíàëîã ôóíêöèè ðàñïðåäåëåíèÿ)
////////////////////////////////////////////////////////////////////////////////////////////
void CreateHistogramArray()
{
   double level, levelNext, Upper = 1.0, Lower = -1.0, step;
   int size = ArraySize(Correlation), maxValue = 0;
   ArrayResize(HistogramValues, HistogramBars);
   ArrayInitialize(HistogramValues, 0);
   // öèêëå îïðåäåëÿåì "âåñ" çíà÷åíèé ÊÊ
   //Âñåãî ðàññìàòðèââàåòñÿ HistogramBars çíà÷åíèé èç äèàïàçîíà îò -1 äî +1
   //Âåñîì çíà÷åíèÿ íàçûâàåì êîëè÷åñòâî çíà÷åíèé ÊÊ, êîòîðûå óêëàäûâàþòñÿ â çíà÷åíèå
   step = (Upper - Lower)/HistogramBars;//"òîëùèíà" ñòîëáèêà
   for(int j = 0; j < ArraySize(Correlation); j++)
   {
      for(int i = 0; i < HistogramBars; i++)   
      {
         level = (i-HistogramBars/2)*step;//Íèæíÿÿ ãðàíèöà ñòîëáèêà
         levelNext = (i-HistogramBars/2+1)*step;//Âåðõíÿÿ ãðàíèöà ñòîëáèêà
         if(Correlation[j] >= level && Correlation[j] < levelNext)//Åñëè çíà÷åíèå ÊÊ ïîïàäàåò ïî äèàïàçîí òåêóùåãî ñòîëáèêà
         {
            HistogramValues[i]++;//íàðàùèâàåì äëèíó ñòîëáèêà íà 1
            if(maxValue < HistogramValues[i])//Åñëè íàäî, òî óòî÷íÿåì çíà÷åíèå ìàêñèìóìà ãèñòîãðàììû
            {
               maxValue = HistogramValues[i];
               HistogramMax = level;
            }
            break;//Ïåðåõîäèì ñðàçó ê ñëåäóþùåìó çíà÷åíèþ ÊÊ
         }
      }
   }
}
////////////////////////////////////////////////////////////////////////////////////////////






////////////////////////////////////////////////////////////////////////////////////////////
//Âûâîä èòîãîâîé íàäïèñè âíèçó îêíà
////////////////////////////////////////////////////////////////////////////////////////////
void ShowSummary(int essCounter)
{
   string Text1, Text2;
   if(AutoCorrelation)
      Text2 = "Àâòîêîððåëÿöèÿ";
   else
      //Ñðåäíåå çíà÷åíèå ÊÊ ïî óêàçàííîìó ÷èñëó áàðîâ
      Text2 = "Ñðåäíåå: Ìàêñ. ãèñòîãðàììû/MA = " + DoubleToStr(HistogramMax, 2) + "/" + DoubleToStr(AverageCorrelation, 2) + " (" + AverageLength + " èç " + ValidDataLength + " áàð)";
      
   //Êîëè÷åñòâî ñóùåñòâåííûõ çíà÷åíèé ÊÀÊ
   Text1 = "Ñóùåñòâåííûõ òî÷åê (>" + DoubleToStr(EssentialLevel, 2) + "): " + essCounter;
   ObjectSetText(ShortName + SummaryLabel + "1", Text1, FontSize, FontName, FontColor);
   ObjectSetText(ShortName + SummaryLabel + "2", Text2, FontSize, FontName, FontColor);
}
////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////
//Âîçâðàùàåò çíà÷åíèå ïåðâîé ñëó÷àéíîé ôóíêöèè
////////////////////////////////////////////////////////////////////////////////////////////
double getX(int shift)
{
   return(getSymbol(Symbol(), shift, Mode));
}
////////////////////////////////////////////////////////////////////////////////////////////





////////////////////////////////////////////////////////////////////////////////////////////
//Âîçâðàùàåò çíà÷åíèå âòîðîé ñëó÷àéíîé ôóíêöèè
////////////////////////////////////////////////////////////////////////////////////////////
double getY(int shift)
{
   if(AutoCorrelation)
      return(getSymbol(Symbol(), AutoCorrelationShift + shift, Mode));
   else
      return(getSymbol(Pair, shift, Mode));
}
////////////////////////////////////////////////////////////////////////////////////////////





////////////////////////////////////////////////////////////////////////////////////////////
//Âîçâðàùàåò ÈÑÒÈÍÀ, åñëè íàéäåíû íåíóëåâûå êîòèðîâêè ïåðâîãî èíñòðóìåíòà
////////////////////////////////////////////////////////////////////////////////////////////
bool isValidPriceX(int shift)
{
   return(iOpen(Symbol(), 0, shift) > 0.0);
}
////////////////////////////////////////////////////////////////////////////////////////////






////////////////////////////////////////////////////////////////////////////////////////////
//Âîçâðàùàåò ÈÑÒÈÍÀ, åñëè íàéäåíû íåíóëåâûå êîòèðîâêè âòîðîãî èíñòðóìåíòà
////////////////////////////////////////////////////////////////////////////////////////////
bool isValidPriceY(int shift)
{
   if(AutoCorrelation)
      return(iOpen(Symbol(), 0, AutoCorrelationShift + shift) > 0.0);
   else
      return(iOpen(Pair, 0, shift) > 0.0);
}
////////////////////////////////////////////////////////////////////////////////////////////






////////////////////////////////////////////////////////////////////////////////////////////
//Âûðåçàåò èç ïîäãîòîâëåííûõ ìàññèâîâ äàííûõ êóñêè äëÿ ðàñ÷åòà êîýô. êîððåëÿöèè
////////////////////////////////////////////////////////////////////////////////////////////
void CreateDataArrays(int StartBar)
{
   ArrayResize(ArrayX, CorrelationRadius); ArrayResize(ArrayY, CorrelationRadius);
   ArrayInitialize(ArrayX, 0.0); ArrayInitialize(ArrayY, 0.0);
   datetime timeX, timeY;
   int DataCounter = 0, yIndex = StartBar, xIndex = StartBar;
   while(xIndex < StartBar + CorrelationRadius || xIndex < ArraySize(ValidX))
   {
      if(ValidX[xIndex] > 0.0 && ValidY[yIndex] > 0.0)//Åñëè íóæíûå êîòèðîâêè åñòü
      {
         ArrayX[DataCounter] = ValidX[xIndex]; ArrayY[DataCounter] = ValidY[yIndex];
         DataCounter++;
      }
      yIndex++; xIndex++;      
   }
   //Åñëè äîñòóïíûå äàííûå íåïîêðûâàþò ðàäèóñ êîððåëÿöèè - òî ñ÷èòàåì, ÷òî äàííûõ íåò âîîáùå
   if(DataCounter < CorrelationRadius)
      {ArrayResize(ArrayX, 0); ArrayResize(ArrayY, 0);}
}
////////////////////////////////////////////////////////////////////////////////////////////






////////////////////////////////////////////////////////////////////////////////////////////
//Ôîðìèðóåò ïîäãîòîâëåííûå ìàññèâû äàííûõ, â êîòîðûõ ó÷òåíû âîçìîæíûå ðàñõîæäåíèÿ âî 
//âðåìåíàõ áàðîâ äâóõ èíñòðóìåíòîâ
////////////////////////////////////////////////////////////////////////////////////////////
void CreateValidData()
{
   ArrayResize(ValidX, ValidDataLength); ArrayResize(ValidY, ValidDataLength);
   ArrayInitialize(ValidX, 0.0); ArrayInitialize(ValidY, 0.0);
   datetime timeX, timeY;
   int yIndex = - 1;
   ValidDataCounter = 0;
   for(int xIndex = 0; xIndex < ValidDataLength; xIndex++)
   {
      yIndex++;
      timeX = iTime(Symbol(), 0, xIndex); timeY = iTime(Pair, 0, yIndex);
      if(timeX == NULL || timeY == NULL)break;
      if(AutoCorrelation)
      {
         if(!(isValidPriceX(xIndex) && isValidPriceY(yIndex)))
         {
            Sleep(2000);
            if(!(isValidPriceX(xIndex) && isValidPriceY(yIndex)))
               continue;
         }
         ValidX[xIndex] = getX(xIndex); ValidY[yIndex] = getY(yIndex);
         ValidDataCounter++;
      }
      else
      {
         if(timeX == timeY)
         {
            if(!(isValidPriceX(xIndex) && isValidPriceY(yIndex)))//Åñëè íóæíûõ êîòèðîâîê íåò
            {
               Sleep(2000);//Æäåì 2 ñåêóíäû
               if(!(isValidPriceX(xIndex) && isValidPriceY(yIndex)))//È ñíîâà çàïðàøèâàåì êîòèðîâêè
                  continue;//Åñëè èõ îïÿòü íåò - ïðåõîäèì ê ñëåäóþùåìó áàðó
            }
            ValidX[xIndex] = getX(xIndex); ValidY[yIndex] = getY(yIndex);
            ValidDataCounter++;
         }
         else if(timeX > timeY)
         {
            xIndex++;//Ïåðåñêàêèâàåì ÷åðåç ïðîáëåìíûé áàð â êîòèðîâêàõ ïåðâîãî èíñòðóìåíòà
         }               
         else if(timeX < timeY)
         {
            yIndex++;//Ïåðåñêàêèâàåì ÷åðåç áàð â êîòèðîâêàõ âòîðîãî èíñòðóìåíòà
         }
      }
   }
}
////////////////////////////////////////////////////////////////////////////////////////////





////////////////////////////////////////////////////////////////////////////////////////////
//Âîçâðàùàåò êîýôôèöèåíò êîððåëÿöèè ìåæäó äâóìÿ ìàññèâàìè äàííûõ
//(â äàííîì ñëó÷àå, ðàäèóñ êîððåëÿöèè ñîîòâåòñâóåò ðàçìåðàì ìàññèâîâ, êîòîðûå äîëæíû áûòü îäèíàêîâû)
////////////////////////////////////////////////////////////////////////////////////////////
double getCorrelation(double X[], double Y[])
{
   if(ArraySize(X) != ArraySize(Y) || ArraySize(X) == 0)return(0.0);
   double avgX = 0, avgY = 0, covarXY = 0, dispX = 0, dispY = 0;
   int i, length = ArraySize(X);
   
   for(i = 0; i < length; i++)
      {avgX += X[i];avgY += Y[i];}
   avgX /= length;avgY /= length;
   
   for(i = 0; i < length; i++)
   {
      covarXY += (X[i]-avgX)*(Y[i]-avgY);
      dispX += (X[i] - avgX)*(X[i] - avgX);
      dispY += (Y[i] - avgY)*(Y[i] - avgY);
   }
   covarXY /= length; dispX /= length; dispY /= length;
   
   if(MathSqrt(dispX*dispY) > 0.0)
      return(covarXY/MathSqrt(dispX*dispY));
   else
      return(0.0);
}
////////////////////////////////////////////////////////////////////////////////////////////





////////////////////////////////////////////////////////////////////////////////////////////
//Ñîçäàíèå ìåòîê äëÿ âûâîäà èòîãîâûõ íàäïèñåé âíèçó îêíà
////////////////////////////////////////////////////////////////////////////////////////////
void CreateSummaryLabels()
{
   IndicatorWindow = WindowFind(ShortName);
   if(IndicatorWindow == -1)return(-1);
   string Name = ShortName + SummaryLabel + "1";
   if(ObjectFind(Name) == -1 && ObjectCreate(Name, OBJ_LABEL, IndicatorWindow, 0, 0))
   {
      ObjectSet(Name, OBJPROP_CORNER, 2);
      ObjectSet(Name, OBJPROP_XDISTANCE, 0);
      ObjectSet(Name, OBJPROP_YDISTANCE, 0.7*FontSize);
   }
   Name = ShortName + SummaryLabel + "2";
   if(ObjectFind(Name) == -1 && ObjectCreate(Name, OBJ_LABEL, IndicatorWindow, 0, 0))
   {
      ObjectSet(Name, OBJPROP_CORNER, 2);
      ObjectSet(Name, OBJPROP_XDISTANCE, 0);
      ObjectSet(Name, OBJPROP_YDISTANCE, 2.5*FontSize);
   }
}
////////////////////////////////////////////////////////////////////////////////////////////




////////////////////////////////////////////////////////////////////////////////////////////
//Óäàëÿþòñÿ âñå îáúåêòû, â èìåíàõ êîòîðûõ ñîäåðæèòñÿ ñòðîêà
//Phrase (ðàñïîëîæåííàÿ â ïðîèçâîëüíîé ïîçèöèè)
////////////////////////////////////////////////////////////////////////////////////////////
void DeleteObjectsByPhrase(string Phrase)
{
   string ObjName;
   for(int i = ObjectsTotal()-1; i >= 0; i--)
   {
      ObjName = ObjectName(i);
      if(StringFind(ObjName, Phrase, 0) > -1) 
      { 
         ObjectDelete(ObjName);
      }
   }
}
////////////////////////////////////////////////////////////////////////////////////////////


double getSymbol(string Smbl, int shift, int Mode, int TimeFrame = 0)
{
   double
      h = iHigh(Smbl, TimeFrame, shift),
      o = iOpen(Smbl, TimeFrame, shift),
      c = iClose(Smbl, TimeFrame, shift),
      l = iLow(Smbl, TimeFrame, shift);
      
   switch(Mode)
   {
      case CLOSE_MODE: return(c);
      case CLOSEOPEN_MODE: return(c - o);
      case CLOSE_RELATIVE_MODE: return(c/h);
      case CLOSEOPEN_RELATIVE_MODE: return((c - o)/h);
      
      case HIGHLOW_MODE: return(h - l);
      case HIGHLOW_RELATIVE_MODE: return((h - l)/h);
      case HIGHLOW_AVG_MODE: return((h + l)/2.0);
      case HIGHLOW_AVG_RELATIVE_MODE: return((h + l)/(2.0*h));

      case FULL_AVG_MODE: return((h + l + c + o)/4.0);
      case FULL_AVG_RELATIVE_MODE: return((h + l + c + o)/(4.0*h));
   }
}