X-Trader.net - El Foro de los Traders

¿Dudas sobre trading? Plantea tus cuestiones sobre el funcionamiento del mercado, descarga indicadores y sistemas de trading y comparte tus operaciones con otros traders.
https://www.x-trader.net/foro/

Laguerre Moving Average

https://www.x-trader.net/foro/viewtopic.php?t=13014

Página 1 de 1

Laguerre Moving Average

Publicado: 01 May 2010 16:01
por rtrader
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:

Imagen

Alguien lo tiene para el metatrader?

Saludos

Uploaded with ImageShack.us

Re: Laguerre Moving Average

Publicado: 01 May 2010 17:18
por Fer137
rtrader escribió:Alguien lo tiene para el metatrader?
El Laguerre y otros ventipico de Ehlers:
http://www.mqlsoft.com/download/indicators

Re: Laguerre Moving Average

Publicado: 01 May 2010 19:44
por rtrader
Gracias Fer137, pero no es el que busco... y eso que lo hice en todos los sitios para descargar indicadores.

Saludos

Re: Laguerre Moving Average

Publicado: 01 May 2010 21:35
por Fer137
¿? 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);
 }

Re: Laguerre Moving Average

Publicado: 02 May 2010 16:43
por rtrader
:smt022 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.

Re: Laguerre Moving Average

Publicado: 02 May 2010 20:29
por rtrader
Fer137 te pido disculpas, efectivamente el indicador es el que decías el Laguerre Filter. :oops:

Mil gracias.

Re: Laguerre Moving Average

Publicado: 03 May 2010 22:05
por Mirus Futures
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

Re: Laguerre Moving Average

Publicado: 04 May 2010 01:24
por rtrader
Gracias Mirus Futures :smt023

Saludos
Todos los horarios son UTC+02:00
Página 1 de 1

Desarrollado por phpBB® Forum Software © phpBB Limited

Traducción al español por phpBB España