Indicador diferencial de Sultonov - página 41

Nuevo comentario
 
Dmitry Fedoseev:

Habrá un código en 5 minutos. Tenga en cuenta que el RSI utiliza el suavizado de Wilder, que es lo mismo que el suavizado exponencial pero con un período más largo, por lo que puede haber un desajuste notable.


¿Qué hay que preparar? Tiramos el buffer principal de RSI y ponemos los dos buffers existentes en su lugar:

//+------------------------------------------------------------------+
//|                                                          RSI.mq4 |
//|                   Copyright 2005-2014, MetaQuotes Software Corp. |
//|                                              https://www.mql4.com |
//+------------------------------------------------------------------+
#property copyright   "2005-2014, MetaQuotes Software Corp."
#property link        "https://www.mql4.com"
#property description "Relative Strength Index"
#property strict

#property indicator_separate_window
#property indicator_buffers    2
#property  indicator_color1     clrBlue
#property  indicator_color2     clrRed

//--- input parameters
input int InpRSIPeriod=14; // RSI Period
//--- buffers
double ExtPosBuffer[];
double ExtNegBuffer[];
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit(void)
  {
   string short_name;
//--- 2 additional buffers are used for counting.
   SetIndexBuffer(0,ExtPosBuffer);
   SetIndexBuffer(1,ExtNegBuffer);
//--- indicator line
   SetIndexStyle(0,DRAW_LINE);
   SetIndexStyle(1,DRAW_LINE);
//--- name for DataWindow and indicator subwindow label
   short_name="RSI("+string(InpRSIPeriod)+")";
   IndicatorShortName(short_name);
   SetIndexLabel(0,short_name);
//--- check for input
   if(InpRSIPeriod<2)
     {
      Print("Incorrect value for input variable InpRSIPeriod = ",InpRSIPeriod);
      return(INIT_FAILED);
     }
//---
   SetIndexDrawBegin(0,InpRSIPeriod);
//--- initialization done
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Relative Strength Index                                          |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
  {
   int    i,pos;
   double diff;
//---
   if(Bars<=InpRSIPeriod || InpRSIPeriod<2)
      return(0);
//--- counting from 0 to rates_total
   ArraySetAsSeries(ExtPosBuffer,false);
   ArraySetAsSeries(ExtNegBuffer,false);
   ArraySetAsSeries(close,false);
//--- preliminary calculations
   pos=prev_calculated-1;
   if(pos<=InpRSIPeriod)
     {
      //--- first RSIPeriod values of the indicator are not calculated
      ExtPosBuffer[0]=0.0;
      ExtNegBuffer[0]=0.0;
      double sump=0.0;
      double sumn=0.0;
      for(i=1; i<=InpRSIPeriod; i++)
        {
         ExtPosBuffer[i]=0.0;
         ExtNegBuffer[i]=0.0;
         diff=close[i]-close[i-1];
         if(diff>0)
            sump+=diff;
         else
            sumn-=diff;
        }
      //--- calculate first visible value
      ExtPosBuffer[InpRSIPeriod] = sump / InpRSIPeriod;
      ExtNegBuffer[InpRSIPeriod] = sumn / InpRSIPeriod;
      //--- prepare the position value for main calculation
      pos=InpRSIPeriod+1;
     }
//--- the main loop of calculations
   for(i=pos; i<rates_total && !IsStopped(); i++)
     {
      diff=close[i]-close[i-1];
      ExtPosBuffer[i]=(ExtPosBuffer[i-1]*(InpRSIPeriod-1)+(diff>0.0?diff:0.0))/InpRSIPeriod;
      ExtNegBuffer[i]=(ExtNegBuffer[i-1]*(InpRSIPeriod-1)+(diff<0.0?-diff:0.0))/InpRSIPeriod;
     }
//---
   return(rates_total);
  }
//+------------------------------------------------------------------+
Ahí no hay suavidad. Y el cálculo es diferente, ya que la fuerza de los osos incluye el doji. Esa es la diferencia. El fiscal lo tiene en cuenta.
 
Dmitry Fedoseev:

Habrá un código en 5 minutos. Tenga en cuenta que el RSI utiliza el suavizado de Wilder, que es el mismo que el exponencial pero con un periodo más largo, por lo que puede haber un desajuste notable.

¿Te estás echando atrás ahora?
 

Se adjunta un indicador.

Parámetros:

periodo - periodo en bares;

Componentes - opción de cálculo de componentes:

  • c_rsi - como para el RSI
  • c_adx - como para ADX
  • c_x - como en el caso de RSI, pero la división no es por período, sino por número real de incrementos.

Métodosuave - suave:

  • s_wilder - Método Wilder
  • s_ema - alisamiento exponencial.
Tenga en cuenta que los componentes del RSI se suavizan mediante Wilder, mientras que los componentes del ADX se suavizan mediante el método exponencial convencional (es decir, el periodo 14 del RSI corresponde al periodo 27 del ADX).

Potencia: la forma de calcular la línea final:

  • f_off - no se muestra para ver mejor los componentes
  • f_rsi - como para el RSI
  • f_adx - como ADX.

Para información: la línea final del RSI no está suavizada, el ADX está suavizado.

***

Usted puede obtener RSI y ADX y varios híbridos por este indicador a través de la configuración.

Para obtener RSI:

  • Componentes - c_rsi
  • Suave - s_wilder
  • Potencia - f_rsi;

Para obtener ADX:

  • Componentes - c_adx
  • Suave - s_ema
  • Potencia - f_adx

Potencia - activar/desactivar para mantener los componentes fuera del camino.

***

También se adjunta la plantilla con dos indicadores como en la imagen de este post.

Archivos adjuntos:
qwerty.mq5  6 kb
2ind.tpl  201 kb
 
Yousufkhodja Sultonov:
¿Estás retrocediendo ahora?

¿Dónde está la historia de fondo? ¿Cinco minutos para escribir un post es mucho?

 
Ihor Herasko:

...

No hay antialiasing en there....

¿Qué es eso? -

ExtPosBuffer[i]=(ExtPosBuffer[i-1]*(InpRSIPeriod-1)+(diff>0.0?diff:0.0))/InpRSIPeriod;
ExtNegBuffer[i]=(ExtNegBuffer[i-1]*(InpRSIPeriod-1)+(diff<0.0?-diff:0.0))/InpRSIPeriod;
Es un alisado más salvaje. Es esencialmente idéntico al exponencial, pero más lento.
 
Dmitry Fedoseev:

¿Dónde está la historia de fondo? ¿Son muchos 5 minutos para escribir un post?

No hay suavizado en el DA y no es necesario. ¿Qué dices a eso?
 
Yousufkhodja Sultonov:
No hay suavizado en DA y no es necesario. ¿Qué te parece?

Es posible no suavizar como en el RSI, sino los propios componentes, es una media simple. Es posible refinar mi indicador universal anterior para activar/desactivar el suavizado. Pero conceptualmente nada cambia.

Además, será mejor que lo muestre antes de hablar. ¿Por qué me preguntas tan severamente, y tú bla bla bla

 
Dmitry Fedoseev:

¿Dónde está la historia de fondo? ¿Son muchos 5 minutos para escribir un post?

Lo que quería decir era esto: "Hayque tener en cuenta que el RSI utiliza el suavizado de Wilder, es lo mismo que el exponencial pero con un periodo mayor, puede haber un desajuste notable por ello. "

Cualquier convención con periodos más largos o más cortos, alisamiento exponencial o regular, ¿qué sentido tiene todo esto? DA coge al toro por los cuernos y al oso por las patas.

 
Dmitry Fedoseev:
Es posible no suavizar como en el RSI, sino los propios componentes, es una media simple. Es posible refinar mi indicador universal anterior para activar/desactivar el suavizado. Pero conceptualmente nada cambia.
Ahora, por supuesto, puedes hacerlo.
 
Dmitry Fedoseev:
Es posible no suavizar como en el RSI, sino los propios componentes, es una media simple. Puedes refinar mi indicador universal anterior para activar/desactivar el suavizado. Pero conceptualmente nada cambia.

Estás tratando de discutir con fórmulas con alguien que habla el lenguaje de la poesía.

1...34353637383940414243444546474849
Nuevo comentario