//+--------------------------------------------------------------------+
//| Copyright:  (C) 2014, Miroslav Popov - All rights reserved!        |
//| Website:    http://forexsb.com/                                    |
//| Support:    http://forexsb.com/forum/                              |
//| License:    Proprietary under the following circumstances:         |
//|                                                                    |
//| This code is a part of Forex Strategy Builder. It is free for      |
//| use as an integral part of Forex Strategy Builder.                 |
//| One can modify it in order to improve the code or to fit it for    |
//| personal use. This code or any part of it cannot be used in        |
//| another applications without a permission. Contact information     |
//| cannot be changed.                                                 |
//|                                                                    |
//| NO LIABILITY FOR CONSEQUENTIAL DAMAGES                             |
//|                                                                    |
//| In no event shall the author be liable for any damages whatsoever  |
//| (including, without limitation, incidental, direct, indirect and   |
//| consequential damages, damages for loss of business profits,       |
//| business interruption, loss of business information, or other      |
//| pecuniary loss) arising out of the use or inability to use this    |
//| product, even if advised of the possibility of such damages.       |
//+--------------------------------------------------------------------+

#property copyright "Copyright 2014, Miroslav Popov"
#property link      "http://forexsb.com"
#property version   "1.00"
#property strict

#include <Forexsb.com/Indicator.mqh>
#include <Forexsb.com/Enumerations.mqh>
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
class FractalDimensionIndex : public Indicator
  {
public:
                     FractalDimensionIndex(SlotTypes slotType)
     {
      SlotType=slotType;

      IndicatorName="Fractal Dimension Index";

      WarningMessage    = "";
      IsAllowLTF        = true;
      ExecTime          = ExecutionTime_DuringTheBar;
      IsSeparateChart   = true;
      IsDiscreteValues  = false;
      IsDeafultGroupAll = false;
     }

   virtual void      Calculate(DataSet &dataSet);
  };
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void FractalDimensionIndex::Calculate(DataSet &dataSet)
  {
   Data=GetPointer(dataSet);


// Reading the parameters
   BasePrice basePrice = (BasePrice)ListParam[2].Index;
   int       iPeriod   = (int)NumParam[0].Value;
   double    dLevel    = NumParam[1].Value;
   int       iPrvs     = (SlotType == SlotTypes_OpenFilter) ? 1 : 0;

//Calculation
   int iFirstBar=iPeriod+10;
   double adBasePrice[];
   Price(basePrice,adBasePrice);

   double adFractalDim[]; ArrayResize(adFractalDim,Data.Bars);ArrayInitialize(adFractalDim,0);
   double adUpperBand[];  ArrayResize(adUpperBand, Data.Bars);ArrayInitialize(adUpperBand,0);
   double adLowerBand[];  ArrayResize(adLowerBand, Data.Bars);ArrayInitialize(adLowerBand,0);
   double adLevel[];      ArrayResize(adLevel,Data.Bars);     ArrayInitialize(adLevel,0);

   double dPriceMax;
   double dPriceMin;
   double dDiff;
   double dPriorDiff;
   double dLength;
   double dVar;
   double dStdDev;
   double dMean;
   double dSum;
   double dDelta;

   for(int iBar=iFirstBar; iBar<Data.Bars; iBar++)
     {
      dPriceMax = DBL_MIN;
      dPriceMin = DBL_MAX;
      for(int iBack=0; iBack<iPeriod; iBack++)
        {
         if(adBasePrice[iBar-iBack]>dPriceMax)
            dPriceMax=adBasePrice[iBar-iBack];
         if(adBasePrice[iBar-iBack]<dPriceMin)
            dPriceMin=adBasePrice[iBar-iBack];
        }
      dPriorDiff=0;
      dLength=0;
      dSum=0;
      for(int iIteration=1; iIteration<iPeriod; iIteration++)
        {
         if(dPriceMax-dPriceMin>0)
           {
            dDiff=(adBasePrice[iIteration]-dPriceMin)/(dPriceMax-dPriceMin);
            if(iIteration>1)
              {
               dLength+=MathSqrt(MathPow(dDiff-dPriorDiff,2)+(1/MathPow(iPeriod,2)));
              }
            dPriorDiff=dDiff;
           }
        }
      if(dLength>0)
        {
         adFractalDim[iBar]=1+(MathLog(dLength)+MathLog(2))/MathLog(2*iPeriod);
         dMean=dLength/(iPeriod-1);
         for(int iIteration=1; iIteration<iPeriod; iIteration++)
           {
            if(dPriceMax-dPriceMin>0)
              {
               dDiff=(adBasePrice[iIteration]-dPriceMin)/(dPriceMax-dPriceMin);
               if(iIteration>1)
                 {
                  dDelta=MathSqrt(MathPow(dDiff-dPriorDiff,2)+(1/MathPow(iPeriod,2)));
                  dSum+=MathPow(dDelta-(dLength/(iPeriod-1)),2);
                 }
               dPriorDiff=dDiff;
              }
           }
         dVar=dSum/(MathPow(dLength,2)*MathPow(MathLog(2*(iPeriod-1)),2));
        }
      else
        {
         adFractalDim[iBar]=0;
         dVar=0;
        }
      dStdDev=MathSqrt(dVar);
      adUpperBand[iBar] = adFractalDim[iBar] + dStdDev;
      adLowerBand[iBar] = adFractalDim[iBar] - dStdDev;
      adLevel[iBar]=dLevel;
     }

// Saving the components

   ArrayResize(Component[0].Value,Data.Bars);
   Component[0].CompName   = "FDI";
   Component[0].DataType   = IndComponentType_IndicatorValue;
   Component[0].FirstBar   = iFirstBar;
   ArrayCopy(Component[0].Value,adFractalDim);

   ArrayResize(Component[1].Value,Data.Bars);
   Component[1].FirstBar=iFirstBar;

   ArrayResize(Component[2].Value,Data.Bars);
   Component[2].FirstBar=iFirstBar;

   ArrayResize(Component[3].Value,Data.Bars);
   Component[3].CompName   = "Upper Band";
   Component[3].DataType   = IndComponentType_IndicatorValue;
   Component[3].FirstBar   = iFirstBar;
   ArrayCopy(Component[3].Value,adUpperBand);

   ArrayResize(Component[4].Value,Data.Bars);
   Component[4].CompName   = "Lower Band";
   Component[4].DataType   = IndComponentType_IndicatorValue;
   Component[4].FirstBar   = iFirstBar;
   ArrayCopy(Component[4].Value,adLowerBand);

   ArrayResize(Component[5].Value,Data.Bars);
   Component[5].CompName   = "Level";
   Component[5].DataType   = IndComponentType_IndicatorValue;
   Component[5].FirstBar   = iFirstBar;
   ArrayCopy(Component[5].Value,adLevel);

// Sets the Component's type
   if(SlotType==SlotTypes_OpenFilter)
     {
      Component[1].DataType = IndComponentType_AllowOpenLong;
      Component[1].CompName = "Is long entry allowed";
      Component[2].DataType = IndComponentType_AllowOpenShort;
      Component[2].CompName = "Is short entry allowed";
     }
   else if(SlotType==SlotTypes_CloseFilter)
     {
      Component[1].DataType = IndComponentType_ForceCloseLong;
      Component[1].CompName = "Close out long position";
      Component[2].DataType = IndComponentType_ForceCloseShort;
      Component[2].CompName = "Close out short position";
     }

// Calculation of the logic
   IndicatorLogic indLogic=IndicatorLogic_It_does_not_act_as_a_filter;

   if(ListParam[0].Text=="The FDI rises")
     {
      indLogic=IndicatorLogic_The_indicator_rises;
     }
   else if(ListParam[0].Text=="The FDI falls")
     {
      indLogic=IndicatorLogic_The_indicator_falls;
     }
   else if(ListParam[0].Text=="The FDI is higher than the Level line")
     {
      indLogic=IndicatorLogic_The_indicator_is_higher_than_the_level_line;
     }
   else if(ListParam[0].Text=="The FDI is lower than the Level line")
     {
      indLogic=IndicatorLogic_The_indicator_is_lower_than_the_level_line;
     }
   else if(ListParam[0].Text=="The FDI crosses the Level line upward")
     {
      indLogic=IndicatorLogic_The_indicator_crosses_the_level_line_upward;
     }
   else if(ListParam[0].Text=="The FDI crosses the Level line downward")
     {
      indLogic=IndicatorLogic_The_indicator_crosses_the_level_line_downward;
     }
   else if(ListParam[0].Text=="The FDI changes its direction upward")
     {
      indLogic=IndicatorLogic_The_indicator_changes_its_direction_upward;
     }
   else if(ListParam[0].Text=="The FDI changes its direction downward")
     {
      indLogic=IndicatorLogic_The_indicator_changes_its_direction_downward;
     }

   NoDirectionOscillatorLogic(iFirstBar,iPrvs,adFractalDim,dLevel,Component[1],indLogic);
   ArrayCopy(Component[2].Value,Component[1].Value);
  }
//+------------------------------------------------------------------+