外汇EA编写教程：计算赫斯特指数

步骤 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("可用柱线太少了！尝试另一个时间帧。");
      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。换言之, 我们需要为 1000 找到超过 10 的分频数。有 11 个这样的分频数:

//--- 设置每个子群中的元素数
      num1=10;
      num2=20;
      num3=25;
      num4=40;
      num5=50;
      num6=100;
      num7=125;
      num8=200;
      num9=250;
      num10=500;
                  num11=1000;

由于我们要计算 RS 统计数据 11 次, 因此开发一个自定义函数是合理的。将要计算的 RS 统计数据子组的最终和初始索引, 以及所要分析的柱线数作为函数参数。算法完全类似于文章开头描述的算法。

//+----------------------------------------------------------------------+
//|  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 振幅和 S 偏差
   R=MaxValue-MinValue;                         //幅度是最大值和
   MaxValue=0.0; MinValue=1000;                 //最小值之间的差值
   S1=MathSqrt(DevSum/barscount);               //计算标准偏差
//--- 计算 R/S 参数
   if(S1!=0)RS=R/S1;                            //消除除零错误
// else Alert("除零！");
   return(RS);                                  //返回 RS 统计值
              }

使用 switch-case 语句计算。

   //--- 计算复合 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 |
//|                                    版权所有 2016, Piskarev D.M.    |
//|                                      piskarev.dmitry25@gmail.com |
//+------------------------------------------------------------------+
#property 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;
//+------------------------------------------------------------------+
//| 脚本的 start 函数                                                  |
//+------------------------------------------------------------------+
void OnStart()
  {
   double close[];                                              //声明动态收盘价格数组
   int copied=CopyClose(symbol,timeframe,0,1001,close);         //复制所选对的收盘价格至 
                                                                //close[] 数组 
   ArrayResize(close,1001);                                     //设置数组大小
   ArraySetAsSeries(close,true);
   if(bars<1001)                                                //为 1001 根历史柱线的存在创造一个条件
     {
         Comment("可用柱线太少了！尝试另一个时间帧。");
         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;                                      //初始和为零
   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 振幅和 S 偏差
   R=MaxValue-MinValue;                         //幅度是最大值和
   MaxValue=0.0; MinValue=1000;                 //最小值之间的差值
   S1=MathSqrt(DevSum/barscount);               //计算标准偏差
//--- 计算 R/S 参数
   if(S1!=0)RS=R/S1;                            //消除除零错误
// else Alert("除零！");
   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);
              }

您可以自行实现更广泛的计算功能并创建一个用户友好的图形界面来升级代码。 

在最后一个章节中, 我们将讨论现有的软件解决方案。