Laguerre Moving Average

rtrader · Mensaje por **rtrader** » 01 May 2010 16:01

Resulta que utilizo la media T3 de Tilson y ya hace bastante tiempo que busco la Laguerre Moving Average que arroja mejores resultados que la T3 Tilson según este artículo sacado de http://www.tradingsys.org/index.php?opt ... &Itemid=65

De los trabajos sobre procesamiento digital de señales nos llega este interesante filtro basado en las transformaciones de Laguerre. John F. Ehlers, en su artículo “Time Warp – Without Space Travel”, muestra como emplear esta metodología en la construcción de una media suavizada capaz de filtrar las irregularidades pseudoaleatorias de la curva de precios a cambio de un pequeño retardo que puede ser modulado a voluntad por el usuario. En este pequeño estudio compararamos el SMA con otros sistemas de filtrado, como el T3 de Tillson.

Los filtros convencionales, de los que derivan el Generalized DEMA o la media T3 de Tillson, emplean transformaciones aritméticas que requieren al menos dos parámetros: Número de barras de la serie y coeficiente de filtrado (vfactor). A cambio, se consigue una relación aceptable entre nivel de filtrado (smoth) y retardo (lag).

En mi opinión, una de las principales ventajas de la metodología propuesta por Ehlers, es que consigue crear –como seguidamente veremos– curvas prácticamente equivalentes empleando muy pocos datos y con un sólo parámetro optimizable: El factor gamma. En la práctica, esto se traduce en indicadores con un mayor nivel de sensibilidad y con la misma o superior capacidad de filtrado.

Por otra parte, esta técnica puede aplicarse en la construcción de versiones mejoradas de otros indicadores como el RSI, el MACD o el Estocástico que se adaptan con mayor rapidez a la evolución de los precios.

Omitiremos los detalles matemáticos sobre las transformaciones de Laguerre para centrarnos en la estructura del LMA. La media consta de tres partes:

(A) Un descriptor de la estructura consensual del mercado en cada barra. Por lo general: Price= (H+L+C)/3, Price =(H+L)/2 o Price=Close.

(B) La transformación de Laguerre para un número limitado de elementos (entre tres y cinco):

L0 = (1-gamma)*Price+gamma*L0[1]
L1= -gamma*L0+L0[1]+gamma*L1[1]
L2= -gamma*L1+L1[1]+gamma*L2[1]
L3= -gamma*L2+L2[1]+gamma*L3[1]

(C) Un filtro de salida tipo FIR:

LMA=(L0+2*L1+2*L2+L3)/6

En la imagen inferior podemos ver como se modifica la relación entre filtrado y retardo en la LMA para diferentes valores del parámetro gamma:

Alguien lo tiene para el metatrader?

Saludos

Uploaded with ImageShack.us

Fer137 · Mensaje por **Fer137** » 01 May 2010 17:18

rtrader escribió:Alguien lo tiene para el metatrader?

El Laguerre y otros ventipico de Ehlers:
http://www.mqlsoft.com/download/indicators

rtrader · Mensaje por **rtrader** » 01 May 2010 19:44

Gracias Fer137, pero no es el que busco... y eso que lo hice en todos los sitios para descargar indicadores.

Saludos

Fer137 · Mensaje por **Fer137** » 01 May 2010 21:35

¿? Creo que es el LaguerreFilter al que te refieres.

En cuanto a

(A) Un descriptor de la estructura consensual del mercado en cada barra. Por lo general: Price= (H+L+C)/3, Price =(H+L)/2 o Price=Close.

tendrias que modificar ligeramente el codigo si lo quieres aplicar a medianPrice o typìcalPrice.

LaguerreFilter:

Código: Seleccionar todo

#property indicator_chart_window
#property indicator_buffers 2
#property indicator_color1 Red
#property indicator_color2 Blue

extern double Gamma = 0.8;

double Filter[];
double FIR[];
double L0[];
double L1[];
double L2[];
double L3[];

int buffers = 0;
int drawBegin = 0;

int init() {
    drawBegin = 4;
    initBuffer(Filter, "Laguerre Filter", DRAW_LINE);
    initBuffer(FIR, "FIR", DRAW_LINE);
    initBuffer(L0);
    initBuffer(L1);
    initBuffer(L2);
    initBuffer(L3);
    IndicatorBuffers(buffers);
    IndicatorShortName("Laguerre Filter [" + DoubleToStr(Gamma, 2) + "]");  
    return (0);
}
  

int start() {
    if (Bars <= drawBegin) return (0);
    int countedBars = IndicatorCounted();
    if (countedBars < 0) return (-1);
    if (countedBars > 0) countedBars--;
    int s, limit = Bars - countedBars - 1;
    for (s = limit; s >= 0; s--) {
        L0[s] = (1.0 - Gamma) * P(s) + Gamma * L0[s + 1];
        L1[s] = -Gamma * L0[s] + L0[s + 1] + Gamma * L1[s + 1];
        L2[s] = -Gamma * L1[s] + L1[s + 1] + Gamma * L2[s + 1];
        L3[s] = -Gamma * L2[s] + L2[s + 1] + Gamma * L3[s + 1];
        Filter[s] = (L0[s] + 2.0 * L1[s] + 2.0 * L2[s] + L3[s]) / 6.0;
        FIR[s] = (P(s) + 2.0 * P(s + 1) + 2.0 * P(s + 2) + P(s + 3)) / 6.0;
        if (s > Bars - 4) {
            L0[s] = P(s);
            L1[s] = P(s);
            L2[s] = P(s);
            L3[s] = P(s);
            Filter[s] = P(s);
        }
    }   
    return (0);   
}

double P(int index) {
    return ((High[index] + Low[index]) / 2.0);
}

void initBuffer(double array[], string label = "", int type = DRAW_NONE, int arrow = 0, int style = EMPTY, int width = EMPTY, color clr = CLR_NONE) {
    SetIndexBuffer(buffers, array);
    SetIndexLabel(buffers, label);
    SetIndexEmptyValue(buffers, EMPTY_VALUE);
    SetIndexDrawBegin(buffers, drawBegin);
    SetIndexShift(buffers, 0);
    SetIndexStyle(buffers, type, style, width);
    SetIndexArrow(buffers, arrow);
    buffers++;
}

--------------------------------------------------------------------------------------------------------------

LaguerreRSI:

Código: Seleccionar todo

#property indicator_separate_window
#property indicator_buffers 2
#property indicator_color1 Red
#property indicator_color2 Blue
#property indicator_minimum 0
#property indicator_maximum 1
#property indicator_level1 0.8
#property indicator_level2 0.2

extern double Gamma = 0.5;

double RSI[];
double L0[];
double L1[];
double L2[];
double L3[];

int buffers = 0;
int drawBegin = 0;

int init() {
    drawBegin = 4;
    initBuffer(RSI, "Laguerre RSI", DRAW_LINE);
    initBuffer(L0);
    initBuffer(L1);
    initBuffer(L2);
    initBuffer(L3);
    IndicatorBuffers(buffers);
    IndicatorShortName("Laguerre RSI [" + DoubleToStr(Gamma, 2) + "]");  
    return (0);
}

int start() {
    if (Bars <= drawBegin) return (0);
    int countedBars = IndicatorCounted();
    if (countedBars < 0) return (-1);
    if (countedBars > 0) countedBars--;
    int s, limit = Bars - countedBars - 1;
    for (s = limit; s >= 0; s--) {
        L0[s] = (1.0 - Gamma) * Close[s] + Gamma * L0[s + 1];
        L1[s] = -Gamma * L0[s] + L0[s + 1] + Gamma * L1[s + 1];
        L2[s] = -Gamma * L1[s] + L1[s + 1] + Gamma * L2[s + 1];
        L3[s] = -Gamma * L2[s] + L2[s + 1] + Gamma * L3[s + 1];
        double CU = 0.0;
        double CD = 0.0;
        if (L0[s] >= L1[s]) {
            CU = L0[s] - L1[s];
        } else {
            CD = L1[s] - L0[s];
        }
        if (L1[s] >= L2[s]) {
            CU += L1[s] - L2[s];
        } else {
            CD += L2[s] - L1[s];
        }
        if (L2[s] >= L3[s]) {
            CU += L2[s] - L3[s];
        } else {
            CD += L3[s] - L2[s];
        }        
        RSI[s] = 0.0;
        if (CU + CD != 0.0) {
            RSI[s] = CU / (CU + CD);
        }
    }   
    return (0);   
}

void initBuffer(double array[], string label = "", int type = DRAW_NONE, int arrow = 0, int style = EMPTY, int width = EMPTY, color clr = CLR_NONE) {
    SetIndexBuffer(buffers, array);
    SetIndexLabel(buffers, label);
    SetIndexEmptyValue(buffers, EMPTY_VALUE);
    SetIndexDrawBegin(buffers, drawBegin);
    SetIndexShift(buffers, 0);
    SetIndexStyle(buffers, type, style, width);
    SetIndexArrow(buffers, arrow);
    buffers++;
}

--------------------------------------------------------------------------------

LaguerreROC

Código: Seleccionar todo

#property indicator_separate_window

#property indicator_color1 Red

#property indicator_level2 1.00
#property indicator_level3 0.75
#property indicator_level4 0.50
#property indicator_level5 0.25
#property indicator_level6 0.00

#property indicator_maximum  1.10
#property indicator_minimum -0.10

//---- input parameters
extern int    vPeriod   =     5;
extern double gamma     = 0.500;
extern int    CountBars =  3000;

double ROC = 0;
double L0 = 0;
double L1 = 0;
double L2 = 0;
double L3 = 0;
double L0A = 0;
double L1A = 0;
double L2A = 0;
double L3A = 0;
double LROC = 0;
double CU = 0;
double CD = 0;

double val1[];
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
  {
//---- indicators
//----
   SetIndexBuffer(0,val1);
   return(0);
  }
//+------------------------------------------------------------------+
//| Custor indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit()
  {
//---- TODO: add your code here
   
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start()
  {
   if (CountBars>Bars) CountBars=Bars;
   SetIndexDrawBegin(0,Bars-CountBars);
   
   int i;
   int counted_bars=IndicatorCounted();

   i = CountBars-1;
   while(i>=0)
   {
      L0A = L0;
      L1A = L1;
      L2A = L2;
      L3A = L3;
      
      ROC = (((Close[i] - Close[i + vPeriod]) / Close[i + vPeriod]) + Point);
      L0 = ((1 - gamma)*(ROC)) + (gamma*L0A);
      
      L1 = - gamma *L0 + L0A + gamma *L1A;
      L2 = - gamma *L1 + L1A + gamma *L2A;
      L3 = - gamma *L2 + L2A + gamma *L3A;

      CU = 0;
      CD = 0;
      
      if (L0 >= L1) CU = L0 - L1; else CD = L1 - L0;
      if (L1 >= L2) CU = CU + L1 - L2; else CD = CD + L2 - L1;
      if (L2 >= L3) CU = CU + L2 - L3; else CD = CD + L3 - L2;

      if (CU + CD != 0) LROC = CU / (CU + CD);
      val1[i] = LROC;
	  i--;
	}
   return(0);
 }

----------------------------------------------------------------------------------------
LagurreMinusDI

Código: Seleccionar todo

#property indicator_separate_window
#property indicator_minimum -0.05
#property indicator_maximum 1.05
#property indicator_color1 Red
#property indicator_level2 0.75
#property indicator_level3 0.50
#property indicator_level4 0.25
//---- input parameters
extern double periods=14;
extern double timeperiods=0;
extern double gamma=0.764;
extern int CountBars=300;

double L0 = 0;
double L1 = 0;
double L2 = 0;
double L3 = 0;
double L0A = 0;
double L1A = 0;
double L2A = 0;
double L3A = 0;
double LRSI = 0;
double CU = 0;
double CD = 0;

double val1[];
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
      
int init()
  {
//---- indicators
//----
   SetIndexBuffer(0,val1);
   return(0);
  }
//+------------------------------------------------------------------+
//| Custor indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit()
  {
//---- TODO: add your code here
   
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start()
  {
   if (CountBars>Bars) CountBars=Bars;
   SetIndexDrawBegin(0,Bars-CountBars);
   
   int i;
   int    counted_bars=IndicatorCounted();

   //if(CountBars<=Lookback) return(0);
   //---- initial zero
   //if(counted_bars<1)
   //{
   //   for(i=1;i<=Lookback;i++) val1[CountBars-i]=0.0;
   //}

   i=CountBars-1;
   while(i>=0)
   {
      L0A = L0;
      L1A = L1;
      L2A = L2;
      L3A = L3;
      L0 = ((1 - gamma)*iADX(NULL,timeperiods,periods,PRICE_LOW,MODE_MINUSDI,i)) + gamma*L0A;
      L1 = ((- gamma *L0) + L0A) + (gamma *L1A);
      L2 = ((- gamma *L1) + L1A) + (gamma *L2A);
      L3 = ((- gamma *L2) + L2A) + (gamma *L3A);

      CU = 0;
      CD = 0;
      
      if (L0 >= L1) CU = L0 - L1; else CD = L1 - L0;
      if (L1 >= L2) CU = CU + L1 - L2; else CD = CD + L2 - L1;
      if (L2 >= L3) CU = CU + L2 - L3; else CD = CD + L3 - L2;

      if (CU + CD != 0) LRSI = CU / (CU + CD);
      val1[i] = LRSI;
	  i--;
	}
   return(0);
 }

-------------------------------------------------------------------------
LaguerrePlusDi

Código: Seleccionar todo

#property indicator_separate_window
#property indicator_minimum -0.05
#property indicator_maximum 1.05
#property indicator_color1 LawnGreen
#property indicator_level2 0.75
#property indicator_level3 0.50
#property indicator_level4 0.25
//---- input parameters
extern double periods=14;
extern double timeperiods=0;
extern double gamma=0.764;
extern int CountBars=300;

double L0 = 0;
double L1 = 0;
double L2 = 0;
double L3 = 0;
double L0A = 0;
double L1A = 0;
double L2A = 0;
double L3A = 0;
double LRSI = 0;
double CU = 0;
double CD = 0;

double val1[];
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
      
int init()
  {
//---- indicators
//----
   SetIndexBuffer(0,val1);
   return(0);
  }
//+------------------------------------------------------------------+
//| Custor indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit()
  {
//---- TODO: add your code here
   
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start()
  {
   if (CountBars>Bars) CountBars=Bars;
   SetIndexDrawBegin(0,Bars-CountBars);
   
   int i;
   int    counted_bars=IndicatorCounted();

   //if(CountBars<=Lookback) return(0);
   //---- initial zero
   //if(counted_bars<1)
   //{
   //   for(i=1;i<=Lookback;i++) val1[CountBars-i]=0.0;
   //}

   i=CountBars-1;
   while(i>=0)
   {
      L0A = L0;
      L1A = L1;
      L2A = L2;
      L3A = L3;
      L0 = ((1 - gamma)*iADX(NULL,timeperiods,periods,PRICE_HIGH,MODE_PLUSDI,i)) + gamma*L0A;
      L1 = ((- gamma *L0) + L0A) + (gamma *L1A);
      L2 = ((- gamma *L1) + L1A) + (gamma *L2A);
      L3 = ((- gamma *L2) + L2A) + (gamma *L3A);

      CU = 0;
      CD = 0;
      
      if (L0 >= L1) CU = L0 - L1; else CD = L1 - L0;
      if (L1 >= L2) CU = CU + L1 - L2; else CD = CD + L2 - L1;
      if (L2 >= L3) CU = CU + L2 - L3; else CD = CD + L3 - L2;

      if (CU + CD != 0) LRSI = CU / (CU + CD);
      val1[i] = LRSI;
	  i--;
	}
   return(0);
 }

rtrader · Mensaje por **rtrader** » 02 May 2010 16:43

No es ninguno de esos. Mira subo el código para Visual Chart por si algún alma caritativa lo puede hacer mq4 para el metatrader.

Gracias y saludos.

rtrader · Mensaje por **rtrader** » 02 May 2010 20:29

Fer137 te pido disculpas, efectivamente el indicador es el que decías el Laguerre Filter.

Mil gracias.

Mirus Futures · Mensaje por **Mirus Futures** » 03 May 2010 22:05

rtrader - Estaba buscando un indicador durante el día y coincidí al que estabas buscando.

http://www.bigmiketrading.com/free_down ... 0&keyid=95

Saludos,
Mirus Futures

rtrader · Mensaje por **rtrader** » 04 May 2010 01:24

Gracias Mirus Futures

Saludos

Laguerre Moving Average

Laguerre Moving Average

Re: Laguerre Moving Average

Re: Laguerre Moving Average

Re: Laguerre Moving Average

Re: Laguerre Moving Average

Re: Laguerre Moving Average

Re: Laguerre Moving Average

Re: Laguerre Moving Average