Inverse Fisher Transform of RSI

#property indicator_separate_window
#property indicator_buffers   8
#property indicator_color1    Goldenrod
#property indicator_color2    LimeGreen
#property indicator_color3    LimeGreen
#property indicator_color4    Red
#property indicator_color5    Red
#property indicator_color6    DeepSkyBlue
#property indicator_color7    PaleVioletRed
#property indicator_color8    DimGray
#property indicator_width1    2
#property indicator_width2    2
#property indicator_width3    2
#property indicator_width4    2
#property indicator_width5    2
#property indicator_style8    STYLE_DASH

#import "dynamicZone.dll"
   double dzBuy(double& sourceArray[],double probabiltyValue, int lookBack, int bars, int i);
   double dzSell(double& sourceArray[],double probabiltyValue, int lookBack, int bars, int i);
#import

extern string TimeFrame              = "Current time frame";
extern int    RsiPeriod              = 5;
extern int    RsiPrice               = PRICE_CLOSE;
extern string _rsimethods            = "0=rsi,1=wilder rsi,2=rsx,3=cuttler rsi ";
extern int    RsiMethod              = 0;
extern double SmoothLength           = 9;
extern double SmoothPhase            = 0;
extern bool   SmoothDouble           = false;
extern double PaFilter               = 1.0;
extern double PaCycles               = 2.0;
extern double DzStartBuyProbability  = 0.10;
extern double DzStartSellProbability = 0.10;
extern bool   Interpolate            = true;

extern bool   alertsOn               = true;
extern bool   alertsOnLeavingOsOb    = true;
extern bool   alertsOnEnteringOsOb   = true;
extern bool   alertsOnZeroLineCross  = true;
extern bool   alertsOnUpLevel1Cross  = true;
extern bool   alertsOnDnLevel1Cross  = true;
extern bool   alertsOnCurrent        = true;
extern bool   alertsMessage          = true;
extern bool   alertsSound            = false;
extern bool   alertsEmail            = false;

extern bool   arrowsVisible          = true;
extern string arrowsIdentifier       = "Dzift Arrows1";
extern double arrowsDisplacement     = 1.0;
extern color  arrowsUpColor          = LimeGreen;
extern color  arrowsDnColor          = Red;
extern bool   arrowsOnLeavingOsOb    = true;
extern bool   arrowsOnEnteringOsOb   = true;
extern bool   arrowsOnZeroLineCross  = true;
extern bool   arrowsOnUpLevel1Cross  = true;
extern bool   arrowsOnDnLevel1Cross  = true;

extern bool   LinesVisible           = false;
extern string verticalLinesID        = "DzIft lines1";
extern color  verticalLinesUpColor   = DeepSkyBlue;
extern color  verticalLinesDnColor   = PaleVioletRed;
extern int    verticalLinesStyle     = STYLE_DOT;
extern int    verticalLinesWidth     = 0;
extern bool   linesOnLeavingOsOb     = true;
extern bool   linesOnEnteringOsOb    = true;
extern bool   linesOnZeroLineCross   = true;
extern bool   linesOnUpLevel1Cross   = true;
extern bool   linesOnDnLevel1Cross  = true;

double ifishua[];
double ifishub[];
double ifishda[];
double ifishdb[];
double ifisher[];
double sli[];
double bli[];
double zli[];
double trends[][5];
#define _tup1 0
#define _tup2 1
#define _tdn1 2
#define _tdn2 3
#define _tmi1 4

string indicatorFileName;
bool   returnBars;
bool   calculateValue;
int    timeFrame;

int init()
{
      // код доступен только после оплаты
   }
int deinit()
{

   if (!calculateValue && LinesVisible)  deleteLines();
   if (!calculateValue && arrowsVisible) deleteArrows();

return(0);
}

double trend[];

int start()
{
      // код доступен только после оплаты
   }

double workHil[][9];
#define _price      0
#define _smooth     1
#define _detrender  2
#define _period     3
#define _instPeriod 4
#define _phase      5
#define _deltaPhase 6
#define _Q1         7
#define _I1         8

#define Pi 3.14159265358979323846264338327950288

double iHilbertPhase(double price, double filter, double cyclesToReach, int i, int s=0)
{
   if (ArrayRange(workHil,0)!=Bars) ArrayResize(workHil,Bars);
   int r = Bars-i-1; s = s*9;

      workHil[r][s+_price]      = price;
      workHil[r][s+_smooth]     = (4.0*workHil[r][s+_price]+3.0*workHil[r-1][s+_price]+2.0*workHil[r-2][s+_price]+workHil[r-3][s+_price])/10.0;
      workHil[r][s+_detrender]  = calcComp(r,_smooth,s);
      workHil[r][s+_Q1]         = 0.15*calcComp(r,_detrender,s)  +0.85*workHil[r-1][s+_Q1];
      workHil[r][s+_I1]         = 0.15*workHil[r-3][s+_detrender]+0.85*workHil[r-1][s+_I1];
      workHil[r][s+_phase]      = workHil[r-1][s+_phase];
      workHil[r][s+_instPeriod] = workHil[r-1][s+_instPeriod];

         if (MathAbs(workHil[r][s+_I1])>0)
                     workHil[r][s+_phase] = 180.0/Pi*MathArctan(MathAbs(workHil[r][s+_Q1]/workHil[r][s+_I1]));

         if (workHil[r][s+_I1]<0 && workHil[r][s+_Q1]>0) workHil[r][s+_phase] = 180.0-workHil[r][s+_phase];
         if (workHil[r][s+_I1]<0 && workHil[r][s+_Q1]<0) workHil[r][s+_phase] = 180.0+workHil[r][s+_phase];
         if (workHil[r][s+_I1]>0 && workHil[r][s+_Q1]<0) workHil[r][s+_phase] = 360.0-workHil[r][s+_phase];

      workHil[r][s+_deltaPhase] = workHil[r-1][s+_phase]-workHil[r][s+_phase];

         if (workHil[r-1][s+_phase]<90.0 && workHil[r][s+_phase]>270.0)
             workHil[r][s+_deltaPhase] = 360.0+workHil[r-1][s+_phase]-workHil[r][s+_phase];
             workHil[r][s+_deltaPhase] = MathMax(MathMin(workHil[r][s+_deltaPhase],60),7);

            double alpha    = 2.0/(1.0+MathMax(filter,1));
            double phaseSum = 0; for (int k=0; phaseSum<cyclesToReach*360.0 && (r-k)>0; k++) phaseSum += workHil[r-k][s+_deltaPhase];

               if (k>0) workHil[r][s+_instPeriod]= k;
                  workHil[r][s+_period] = workHil[r-1][s+_period]+alpha*(workHil[r][s+_instPeriod]-workHil[r-1][s+_period]);
   return (workHil[r][s+_period]);
}

double calcComp(int r, int from, int s)
{
   return((0.0962*workHil[r  ][s+from] + 
           0.5769*workHil[r-2][s+from] - 
           0.5769*workHil[r-4][s+from] - 
           0.0962*workHil[r-6][s+from]) * (0.075*workHil[r-1][s+_period] + 0.54));
}

void CleanPoint(int i,double& first[],double& second[])
{
   if ((second[i]  != EMPTY_VALUE) && (second[i+1] != EMPTY_VALUE))
        second[i+1] = EMPTY_VALUE;
   else
      if ((first[i] != EMPTY_VALUE) && (first[i+1] != EMPTY_VALUE) && (first[i+2] == EMPTY_VALUE))
          first[i+1] = EMPTY_VALUE;
}

void PlotPoint(int i,double& first[],double& second[],double& from[])
{
   if (first[i+1] == EMPTY_VALUE)
      {
         if (first[i+2] == EMPTY_VALUE) {
                first[i]   = from[i];
                first[i+1] = from[i+1];
                second[i]  = EMPTY_VALUE;
            }
         else {
                second[i]   =  from[i];
                second[i+1] =  from[i+1];
                first[i]    = EMPTY_VALUE;
            }
      }
   else
      {
         first[i]  = from[i];
         second[i] = EMPTY_VALUE;
      }
}

double getPrice(int type, int i)
{
   switch (type)
   {
      case 7:     return((Open[i]+Close[i])/2.0);
      case 8:     return((Open[i]+High[i]+Low[i]+Close[i])/4.0);
      default :   return(iMA(NULL,0,1,0,MODE_SMA,type,i));
   }      
}

string rsiMethodNames[] = {"rsi","wilders rsi","rsx","cuttler rsi"};
string getRsiName(int& method)
{
   int max = ArraySize(rsiMethodNames)-1;
      method=MathMax(MathMin(method,max),0); return(rsiMethodNames[method]);
}

double workRsi[][13];
#define _tprice  0
#define _change 1
#define _changa 2

double iRsi(double price, double period, int i, int instanceNo=0, int rsiMode=0)
{
   if (ArrayRange(workRsi,0)!=Bars) ArrayResize(workRsi,Bars);
      int z = instanceNo*13; 
      int r = Bars-i-1;

   workRsi[r][z+_tprice] = price;
   switch (rsiMode)
   {
      case 0:
         double alpha = 1.0/period; 
         if (r<period)
            {
               int k; double sum = 0; for (k=0; k<period && (r-k-1)>=0; k++) sum += MathAbs(workRsi[r-k][z+_tprice]-workRsi[r-k-1][z+_tprice]);
                  workRsi[r][z+_change] = (workRsi[r][z+_tprice]-workRsi[0][z+_tprice])/MathMax(k,1);
                  workRsi[r][z+_changa] =                                         sum/MathMax(k,1);
            }
         else
            {
               double change = workRsi[r][z+_tprice]-workRsi[r-1][z+_tprice];
                               workRsi[r][z+_change] = workRsi[r-1][z+_change] + alpha*(        change  - workRsi[r-1][z+_change]);
                               workRsi[r][z+_changa] = workRsi[r-1][z+_changa

Показано первые 50% кода (символов: 20449)