^L_Correlation_v2

Download script
Author: Copyright � 2008, lotos4u
^L_Correlation_v2

This script is a specialized financial analysis tool designed to measure the relationship between two different market instruments (such as two different currencies, like GBP and USD). It identifies how closely two assets move in tandem or in opposition.

Core Functionality

The primary purpose of the tool is to calculate a Correlation Coefficient. This is a numerical value that tells you if two assets are moving together (positive correlation), in opposite directions (negative correlation), or have no relationship at all.

The script offers two distinct ways to analyze this data:

  1. Pair Correlation: Comparing two different assets (e.g., seeing how "Gold" moves relative to the "US Dollar").
  2. Auto-Correlation: Comparing an asset against its own past performance (e.g., seeing if the current price action of "EURUSD" repeats a pattern it showed 50 bars ago).

Data Processing Logic

To provide accurate results, the script does not just look at raw prices. It allows you to choose specific types of data to analyze:

  • Price Variations: You can measure the difference between opening and closing prices.
  • Relative Movement: You can measure price movement as a percentage of the highest price in a period.
  • Range Analysis: You can focus on the "High" and "Low" values to see volatility correlation.
  • Average Performance: You can use the average of all four price points (Open, High, Low, Close) to smooth out noise.

Key Visual Features

The script provides several layers of visual information to help a user interpret the market:

  • Correlation Line: A primary curve showing the changing relationship between the two assets over time.
  • Moving Average (MA): A smoother line that filters out "noise," helping you see the overall trend of the correlation rather than just short-term fluctuations.
  • Histogram: A visual distribution chart at the bottom of the window. This shows how often certain correlation levels occur, providing a "snapshot" of historical behavior.
  • Essential Points & Zones: The script can automatically identify and mark "extreme" moments where the correlation becomes particularly strong or significant. It marks these with points, vertical lines, or rectangles on your chart to highlight specific areas of interest.

Intelligent Adjustments

The tool includes "smart" logic to handle different trading timeframes. If the user doesn't manually specify certain settings, the script automatically adjusts the "Lookback Radius" (the amount of data it looks at to calculate a single point) based on whether you are looking at 1-minute charts versus Daily or Weekly charts.

Summary Labels

For quick reference, the script generates an on-screen summary. This text updates in real-time to show the number of "Significant Points" found and the average correlation strength, allowing the trader to see the data at a glance without having to manually interpret the entire curve.

Price Data Components
Series array that contains open prices of each barSeries array that contains the highest prices of each barSeries array that contains close prices for each barSeries array that contains the lowest prices of each bar
Indicators Used
Moving average indicator
Miscellaneous
Implements a curve of type %1
7 Views
0 Downloads
0 Favorites
^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));
   }
}

Similar scripts

Levels_A_Vlad

Levels_A_Vlad_3

This indicator projects a series of recursive support and resistance levels derived from price action extremes using variable coefficient multipliers.

Igrok

ATM_xpMAv10bVS_25LWMAmedian

BoxFibo

This indicator identifies specific price extremes within a predefined temporal window to generate visual boundaries and multi-level retracement zones.

^L_Correlation

Quantifies the statistical linear relationship between two financial assets by calculating covariation and dispersion over a dynamic rolling window.

pricehistgram_onclick

This indicator visualizes historical price distribution across multiple timeframes using an interactive click event to generate a volumetric histogram based on localized price bins.

NeutralHedge osc_v3[1].1

This indicator quantifies the price discrepancy between a primary and secondary asset by normalizing their relative ranges and identifying statistically significant deviations using standard deviation thresholds.

ATM_XpMA

Comments