Fractal Dimension Index (FDI)

[Pablo Heras]

Las personas estamos acostumbradas a ver las cosas de una forma suave y regular: un edificio es cuadradao, un balón circular, una superficie plana, un triángulo, etc, etc. Las matemáticas están creadas para explicar el mundo que hemos creado. Pero, los patrones de la naturaleza, las cosas estaban ahí antes de que nosotros llegáramos: nubes, montañas, los animales, etc. Todo eso es ajeno a las matemáticas. Mandelbrot dijo en los 70- Oye, sólo tenéis que mirar los patrones de la naturaleza de forma correcta y podréis aplicar las matemáticas.
Hay un orden bajo el aparente caos y es posible crear fórmulas que describan las nubes, las montañas, el sonido... sólo que son un tipo de fórmulas distintos.
Un gráfico de un mercado financiero es un fractal, se puede framentarla una y otra vez de tal manera que la totalidad del fractal es igual a cualquiera de sus partes, que a su vez es igual o otro trozo más pequeño. Básicamente los estados de un mercado son dos: una fase de tendencia donde el mercado se asimila más a una línea, y una fase lateral o de rango donde el precio traza curvas sinuosas y donde la fractalidad es mucho mayor. Con el Fractal Dimension Index (FDI) podemos distinguir estas dos fases y cuantificar cuando el mercado se sale de un lateral dándonos oportunidades para abrir posiciones en los mercados.
El FDI tiene un rango de entre 1 y 2. Cuando tenemos índices próximos al 1.35 el mercado está en lateral y cuando el FDI recoge índices entorno al 1.55 podemos decir que entrará en tendencia tan pronto como estos índices empiecen a decaer, dándonos oportunidades para abrir posiciones. Os adjunto un gráfico con este indicador y un enlace a un vídeo donde explico más detalladamente como utilizarlo.

[Rafa7]

El FDI tiene un rango de entre 1 y 2. Cuando tenemos índices próximos al 1.35 el mercado está en lateral y cuando el FDI recoge índices entorno al 1.55 podemos decir que entrará en tendencia tan pronto como estos índices empiecen a decaer, dándonos oportunidades para abrir posiciones.

Gracias Pablo Heras,



He leído, u oído, que algunos consideran el FDI uno de los mejores indicadores para detectar lateralidad.
Interesante.

¿El gráfico de precios es algún tipo de Renko?
¿Las nubes son el Kumo del Ichimoku?



Saludos.

[Pablo Heras]

Hola Rafa!
Efectivamente, el FDI mide muy bien cuando el mercado sale de un lateral. Si miras el gráfico que adjunté como ejemplo verás que cuando el indicador comienza a descender y supera la línea de 1,5 (Color verde) el mercado va entrando en una zona de distribución (lateral) y luego cuando vuelve a subir el mercado comienza a coger tendencia. Lo que mide el indicador es la fractalidad, cuando hay tendencia el mercado empieza a ser lineal y cuando entra en lateral se vuelve más fractal. Obviamente no es la panacea y no se puede operar únicamente con este indicador pero puede resultar de ayuda.

En cuanto a las velas, efectivamente, son velas renko con colas o pabilos y el indicador que ves de fondo es la nube de Ichimoku con la línea Kijun Sen de 26 periodos. En cualquier caso, el indicador Ichimoku te permite operar sin la necesidad de añadir ningún otro indicador de apoyo.

Un saldudo.

[mascara]

Hola!

¿Alguien sabría explicar de forma sencilla cómo se calcula el FDI?. Es que en mi plataforma (JForex) parece que no existe así que tendré que hacérmelo, pero las cosas que estoy encontrando se me hacen muy matemáticas para mi... Me refiero a una explicación en plan: "en cada barra coges el Open, lo multiplicas por tal...", algo así...

He encontrado el código en mq4 y calgo, pero sin saber más o menos cómo es, se va a complicar reescribirlo en JForex...

Muchas gracias!

[Rango Starr]

Mira a ver si te sirve. Es de prorealtime, pero el código es muy intuitivo:

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


variable a definir : N = 30

--------------código-------------
once fdi=undefined

if barindex >= n-1 then
diff=0
length = 0
pdiff = 0
hh=0
ll=0
FDI=0
HH = highest[N](close)
LL = lowest[N](close)

for Period = 1 to N-1 do
if (HH - LL) > 0 then
diff = (customclose[Period] - LL) / (HH - LL)
if Period > 1 then
length = length + SQRT(SQUARE(diff - pdiff) + (1 / SQUARE(N)))
endif
pdiff = diff
endif
next

if length > 0 then
FDI = 1 + (LOG(length) + LOG(2)) / LOG(2 * (N))
else
FDI = 0
endif
endif

return FDI AS "Fractal Dimension Index"
-----------------------------------

Saludos

[jda]

Mira a ver si te sirve. Es de prorealtime, pero el código es muy intuitivo:

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


variable a definir : N = 30

--------------código-------------
once fdi=undefined

if barindex >= n-1 then
diff=0
length = 0
pdiff = 0
hh=0
ll=0
FDI=0
HH = highest[N](close)
LL = lowest[N](close)

for Period = 1 to N-1 do
if (HH - LL) > 0 then
diff = (customclose[Period] - LL) / (HH - LL)
if Period > 1 then
length = length + SQRT(SQUARE(diff - pdiff) + (1 / SQUARE(N)))
endif
pdiff = diff
endif
next

if length > 0 then
FDI = 1 + (LOG(length) + LOG(2)) / LOG(2 * (N))
else
FDI = 0
endif
endif

return FDI AS "Fractal Dimension Index"
-----------------------------------

Saludos

En serio,no se como podeis programar.Yo no me enteraria de nada.Y aprender me costaria dios y ayuda....puffffff

[chien1]

Hola,

alguien lo tiene para el Ninjatrader?

Gracias.

[Rango Starr]

Jda,

ese código no es mio, pero da igual....

coge el código, y traduce las palabras reconocibles al castellano. Tendras una estructura lógica del estilo:

esto es i gual a ....(máximo- minimo)...
o--------

Si el máximo de la diferencia entre esto y esto otro es mayor que cero, entonces haz:
esto menos lo otro, dividido por la longitud de la distancia, multiplicada por dos, y eso es igual a Pascual
fin

devuelve Pascual como "Pascual que te veo"...

y el programa te graficaria una línea llamada, "Pascual que te veo", cuyo valor es Pascual
..... y etc...

Saludos!

[Feroz]

Chien1

Mandame un MP

[chien1]

Chien1

Mandame un MP

Gracias Feroz. Le he encontrado por la nube

[Feroz]

ok

[Xavi]

Chief.

Llego tarde pero te lo adjunto para Ninjatrader que lo tenia por ahi.
Por si alguien nos lee...y lo necesita.

PD: Por cierto alguien lo tiene para JForex?

[mascara]

Muchas gracias!,

A ver si entre estos y los dos que encontré yo, lo saco... y subo los que encontré yo esta tarde porque los tengo en casa...

Saludos,

[X-Trader]

Justo acabo de subirlo al apartado de indicadores para Ninjatrader

viewtopic.php?f=55&t=19161

Saludos,
X-Trader

[mascara]

Esta es mi versión del FDI para JForex... Si alguien que use JForex y otra plataforma puede comprobar si sale parecido... O comparando la imagen... Gracias!

Código: Seleccionar todo

package jforex;

import com.dukascopy.api.indicators.*;

public class indFractalDimensionIndex implements IIndicator{
    private IndicatorInfo indicatorInfo;
    private InputParameterInfo[] inputParameterInfos;
    private OptInputParameterInfo[] optInputParameterInfos;
    private OutputParameterInfo[] outputParameterInfos;
    private double[][] inputs = new double[1][];
    private int timePeriod = 2;
    private double medval  = 0;
    private double[][] outputs = new double[2][];
    private IIndicator max;
    private IIndicator min;

    public void onStart(IIndicatorContext context) {
        indicatorInfo = new IndicatorInfo("FDI", "Fractal Dimension Index", "My indicators",
                false, false, false, 1, 2, 2);
        inputParameterInfos = new InputParameterInfo[] {
            new InputParameterInfo("Input data", InputParameterInfo.Type.DOUBLE)
        };
        optInputParameterInfos = new OptInputParameterInfo[] {
            new OptInputParameterInfo("Time period", OptInputParameterInfo.Type.OTHER,
                new IntegerRangeDescription(30, 2, 100, 1)),
            new OptInputParameterInfo("Medio", OptInputParameterInfo.Type.OTHER,
                new DoubleRangeDescription(1.5, 0.0, 3.0, 0.05,1)),          
        };
        outputParameterInfos = new OutputParameterInfo[] {
            new OutputParameterInfo("FDI", OutputParameterInfo.Type.DOUBLE,
                OutputParameterInfo.DrawingStyle.LINE),
            new OutputParameterInfo("med", OutputParameterInfo.Type.DOUBLE,
                OutputParameterInfo.DrawingStyle.LINE),                
        };
        
        IIndicatorsProvider indicatorsProvider = context.getIndicatorsProvider();
        max = indicatorsProvider.getIndicator("MAX");
        min = indicatorsProvider.getIndicator("MIN");
    }

    public IndicatorResult calculate(int startIndex, int endIndex) {
        if (startIndex - getLookback() < 0) {
            startIndex = getLookback();
        }
        if (startIndex > endIndex) {
            return new IndicatorResult(0, 0);
        }

        double[] outsMax = new double[outputs[0].length];
        double[] outsMin = new double[outputs[0].length];
        double Diff      = 0; 
        double Length    = 0; 
        double PriceMax  = 0; 
        double PriceMin  = 0; 
        double PriorDiff = 0; 
        double Iteration = 0; 
        double FractalDI = 0;
        int i, j;
                      
        max.setInputParameter(0, inputs[0]);
        max.setOptInputParameter(0, timePeriod);
        max.setOutputParameter(0, outsMax);
        max.calculate(startIndex, endIndex);
        
        min.setInputParameter(0, inputs[0]);
        min.setOptInputParameter(0, timePeriod);
        min.setOutputParameter(0, outsMin);
        min.calculate(startIndex, endIndex); 
        
       for (i = 0, j = 0; i < outputs[1].length; i++, j++) {
            PriceMax = outsMax[i]; 
            PriceMin = outsMin[i]; 
            Length = 0 ; 
            PriorDiff = 0 ; 
            for (int idx = 1; idx  < timePeriod; idx++)    
            {
                if (PriceMax - PriceMin > 0) 
                {
                    Diff = (inputs[0][idx] - PriceMin) / (PriceMax - PriceMin); 
                    if (idx > 1) Length = (Length + Math.sqrt( Math.pow((Diff - PriorDiff) + (1 / Math.pow(timePeriod,2)), 2))) ;  
                    PriorDiff = Diff  ;  
                }
            }
 
            if (Length > 0) FractalDI = 1 + ( Math.log( Length )+ Math.log( 2 ) ) / Math.log( 2 * ( timePeriod ) );
            else FractalDI = 0 ; 
            outputs[0][j] = FractalDI;  
            outputs[1][j] = medval;  
       }        

       return new IndicatorResult(startIndex, endIndex - startIndex + 1);
    }

    public IndicatorInfo getIndicatorInfo() {
        return indicatorInfo;
    }

    public InputParameterInfo getInputParameterInfo(int index) {
        if (index < inputParameterInfos.length) {
            return inputParameterInfos[index];
        }
        return null;
    }

    public int getLookback() {
     max.setOptInputParameter(0, timePeriod);
     min.setOptInputParameter(0, timePeriod);

     return Math.max(max.getLookback(), min.getLookback());        
    }

    public int getLookforward() {
        return 0;
    }

    public OptInputParameterInfo getOptInputParameterInfo(int index) {
        if (index < optInputParameterInfos.length) {
            return optInputParameterInfos[index];
        }
        return null;
    }

    public OutputParameterInfo getOutputParameterInfo(int index) {
        if (index < outputParameterInfos.length) {
            return outputParameterInfos[index];
        }
        return null;
    }

    public void setInputParameter(int index, Object array) {
        inputs[index] = (double[]) array;
    }

    public void setOptInputParameter(int index, Object value) {
       if(index==0) timePeriod = (Integer) value;
       if(index==1) medval     = (Double) value;
    }

    public void setOutputParameter(int index, Object array) {
        outputs[index] = (double[]) array;
    }
}