Indicadores: Indicador de correlación de Pearson

Dmitry Fedoseev 2012.05.29 11:49 #11

Aquí, aproximadamente así - https://www.mql5.com/es/code/183. El punto es que la copia de datos de otros símbolos no se realiza de una sola vez, sino barra por barra. Durante tal copia, desde otros símbolos, la barra será copiada exactamente correspondiente al tiempo de la barra del gráfico, en la cual se muestra el indicador. Si no hay una barra correspondiente, entonces de una barra anterior (como la función iBarShift() en MQL4). En este indicador se copia una barra a la vez, pero para la correlación, puede ser necesario copiar el número correspondiente al periodo de correlación. Puede hacerlo de otra manera - copiar una barra a la vez y ponerla en el buffer del indicador. Usando el buffer puede hacerlo todo lo más rápido posible (por supuesto a costa de un mayor consumo de memoria). Puedes hacerlo sin un buffer extra, con un par de variables estáticas.... Es largo de explicar, es probable que sea necesario escribir un artículo:)

El lienzo es genial. Indicadores de élite :) Características del lenguaje mql5,

Mykola Demko 2012.05.29 11:57 #12

pusheax:

Vale, ayer nos pasamos un poco, supongo que tú también celebraste el "Día de la Guardia de Fronteras" como yo.

¿Me puedes dar un enlace a la correcta sincronización de compases, porque yo también uso este método de sincronización por el último compás y ya está?

No te daré un enlace (porque aún no lo conozco), pero describiré el método.

El método se refiere a la sincronización de diferentes instrumentos, aunque se puede utilizar para la sincronización de diferentes TFs.

Llevo bastante tiempo tratando este problema, e incluso SD hizo un bug-fix para los fallos de este método.

El problema de sincronización está relacionado con el hecho de que diferentes instrumentos tienen un número diferente de barras. Aproximadamente igual es un criterio falso, todo debe ser exacto. Barra a barra. De lo contrario, se pierde el sentido de la sincronización.

El segundo aspecto de este problema es ¿cómo mostrar una barra si no hay barra en el instrumento actual?

Así que la esencia del método es simple: los datos en el instrumento se solicitan estrictamente por tiempos...

count=CopyRates(symbol,tf,time0,time1,rates); если нужно несколько баров
или
count=CopyRates(symbol,tf,time0,1,rates); если нужен один

y la muestra de tiempo se toma del buffer estándar del indicador time[]. De este modo, siempre se sabe con certeza que se está ante una barra que llegó de forma sincrónica con una barra en otro instrumento.

De nuevo, si no existe tal barra en el instrumento actual, no la solicitará. Y si el instrumento solicitado no tiene tal barra como muestra, obtendrá un cero en el recuento y normalmente podrá manejar esta excepción, dependiendo de la lógica de su programa.

Gráfico de patrimonio y Indicador de Super Señales Aprendizaje automático en el

hrenfx 2012.05.29 13:03 #13

Implementación de la sincronización (en MQL4) para cualquier número de FIs(desde aquí):

double GetPrice( string Symb, int time )
{
  double Price;
 
  Price = iClose(Symb, Period(), iBarShift(Symb, Period(), time));
 
  return(Price);
}
 
int GetNextTime( int CurrTime )
{
  static int Pos[MAX_AMOUNTSYMBOLS];
  int i, MinTime, Tmp = -1;
 
  for (i = 0; i < AmountSymbols; i++)
  {
    Pos[i] = iBarShift(Symbols[i], Period(), CurrTime) - 1;
 
    if (Pos[i] >= 0)
      Tmp = i;
  }
 
  if (Tmp < 0)
    return(Time[0]);
 
  MinTime = iTime(Symbols[Tmp], Period(), Pos[Tmp]);
 
  i = Tmp - 1;
 
  while (i >= 0)
  {
    if (Pos[i] >= 0)
    {
      Tmp = iTime(Symbols[i], Period(), Pos[i]);
 
      if (Tmp < MinTime)
        MinTime = Tmp;
    }
 
    i--;
  }
 
  return(MinTime);
}
 
void GetBaseMatrix()
{
  int i, NextTime;
 
  NextTime = GetNextTime(CurrTime);
 
  while (NextTime < Time[0])
  {
    CurrTime = NextTime;
 
    for (i = 0; i < AmountSymbols; i++)
      BaseMatrix[i][MatrixRows] = 1000 * MathLog(GetPrice(Symbols[i], CurrTime));
 
    Times[MatrixRows] = CurrTime;
 
    MatrixRows++;
 
    NextTime = GetNextTime(CurrTime);
  }
 
  return;
}

Por analogía para dos símbolos(desde aquí):

double GetPrice( string Symb, int time )
{
  double Price;
 
  Price = iClose(Symb, Period(), iBarShift(Symb, Period(), time));
 
  return(Price);
}
 
int GetNextTime( int CurrTime )
{
  static int Pos[TWO_SYMBOLS];
  int i, MinTime, Tmp = -1;
 
  for (i = 0; i < TWO_SYMBOLS; i++)
  {
    Pos[i] = iBarShift(Symbols[i], Period(), CurrTime) - 1;
 
    if (Pos[i] >= 0)
      Tmp = i;
  }
 
  if (Tmp < 0)
    return(Time[0]);
 
  MinTime = iTime(Symbols[Tmp], Period(), Pos[Tmp]);
 
  i = Tmp - 1;
 
  while (i >= 0)
  {
    if (Pos[i] >= 0)
    {
      Tmp = iTime(Symbols[i], Period(), Pos[i]);
 
      if (Tmp < MinTime)
        MinTime = Tmp;
    }
 
    i--;
  }
 
  return(MinTime);
}
 
void GetBaseMatrix()
{
  int i, NextTime;
 
  NextTime = GetNextTime(CurrTime);
 
  while (NextTime < Time[0])
  {
    CurrTime = NextTime;
 
    for (i = 0; i < TWO_SYMBOLS; i++)
      BaseMatrix[i][MatrixRows + Shifts[i]] = MathLog(GetPrice(Symbols[i], CurrTime));
 
    Times[MatrixRows] = CurrTime;
 
    MatrixRows++;
 
    NextTime = GetNextTime(CurrTime);
  }
 
  return;
}

Es decir, todo es bastante sencillo. Otra cosa es que la representación barométrica clásica (discretización en tiempo constante) de los PB de precios no sea la única, y mucho menos siempre correcta. A veces es extremadamente útil sincronizar los BPs de precios de otra dimensión temporal. Es decir, introduciendo distorsiones no lineales desde el punto de vista del tiempo clásico. En consecuencia, entonces la correlación mostrará interrelaciones no lineales de dos RV clásicas.

El indicador del sistema Indicador diferencial de Sultonov Discusión sobre el artículo

pusheax 2012.05.29 13:58 #14

¡Gracias por vuestra ayuda!

Me equivoqué lo reconozco, no pensaba que la sincronización fuera tan complicada.

Voy a tratar de averiguarlo y sincronizar barras directamente en este indicador ya que lo necesito mucho.

Ayuda a la codificación ¿Es posible estimar el Estrategias de negociación basadas

Mihail Lagutin 2012.05.29 15:31 #15

Gracias a todos por la información.

He reescrito un poco el indicador. Ahora, supuestamente, debería omitir las partes malas de la historia.

Ya que hemos empezado, por favor, compruebe si hay errores :)

Archivos adjuntos:

Correlation.mq5 8 kb

No el Grial, sólo Discusión sobre el artículo El sistema de comercio

hrenfx 2012.05.29 15:44 #16

Voy a hablar una vez más por la necesidad de optimización algorítmica para todos los indicadores. Y también para el mecanismo incorporado de cálculo de los valores de los indicadores en la memoria (archivo), de modo que durante la optimización del probador el indicador no calcula lo mismo, pero toma valores listos de allí.

[¡AVISO CERRADO!] Cualquier pregunta ¡Ayude a quien le Cálculo de una matriz

Mihail Lagutin 2012.05.29 15:50 #17

hrenfx:
Voy a hablar una vez más por la necesidad de optimización algorítmica para todos los indicadores. Y también para un mecanismo incorporado de cálculo de los valores del indicador en la memoria (archivo), de modo que durante la optimización del probador el indicador no calcula lo mismo, pero toma valores ya hechos de allí.

¿Podría mostrar un ejemplo donde esto ya se ha hecho?

hrenfx 2012.05.29 16:03 #18

La optimización algorítmica para cada indicador es diferente. Para diferentes formas de utilizar la correlación, hice, por ejemplo, esto y esto.

La lectura de memoria de los valores de los indicadores calculados de antemano para toda la historia se hizo sólo en mi calculadora. Es decir, no tengo un mecanismo universal, porque sólo uso mis propias soluciones, que no son nada bonitas. Pero ya que estoy a favor de la mejora de todo, sería genial tener un mecanismo universal de este tipo en el caso del optimizador del probador MT5, ya que da una aceleración de varios órdenes de magnitud (experiencia de usarlo en mi calculadora), es decir, eclipsa a Cloud en términos de eficiencia.

Ideología del probador de Un poco sorprendido :) AMD o Intel, así

Reaper 2012.05.29 18:46 #19

Hola

A veces me paso el tiempo distorsionando los códigos de los demás, por lo general los resultados de un programa incompleto o incompleta, tanto la falta de tiempo y la falta de habilidad.

Esta vez me gustaría tratar de distorsionar este indicador maravilloso, y trató de hacer algo como esto:

- Dibujar sólo una línea, no una línea de trazado de puntos

#property indicator_type1 DRAW_COLOR_LINE
#property indicator_width1 2

// #property indicator_type2 DRAW_COLOR_HISTOGRAM
// #propiedad indicator_style2 STYLE_DOT
// #propiedad indicator_width2 1

- Añadir un montón de símbolos como

//--- parámetros de entrada
input string _SecondSymbol="EURGBP"; // Símbolo

input string _ThirdSymbol="EURAUD"; // Símbolo
input string _FourthSymbol="EURCAD"; // Símbolo
input string _FifthSymbol="EURCHF"; // Símbolo
input string _SixthSymbol="EURNZD"; // Símbolo
input string _SeventhSymbol="EURHKD"; // Símbolo
input string _EighthSymbol="EURTRY"; // Símbolo

A continuación, crear 2 variantes del código fuente:

- Variante visual: una línea de color para cada uno de los pares de divisas correlación 1 línea gruesa que es sólo el promedio de 7 líneas ((A+B+C+D+E+F+G)/7)

- Sin variante visual: 1 línea solamente, que es el resultado de la fórmula anterior ((A+B+C+D+D+E+F+G)/7)

Casi como añadir 7 (u 8) Indicador de Correlación original, pero todo sumado de manera que sólo promedia como con la versión, una de las cuales es de 7 líneas + 1 (promedio), y la otra versión con 1 línea (sólo promedio).

algo como esto

buf[i]= (
(v1/sqrt(v2*v3))+
(v4/sqrt(v2*v6))+
(v7/sqrt(v2*v9))+
(v10/sqrt(v2*v12))+
(v13/sqrt(v2*v15))+
(v16/sqrt(v2*v18))+
(v19/sqrt(v2*v21)) 
)/7; // media simple de los valores.


buf2[i]=buf[i];
c=getPlotColor(buf[i]);
colors1[i]=c;
colors2[i]=c;

Por varias razones el código desordenado no hace lo que quiero hacer debido a errores completamente lógicos.

El problema principal está en la parte de los buffers, la sincronización y la sangría recursiva del código:

if(bars1>bars2)
{
minBars=bars2;
bars2=bars1-bars2;
etc...

+ además de otros errores lógicos.

se han añadido algunas funciones Print() para ayudar en el caso de seguimiento de valores de variables y se han comentado las instrucciones return 0 para encontrar dónde falla lógicamente el código.

Enseño desde cero, así AutoGraf Serie 4 - Vender su código

Reaper 2012.05.29 18:49 #20

código y archivo

//+------------------------------------------------------------------+
//| Correlation.mq5
//|| Copyright 2012, iC |
//| http://www.icreator.biz/ |
//+------------------------------------------------------------------+
#property copyright "Copyright 2012, iC"
#property link "http://www.icreator.biz/"
#property version "1.00"
//--- configuración del indicador
#property indicator_separate_window

#property indicator_minimum -1
#property indicator_maximum 1

#property indicator_buffers 25
#property indicator_plots 2

#property indicator_type1 DRAW_COLOR_LINE
#property indicator_width1 2

// #property indicator_type2 DRAW_COLOR_HISTOGRAM
// #propiedad indicator_style2 STYLE_DOT
// #propiedad indicator_width2 1

/*

#property indicator_type2 DRAW_COLOR_LINE
#property indicator_width2 2

#property indicator_type3 DRAW_COLOR_LINE
#property indicator_width3 2

#property indicator_type4 DRAW_COLOR_LINE
#property indicator_width4 2

#property indicator_type5 DRAW_COLOR_LINE
#propiedad indicator_width5 2

#propiedad indicator_type6 DRAW_COLOR_LINE
#propiedad indicator_width6 2

#propiedad indicator_type7 DRAW_COLOR_LINE
#propiedad indicator_width7 2

#propiedad indicator_type8 DRAW_COLOR_LINE
#propiedad indicator_width8 2

*/

//--- define
#define MAX_COL 64
//--- estructuras
struct CRGB
{
int r;
int g;
int b;
};
//--- parámetros de entrada
input string _SecondSymbol="EURGBP"; // Símbolo

input string _ThirdSymbol="EURAUD"; // Símbolo
input string _FourthSymbol="EURCAD"; // Símbolo
input string _FifthSymbol="EURCHF"; // Símbolo
input string _SixthSymbol="EURNZD"; // Símbolo
input string _SeventhSymbol="EURHKD"; // Símbolo
input string _EighthSymbol="EURTRY"; // Símbolo

input int _SettPeriod=100; // Período
input ENUM_APPLIED_PRICE _AppliedPrice=PRICE_CLOSE; // Precio
input color _Color1=clrLightGray; // Correlación mínima.
input color _Color2=clrLime; // Correlación máxima.

//--- tampones indicadores
double buf[],buf2[]
,buf3[],buf4[],buf5[],buf6[],buf7[],buf8[];

double arr1[],arr2[]
,arr3[],arr4[],arr5[],arr6[],arr7[],arr8[];

double colors1[],colors2[];

//--- MA maneja
int h1,h2,
h3,h4,h5,h6,h7,h8;
//+------------------------------------------------------------------+
//| Función de inicialización del indicador personalizada |
//+------------------------------------------------------------------+
int OnInit()
{
SetIndexBuffer(0,buf);
SetIndexBuffer(1,colors1,INDICATOR_COLOR_INDEX);

SetIndexBuffer(2,buf2);
SetIndexBuffer(3,colors2,INDICATOR_COLOR_INDEX);

SetIndexBuffer(4,arr1,INDICATOR_CALCULATIONS); // primer símbolo
SetIndexBuffer(5,arr2,INDICATOR_CALCULATIONS); // segundo símbolo


SetIndexBuffer(6,arr3,INDICATOR_CALCULATIONS); //3
SetIndexBuffer(7,arr4,INDICATOR_CALCULATIONS); //4

SetIndexBuffer(8,arr5,INDICATOR_CALCULATIONS); //5
SetIndexBuffer(9,arr6,INDICATOR_CALCULATIONS); //6º

SetIndexBuffer(10,arr7,INDICATOR_CALCULATIONS); //7

SetIndexBuffer(11,arr8,INDICATOR_CALCULATIONS); //8

/* 
SetIndexBuffer(12,arr9,INDICATOR_CALCULATIONS);
SetIndexBuffer(13,arr10,INDICATOR_CALCULATIONS);

SetIndexBuffer(14,arr11,INDICATOR_CALCULATIONS);
SetIndexBuffer(15,arr12,INDICATOR_CALCULATIONS);

SetIndexBuffer(16,buf3);
SetIndexBuffer(17,colours3,INDICATOR_COLOR_INDEX);

SetIndexBuffer(18,buf4);
SetIndexBuffer(19,colours4,INDICATOR_COLOR_INDEX);

SetIndexBuffer(20,buf5);
SetIndexBuffer(21,colours5,INDICATOR_COLOR_INDEX);

SetIndexBuffer(22,buf6);
SetIndexBuffer(23,colours6,INDICATOR_COLOR_INDEX);

SetIndexBuffer(24,buf7);
SetIndexBuffer(25,colours7,INDICATOR_COLOR_INDEX);

// etc...
*/

PlotIndexSetDouble(0,PLOT_EMPTY_VALUE,0);
PlotIndexSetDouble(1,PLOT_EMPTY_VALUE,0);

PlotIndexSetInteger(0,PLOT_SHOW_DATA,0);
IndicatorSetInteger(INDICATOR_DIGITS,3); 

IndicatorSetString(INDICATOR_SHORTNAME,_Symbol+"/"+_SecondSymbol+", "+IntegerToString(_SettPeriod)+", "+EnumToString(_AppliedPrice)+","); // etc...

setPlotColor(0,_Color1,_Color2);
setPlotColor(1,_Color1,_Color2);

h1=iMA(_Symbol,0,1,0,MODE_EMA,_AppliedPrice);
h2=iMA(_SecondSymbol,0,1,0,MODE_EMA,_AppliedPrice);

// valores añadidos.
h3=iMA(_ThirdSymbol,0,1,0,MODE_EMA,_AppliedPrice);
h4=iMA(_FourthSymbol,0,1,0,MODE_EMA,_AppliedPrice);
h5=iMA(_FifthSymbol,0,1,0,MODE_EMA,_AppliedPrice);
h6=iMA(_SixthSymbol,0,1,0,MODE_EMA,_AppliedPrice);
h7=iMA(_SeventhSymbol,0,1,0,MODE_EMA,_AppliedPrice);
h8=iMA(_EighthSymbol,0,1,0,MODE_EMA,_AppliedPrice);

return 0;
}
//+------------------------------------------------------------------+
//| Función de iteración del indicador personalizada |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
const int prev_calculated,
const int begin,
const double &price[])
{
int i,j,c,limit,bars1,bars2
,bars3,bars4,bars5,bars6,bars7,bars8, 
minBars,toCopy;
double averX1=0,averX2=0
,averX3=0,averX4=0,averX5=0,averX6=0,averX7=0,averX8=0,
v1=0,v2=0,v3=0
,v4=0,v5=0,v6=0,v7=0,v8=0
,v9=0,v10=0,v11=0,v12=0
,v13=0,v14=0,v15=0,v16=0,v17=0
,v18=0,v19=0,v20=0,v21=0;
datetime t1[1],t2[1],
t3[1],t4[1],t5[1],t6[1],t7[1],t8[1];
//--- símbolos de sincronización
if( 
(
CopyTime(_Symbol,0,0,1,t1)<1 || 
CopyTime(_SecondSymbol,0,0,1,t2)<1 || 

CopyTime(_ThirdSymbol,0,0,1,t3)<1 || 
CopyTime(_FourthSymbol,0,0,1,t4)<1 || 
CopyTime(_FifthSymbol,0,0,1,t5)<1 || 
CopyTime(_SixthSymbol,0,0,1,t6)<1 || 
CopyTime(_SeventhSymbol,0,0,1,t7)<1 || 
CopyTime(_EighthSymbol,0,0,1,t8)<1
) 
|| 

(
t1[0]!=t2[0]
|| t1[0]!=t3[0]
|| t1[0]!=t4[0]
|| t1[0]!=t5[0]
|| t1[0]!=t6[0]
|| t1[0]!=t7[0]
|| t1[0]!=t8[0]
)
) 
{
Print("Synchronization failed!");
// devuelve 0;
}
//--- comprobar datos

bars1=rates_total;
bars2=Bars(_SecondSymbol,0);

bars3=Bars(_ThirdSymbol,0);
bars4=Bars(_FourthSymbol,0);
bars5=Bars(_FifthSymbol,0);
bars6=Bars(_SixthSymbol,0);
bars7=Bars(_SeventhSymbol,0);
bars8=Bars(_EighthSymbol,0);

// sangrar el si el otro hasta que el minBars se encuentra. // para comprobar si la lógica es correcta

if(bars1>bars2)
{
minBars=bars2;
bars2=bars1-bars2;
bars1=0;
Print("bars1>bars2; minBars(",minBars,"),=bars2(",bars2,")=bars1(",bars1,")-bars2(",bars2,");");
// }
//si no 
if(bars1>bars3)
{
minBars=bars3;
bars3=bars1-bars3;
bars1=0;
Print("bars1>bars3; minBars(",minBars,"),=bars3(",bars3,")=bars1(",bars1,")-bars3(",bars3,");");
// } 
//si no 
if(bars1>bars4)
{
minBars=bars4;
bars4=bars1-bars4;
bars1=0;
Print("bars1>bars4; minBars(",minBars,"),=bars4(",bars4,")=bars1(",bars1,")-bars4(",bars4,");");
// } 
//si no 
if(bars1>bars5)
{
minBars=bars5;
bars5=bars1-bars5;
bars1=0;
Print("bars1>bars5; minBars(",minBars,"),=bars5(",bars5,")=bars1(",bars1,")-bars5(",bars5,");");
// } 
//si no 
if(bars1>bars6)
{
minBars=bars6;
bars6=bars1-bars6;
bars1=0;
Print("bars1>bars6; minBars(",minBars,"),=bars6(",bars6,")=bars1(",bars1,")-bars6(",bars6,");");
// } 
//si no 
if(bars1>bars7)
{
minBars=bars7;
bars7=bars1-bars7;
bars1=0;
Print("bars1>bars7; minBars(",minBars,"),=bars7(",bars7,")=bars1(",bars1,")-bars7(",bars7,");");
// } 
//si no 
if(bars1>bars8)
{
minBars=bars8;
bars8=bars1-bars8;
bars1=0;
Print("bars1>bars8; minBars(",minBars,"),=bars8(",bars8,")=bars1(",bars1,")-bars8(",bars8,");");
} }}}}}} 

else
{
minBars=bars1;
bars1=bars2-bars1;
bars2=0;
Print("bars1!>bars2,3,4,5,6,7,8; minBars(",minBars,"),=bars1(",bars1,")=bars2(",bars2,")-bars1(",bars1,");");
}
if(minBars<_SettPeriod)
{
Print("Bars is not enough to calculate!");
// devuelve 0;
}
if(BarsCalculated(h1)<minBars)
{
Print("Not all data of MA1 is calculated. Error ",GetLastError());
// devuelve 0;
}
if(BarsCalculated(h2)<minBars)
{
Print("Not all data of MA2 is calculated. Error ",GetLastError());
// devuelve 0;
}
if(BarsCalculated(h3)<minBars)
{
Print("Not all data of MA3 is calculated. Error ",GetLastError());
// devuelve 0;
}
if(BarsCalculated(h4)<minBars)
{
Print("Not all data of MA4 is calculated. Error ",GetLastError());
// devuelve 0;
}
if(BarsCalculated(h5)<minBars)
{
Print("Not all data of MA5 is calculated. Error ",GetLastError());
// devuelve 0;
}
if(BarsCalculated(h6)<minBars)
{
Print("Not all data of MA6 is calculated. Error ",GetLastError());
// devuelve 0;
}
if(BarsCalculated(h7)<minBars)
{
Print("Not all data of MA7 is calculated. Error ",GetLastError());
// devuelve 0;
}
if(BarsCalculated(h8)<minBars)
{
Print("Not all data of MA8 is calculated. Error ",GetLastError());
// devuelve 0;
} 

//--- podemos copiar no todos los datos
if(prev_calculated>rates_total || 
prev_calculated<=0)
toCopy=minBars;
else
toCopy=rates_total-prev_calculated+1;

if(CopyBuffer(h1,0,0,minBars,arr1)<minBars || 
CopyBuffer(h2,0,0,minBars,arr2)<minBars || 

CopyBuffer(h3,0,0,minBars,arr3)<minBars || 
CopyBuffer(h4,0,0,minBars,arr4)<minBars || 
CopyBuffer(h5,0,0,minBars,arr5)<minBars || 
CopyBuffer(h6,0,0,minBars,arr6)<minBars || 
CopyBuffer(h7,0,0,minBars,arr7)<minBars || 
CopyBuffer(h8,0,0,minBars,arr8)<minBars) 

{
Print("Getting MA buffer failed. Error ",GetLastError());
// devuelve 0;
}
if(prev_calculated>rates_total || 
prev_calculated<=0)
limit=bars1+bars2+_SettPeriod-1
+bars3+bars4+bars5+bars6+bars7+bars8;

else
limit=prev_calculated-1;
//--- 
for(i=limit;i<rates_total;i++)
{
averX1=0; averX2=0; 
averX3=0;averX4=0;averX5=0;averX6=0;averX7=0;averX8=0;
for(j=0;j<_SettPeriod;j++)
{
averX1+=arr1[i-j-bars1]/_SettPeriod;
averX2+=arr2[i-j-bars2]/_SettPeriod;

averX3+=arr3[i-j-bars3]/_SettPeriod;
averX4+=arr4[i-j-bars4]/_SettPeriod;
averX5+=arr5[i-j-bars5]/_SettPeriod;
averX6+=arr6[i-j-bars6]/_SettPeriod;
averX7+=arr7[i-j-bars7]/_SettPeriod;
averX8+=arr8[i-j-bars8]/_SettPeriod;
}

v1=0; v2=0; v3=0;
v4=0;v5=0;v6=0;v7=0;v8=0;
v9=0;v10=0;v11=0;v12=0;v13=0;
v14=0;v15=0;v16=0;v17=0;v18=0;
v19=0;v20=0;v21=0; 
for(j=0;j<_SettPeriod;j++)
{
v1+=(arr1[i-j-bars1]-averX1)*(arr2[i-j-bars2]-averX2);
v2+=pow((arr1[i-j-bars1]-averX1),2);
v3+=pow((arr2[i-j-bars2]-averX2),2);

v4+=(arr1[i-j-bars1]-averX2)*(arr3[i-j-bars3]-averX3);
// v5+=pow((arr1[i-j-bars1]-averX1),2);
v6+=pow((arr3[i-j-bars3]-averX3),2);

v7+=(arr1[i-j-bars1]-averX1)*(arr4[i-j-bars4]-averX4);
// v8+=pow((arr1[i-j-bars1]-averX1),2);
v9+=pow((arr4[i-j-bars4]-averX4),2);

v10+=(arr1[i-j-bars1]-averX1)*(arr5[i-j-bars5]-averX5);
// v11+=pow((arr1[i-j-bars1]-averX1),2);
v12+=pow((arr5[i-j-bars5]-averX5),2);

v13+=(arr1[i-j-bars1]-averX1)*(arr6[i-j-bars6]-averX6);
// v14+=pow((arr1[i-j-bars1]-averX1),2);
v15+=pow((arr6[i-j-bars6]-averX6),2);

v16+=(arr1[i-j-bars1]-averX1)*(arr7[i-j-bars7]-averX7);
// v17+=pow((arr1[i-j-bars1]-averX1),2);
v18+=pow((arr7[i-j-bars7]-averX7),2);

v19+=(arr1[i-j-bars1]-averX1)*(arr8[i-j-bars8]-averX8);
// v20+=pow((arr1[i-j-bars1]-averX1),2);
v21+=pow((arr8[i-j-bars8]-averX8),2);

}
buf[i]= (
(v1/sqrt(v2*v3))+
(v4/sqrt(v2*v6))+
(v7/sqrt(v2*v9))+
(v10/sqrt(v2*v12))+
(v13/sqrt(v2*v15))+
(v16/sqrt(v2*v18))+
(v19/sqrt(v2*v21)) 
)/7; // media simple de los valores.


buf2[i]=buf[i];
c=getPlotColor(buf[i]);
colors1[i]=c;
colors2[i]=c;
}
return rates_total;
}

//+------------------------------------------------------------------+
//| setPlotColour |
//+------------------------------------------------------------------+
void setPlotColor(int plot,color col1,color col2)
{
int i;
CRGB c1,c2;
double dr,dg,db;
string s;
//--- 
PlotIndexSetInteger(plot,PLOT_COLOR_INDEXES,MAX_COL);
ColorToRGB(col1,c1);
ColorToRGB(col2,c2);
dr=(double)(c2.r-c1.r)/MAX_COL;
dg=(double)(c2.g-c1.g)/MAX_COL;
db=(double)(c2.b-c1.b)/MAX_COL;
for(i=0;i<MAX_COL;i++)
{
s=StringFormat("%i,%i,%i",
c1.r+(int)NormalizeDouble(dr*(i+1),0),
c1.g+(int)NormalizeDouble(dg*(i+1),0),
c1.b+(int)NormalizeDouble(db*(i+1),0));
PlotIndexSetInteger(plot,PLOT_LINE_COLOR,i,StringToColor(s));
}
}
//+------------------------------------------------------------------+
//| getPlotColor |
//+------------------------------------------------------------------+
int getPlotColor(double current)
{
return((int)NormalizeDouble((MAX_COL-1)*fabs(current),0));
}
//+------------------------------------------------------------------+
//| ColorToRGB |
//+------------------------------------------------------------------+
void ColorToRGB(color col,CRGB &res)
{
string s,s2;
int n;
//---
s=ColorToString(col);
n=StringFind(s,",");
s2=StringSubstr(s,0,n);
res.r=(int)StringToInteger(s2);
s=StringSubstr(s,n+1);
n=StringFind(s,",");
s2=StringSubstr(s,0,n);
res.g=(int)StringToInteger(s2);
s=StringSubstr(s,n+1);
s2=StringSubstr(s,0);
res.b=(int)StringToInteger(s2);
}
//+------------------------------------------------------------------+

Archivos adjuntos:

Correlation_Var.mq5 16 kb

Indicadores: Indicador de correlación de Pearson - página 2