^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));
   }
}





Sample





Analysis



Market Information Used:

Series array that contains tick volumes of each bar
Series array that contains open time of each bar
Series array that contains the highest prices of each bar
Series array that contains the lowest prices of each bar
Series array that contains open prices of each bar
Series array that contains close prices for each bar


Indicator Curves created:

Implements a curve of type DRAW_LINE

Implements a curve of type DRAW_ARROW

Indicators Used:

Moving average indicator


Custom Indicators Used:

Order Management characteristics:

Other Features: