ステップ2 終値配列を設定して、1001のヒストリーバーが選択した通貨ペアにおいて利用可能かどうかを確認します。

   double close[];                                              //終値の動的配列を宣言
   int copied=CopyClose(symbol,timeframe,0,barscount1+1,close); //選択したペアの終値
                                                                //close[]配列 
   ArrayResize(close,1001);                                     //配列のサイズを設定
   ArraySetAsSeries(close,true);
   if(bars<1001)                                                //1001 ヒストリーの存在の条件を作成
     {
      Comment("Too few bars are available! Try another timeframe.");
      Sleep(10000);                                             //10 秒間遅らせる
      Comment("");
      return;
                 }

ステップ 3。 対数を返す配列を作成します。

LogReturns 配列が既に宣言され、ArrayResize(LogReturns,1001) の文字列があります。

for(int i=1;i<=1000;i++)
                    LogReturns[i]=MathLog(close[i-1]/close[i]);

ステップ 4。 ハースト指数を計算します。

ヒストリーバーの分析量の除算サブグループの要素の数が 10 未満ではない必要があります。 つまり、 10を超える値を持つ仕切りを検索する必要があります。 このような仕切りがあります。

//---各サブグループに含まれる要素の数を設定。
      num1=10;
      num2=20;
      num3=25;
      num4=40;
      num5=50;
      num6=100;
      num7=125;
      num8=200;
      num9=250;
      num10=500;
                  num11=1000;

11 回 RS 統計のデータのため、カスタム関数を開発するが妥当でしょう。 RSの統計情報の計算対象となる、サブグループの最終インデックスとして分析されたバーの数は、関数のパラメータとして使用されます。 このアルゴリズムは、記事の冒頭に記載されている1つに似ています。

//+----------------------------------------------------------------------+
// R/S 計算関数                                                           |       
//+----------------------------------------------------------------------+
double RSculc(int bottom,int top,int barscount)
  {
   Sum=0.0;                                      //初期の和はゼロ
   DevSum=0.0;                                   //累積合計
                                                 //偏差ゼロ  
//---リターンの合計を計算。
   for(int i=bottom; i<=top; i++)
      Sum=Sum+LogReturns[i];                     //合計
//---平均を計算。
   M=Sum/barscount;
//---累積偏差を計算。
   for(int i=bottom; i<=top; i++)
     {
      DevAccum[i]=LogReturns[i]-M+DevAccum[i-1];
      StdDevMas[i]=MathPow((LogReturns[i]-M),2);
      DevSum=DevSum+StdDevMas[i];               //偏差の計算コンポーネント
      if(DevAccum[i]>MaxValue)                  //配列の値が小さい場合
         MaxValue=DevAccum[i];                  //最大よりも。DevAccum 配列の要素の値に割り当てられて
                                                //最大値 
      if(DevAccum[i]<MinValue)                  //ロジックが同一
         MinValue=DevAccum[i];
     }
//---R の振幅との偏差を計算。
   R=MaxValue-MinValue;                         //振幅が最大の違い
   MaxValue=0.0; MinValue=1000;                 //最小値
   S1=MathSqrt(DevSum/barscount);               //標準偏差を計算
//---R/S パラメータを計算。
   if(S1!=0)RS=R/S1;                            //ゼロ除算エラーを排除
// else Alert("Zero divide!");
   return(RS);                                  //RS の統計値を返す
              }

スイッチ ケースを使用して計算。

   //---複合 Log(R/S) を計算。
      for(int A=1; A<=11; A++)                        //サイクルで、コードを短くすることができます
        {                                             //その上、すべての可能な仕切りを考える
         switch(A)
           {
            case 1:                                   //100 グループ含んでいる 10 要素
              {
               ArrayResize(rs1,101);
               RSsum=0.0;
               for(int j=1; j<=100; j++)
                 {
                  rs1[j]=RSculc(10*j-9,10*j,10);      //RScuclc のカスタム関数を呼び出す
                  RSsum=RSsum+rs1[j];
                 }
               RS1=RSsum/100;
               LogRS1=MathLog(RS1);
              }
            break;
            case 2:                                   //50 グループ含む 20 要素
              {
               ArrayResize(rs2,51);
               RSsum=0.0;
               for(int j=1; j<=50; j++)
                 {
                  rs2[j]=RSculc(20*j-19,20*j,20);     //RScuclc のカスタム関数を呼び出す
                  RSsum=RSsum+rs2[j];
                 }
               RS2=RSsum/50;
               LogRS2=MathLog(RS2);
              }
            break;
...
...
...
            case 9: //125 と 16 のグループ
              {
               ArrayResize(rs9,5);
               RSsum=0.0;
               for(int j=1; j<=4; j++)
                 {
                  rs9[j]=RSculc(250*j-249,250*j,250);
                  RSsum=RSsum+rs9[j];
                 }
               RS9=RSsum/4;
               LogRS9=MathLog(RS9);
              }
            break;
            case 10: //125 と 16 のグループ
              {
               ArrayResize(rs10,3);
               RSsum=0.0;
               for(int j=1; j<=2; j++)
                 {
                  rs10[j]=RSculc(500*j-499,500*j,500);
                  RSsum=RSsum+rs10[j];
                 }
               RS10=RSsum/2;
               LogRS10=MathLog(RS10);
              }
            break;
            case 11: //200 と 10 のグループ
              {
               RS11=RSculc(1,1000,1000);
               LogRS11=MathLog(RS11);
              }
            break;
           }
                    }

ステップ 5。 最小自乗 (LS) 法を用いた線形回帰を計算するカスタム関数。

エントリーパラメータは、計算された RS 統計コンポーネントの値です。

double RegCulc1000(double Y1,double Y2,double Y3,double Y4,double Y5,double Y6,
                   double Y7,double Y8,double Y9,double Y10,double Y11)
  {
   double SumY=0.0;
   double SumX=0.0;
   double SumYX=0.0;
   double SumXX=0.0;
   double b=0.0; 
   double N[];                                                    //ディバイダーの対数を格納する配列
   double n={10,20,25,40,50,100,125,200,250,500,1000}             //ディバイダー配列
//---N 比を計算。
   for (int i=0; i<=10; i++)
     {
       N[i]=MathLog(n[i]);
       SumX=SumX+N[i];
       SumXX=SumXX+N[i]*N[i];
     }
   SumY=Y1+Y2+Y3+Y4+Y5+Y6+Y7+Y8+Y9+Y10+Y11;
   SumYX=Y1*N1+Y2*N2+Y3*N3+Y4*N4+Y5*N5+Y6*N6+Y7*N7+Y8*N8+Y9*N9+Y10*N10+Y11*N11;
//---ベータ回帰率または必要なハースト指数を計算。 
   b=(11*SumYX-SumY*SumX)/(11*SumXX-SumX*SumX);
   return(b);
              }

ステップ 6.予想される RS 統計値を計算するカスタム関数。 計算ロジックは、理論パートで説明します。

//+----------------------------------------------------------------------+
// 計算する関数は、E(R/S) 値を予想                                          |       
//+----------------------------------------------------------------------+
double ERSculc(double m)                 //m-1000 ディバイダー
  {
   double e;
   double nSum=0.0;
   double part=0.0;
   for(int i=1; i<=m-1; i++)
     {
      part=MathPow(((m-i)/i), 0.5);
      nSum=nSum+part;
     }
   e=MathPow((m*pi/2),-0.5)*nSum;
   return(e);
              }

プログラム コードは、次のようになります。

//+------------------------------------------------------------------+
//                                              hurst_exponent.mq5   |
//|                                    Copyright 2016, Piskarev D.M. |
//|                                      piskarev.dmitry25@gmail.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2016, Piskarev D.M."
#property link      "piskarev.dmitry25@gmail.com"
#property version   "1.00"
#property script_show_inputs
#property strict
input    string  symbol="EURUSD";  //シンボル
input    ENUM_TIMEFRAMES timeframe=PERIOD_D1; //期間
double   LogReturns[],N[],
         R,S1,DevAccum[],StdDevMas[];
int      num1,num2,num3,num4,num5,num6,num7,num8,num9,num10,num11;
double   pi=3.14159265358979323846264338;
double   MaxValue=0.0,MinValue=1000.0;
double   DevSum,Sum,M,RS,RSsum,Dconv;
double   RS1,RS2,RS3,RS4,RS5,RS6,RS7,RS8,RS9,RS10,RS11,
         LogRS1,LogRS2,LogRS3,LogRS4,LogRS5,LogRS6,LogRS7,LogRS8,LogRS9,
         LogRS10,LogRS11;
double   rs1[],rs2[],rs3[],rs4[],rs5[],rs6[],rs7[],rs8[],rs9[],rs10[],rs11[];
double   E1,E2,E3,E4,E5,E6,E7,E8,E9,E10,E11;
double   H,betaE;
int      bars=Bars(symbol,timeframe);
double   D,StandDev;
//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
   double close[];                                              //終値の動的配列を宣言
   int copied=CopyClose(symbol,timeframe,0,1001,close);         //コピーする選択したペアの終値
                                                                //close[]配列 
   ArrayResize(close,1001);                                     //配列のサイズを設定
   ArraySetAsSeries(close,true);
   if(bars<1001)                                                //1001 ヒストリーバーの存在の条件を作成する
     {
         Comment("Too few bars are available! Try another timeframe.");
         Sleep(10000);                                          //10 秒間遅らせる
         Comment("");
         return;
     }
//+------------------------------------------------------------------+
//配列の準備                                                          |
//+------------------------------------------------------------------+        
   ArrayResize(LogReturns,1001);
   ArrayResize(DevAccum,1001);
   ArrayResize(StdDevMas,1001);
//+------------------------------------------------------------------+
//対数を返す配列                                                       |
//+------------------------------------------------------------------+
   for(int i=1;i<=1000;i++)
      LogReturns[i]=MathLog(close[i-1]/close[i]);
//+------------------------------------------------------------------+
//                                                                   |
//                         R/S 解析                                  |
//                                                                   |
//+------------------------------------------------------------------+
//---各サブグループに含まれる要素の数を設定。
   num1=10;
   num2=20;
   num3=25;
   num4=40;
   num5=50;
   num6=100;
   num7=125;
   num8=200;
   num9=250;
   num10=500;
   num11=1000;
//---複合 Log(R/S) を計算。
   for(int A=1; A<=11; A++)
     {
      switch(A)
        {
         case 1:
           {
            ArrayResize(rs1,101);
            RSsum=0.0;
            for(int j=1; j<=100; j++)
              {
               rs1[j]=RSculc(10*j-9,10*j,10);
               RSsum=RSsum+rs1[j];
              }
            RS1=RSsum/100;
            LogRS1=MathLog(RS1);
           }
         break;
         case 2:
           {
            ArrayResize(rs2,51);
            RSsum=0.0;
            for(int j=1; j<=50; j++)
              {
               rs2[j]=RSculc(20*j-19,20*j,20);
               RSsum=RSsum+rs2[j];
              }
            RS2=RSsum/50;
            LogRS2=MathLog(RS2);
           }
         break;
         case 3:
           {
            ArrayResize(rs3,41);
            RSsum=0.0;
            for(int j=1; j<=40; j++)
              {
               rs3[j]=RSculc(25*j-24,25*j,25);
               RSsum=RSsum+rs3[j];
              }
            RS3=RSsum/40;
            LogRS3=MathLog(RS3);
           }
         break;
         case 4:
           {
            ArrayResize(rs4,26);
            RSsum=0.0;
            for(int j=1; j<=25; j++)
              {
               rs4[j]=RSculc(40*j-39,40*j,40);
               RSsum=RSsum+rs4[j];
              }
            RS4=RSsum/25;
            LogRS4=MathLog(RS4);
           }
         break;
         case 5:
           {
            ArrayResize(rs5,21);
            RSsum=0.0;
            for(int j=1; j<=20; j++)
              {
               rs5[j]=RSculc(50*j-49,50*j,50);
               RSsum=RSsum+rs5[j];
              }
            RS5=RSsum/20;
            LogRS5=MathLog(RS5);
           }
         break;
         case 6:
           {
            ArrayResize(rs6,11);
            RSsum=0.0;
            for(int j=1; j<=10; j++)
              {
               rs6[j]=RSculc(100*j-99,100*j,100);
               RSsum=RSsum+rs6[j];
              }
            RS6=RSsum/10;
            LogRS6=MathLog(RS6);
           }
         break;
         case 7:
           {
            ArrayResize(rs7,9);
            RSsum=0.0;
            for(int j=1; j<=8; j++)
              {
               rs7[j]=RSculc(125*j-124,125*j,125);
               RSsum=RSsum+rs7[j];
              }
            RS7=RSsum/8;
            LogRS7=MathLog(RS7);
           }
         break;
         case 8:
           {
            ArrayResize(rs8,6);
            RSsum=0.0;
            for(int j=1; j<=5; j++)
              {
               rs8[j]=RSculc(200*j-199,200*j,200);
               RSsum=RSsum+rs8[j];
              }
            RS8=RSsum/5;
            LogRS8=MathLog(RS8);
           }
         break;
         case 9:
           {
            ArrayResize(rs9,5);
            RSsum=0.0;
            for(int j=1; j<=4; j++)
              {
               rs9[j]=RSculc(250*j-249,250*j,250);
               RSsum=RSsum+rs9[j];
              }
            RS9=RSsum/4;
            LogRS9=MathLog(RS9);
           }
         break;
         case 10:
           {
            ArrayResize(rs10,3);
            RSsum=0.0;
            for(int j=1; j<=2; j++)
              {
               rs10[j]=RSculc(500*j-499,500*j,500);
               RSsum=RSsum+rs10[j];
              }
            RS10=RSsum/2;
            LogRS10=MathLog(RS10);
           }
         break;
         case 11:
           {
            RS11=RSculc(1,1000,1000);
            LogRS11=MathLog(RS11);
           }
         break;
        }
     }
//+----------------------------------------------------------------------+
// ハースト指数の計算                                                      |       
//+----------------------------------------------------------------------+
   H=RegCulc1000(LogRS1,LogRS2,LogRS3,LogRS4,LogRS5,LogRS6,LogRS7,LogRS8,
                 LogRS9,LogRS10,LogRS11);
//+----------------------------------------------------------------------+
//         期待の log(E(R/S)) 値を計算                                     |       
//+----------------------------------------------------------------------+
   E1=MathLog(ERSculc(num1));
   E2=MathLog(ERSculc(num2));
   E3=MathLog(ERSculc(num3));
   E4=MathLog(ERSculc(num4));
   E5=MathLog(ERSculc(num5));
   E6=MathLog(ERSculc(num6));
   E7=MathLog(ERSculc(num7));
   E8=MathLog(ERSculc(num8));
   E9=MathLog(ERSculc(num9));
   E10=MathLog(ERSculc(num10));
   E11=MathLog(ERSculc(num11));
//+----------------------------------------------------------------------+
// 期待の E(R/S) 値のベータを計算                                           |
//+----------------------------------------------------------------------+  
   betaE=RegCulc1000(E1,E2,E3,E4,E5,E6,E7,E8,E9,E10,E11);
   Alert("H= ", DoubleToString(H,3), " , E= ",DoubleToString(betaE,3));
   Comment("H= ", DoubleToString(H,3), " , E= ",DoubleToString(betaE,3));
}
//+----------------------------------------------------------------------+
// R/S 計算関数                                                           |       
//+----------------------------------------------------------------------+
double RSculc(int bottom,int top,int barscount)
  {
   Sum=0.0;                                      //最初の合計値は 0
   DevSum=0.0;                                   //累積合計
                                                 //偏差ゼロ  
//---リターンの合計を計算。
   for(int i=bottom; i<=top; i++)
      Sum=Sum+LogReturns[i];                     //合計
//---平均を計算。
   M=Sum/barscount;
//---累積偏差を計算。
   for(int i=bottom; i<=top; i++)
     {
      DevAccum[i]=LogReturns[i]-M+DevAccum[i-1];
      StdDevMas[i]=MathPow((LogReturns[i]-M),2);
      DevSum=DevSum+StdDevMas[i];               //偏差の計算コンポーネント
      if(DevAccum[i]>MaxValue)                  //配列の値が小さい場合
         MaxValue=DevAccum[i];                  //最大よりも。DevAccum 配列の要素の値に割り当てられて
                                                //最大値 
      if(DevAccum[i]<MinValue)                  //ロジックが同一
         MinValue=DevAccum[i];
     }
//---R の振幅との偏差を計算。
   R=MaxValue-MinValue;                         //振幅が最大の違い
   MaxValue=0.0; MinValue=1000;                 //最小値
   S1=MathSqrt(DevSum/barscount);               //標準偏差を計算
//---R/S パラメータを計算。
   if(S1!=0)RS=R/S1;                            //ゼロ除算エラーを排除
// else Alert("Zero divide!");
   return(RS);                                  //RS の統計値を返す
  }
//+----------------------------------------------------------------------+
// 回帰計算機                                                             |       
//+----------------------------------------------------------------------+  
double RegCulc1000(double Y1,double Y2,double Y3,double Y4,double Y5,double Y6,
                   double Y7,double Y8,double Y9,double Y10,double Y11)
  {
   double SumY=0.0;
   double SumX=0.0;
   double SumYX=0.0;
   double SumXX=0.0;
   double b=0.0;                                                  //ディバイダーの対数を格納する配列
   double n[]={10,20,25,40,50,100,125,200,250,500,1000};          //ディバイダー配列
//---N 比を計算。
   ArrayResize(N,11);
   for (int i=0; i<=10; i++)
     {
       N[i]=MathLog(n[i]);
       SumX=SumX+N[i];
       SumXX=SumXX+N[i]*N[i];
     }
   SumY=Y1+Y2+Y3+Y4+Y5+Y6+Y7+Y8+Y9+Y10+Y11;
   SumYX=Y1*N[0]+Y2*N[1]+Y3*N[2]+Y4*N[3]+Y5*N[4]+Y6*N[5]+Y7*N[6]+Y8*N[7]+Y9*N[8]+Y10*N[9]+Y11*N[10];
//---ベータ回帰率または必要なハースト指数を計算。 
   b=(11*SumYX-SumY*SumX)/(11*SumXX-SumX*SumX);
   return(b);
  }
//+----------------------------------------------------------------------+
// 計算する関数は、E(R/S) 値を予想                                          |       
//+----------------------------------------------------------------------+
double ERSculc(double m)                 //m-1000 ディバイダー
  {
   double e;
   double nSum=0.0;
   double part=0.0;
   for(int i=1; i<=m-1; i++)
     {
      part=MathPow(((m-i)/i), 0.5);
      nSum=nSum+part;
     }
   e=MathPow((m*pi/2),-0.5)*nSum;
   return(e);
              }

ユーザーフレンドリーなグラフィカルインターフェイスを作成することによって、自分のコードをアップグレードできます。 

最後のチャプターでは、既存のソフトウェア ・ ソリューションについて説明します。