基于艾略特波浪理论的交易策略

Forex Trader 2006.03.14 12:19 #91

基本上，它是这样的。Hurst比率是为每个通道计算的，主要是确保其中的条数超过一定的值，例如30 - Òôô并不重要，因为我们从3-5-7天的日通道计算（一切取决于你想得到的准确性 - 一天的收集可能不稳定） - 日内条数就足够了）。也只有这样，我们才会对这个渠道是否适合预测和构建反转区的预测做出结论。根据不同渠道的Murray，一个相同的逆转水平将处于不同的置信区间--你需要以某种方式将其切断，不是吗？而质量标准是势能--见关于二次形式--没有什么不寻常的。

我不打算分享已完成的解决方案，但方法论--请不要有问题。

好运和快乐的趋势。

Forex Trader 2006.03.14 13:47 #92

<br / translate="no"> 而且我不打算分享DIRECT解决方案，但方法论--没问题。

总的来说，这很清楚。一切都像在论文中一样。什么都有，除了那个简单的计划，没有这个计划，什么都不会成功;o)!而原理图只有发明它的人知道，其他没有原理图的东西都是纸上谈兵，而纸上谈兵的东西就在身边。不过请注意，我只是在陈述一个事实，没有任何其他意思。反正每个人都要骑自己的自行车。这毕竟是外汇！)

这里还有一个问题。所有这些都是在什么基础上实施的？在MT4上？
就是说，MT4有你提到的Murray指标。这很清楚。
但你用什么来计算渠道和赫斯特？你也使用MT4吗？你曾经提到代码大小为0.5M。你这话是什么意思？mql4上的计算程序文本的重量？如果是这样，坦率地说，我很难想象这样的量。因为，根据我的保守估计，这样一个程序的文本应该有10000行左右。我使用的一个简单的白噪声策略只需要1000行，尽管我只是平行启动6个交易线程，使用来自不同时间段的信息，将这些代码的片段保留在目前的形式比使用数组将其转化为400-500行更容易（更便于进一步修改）（尽管这样的计划在未来也是可能的）。也就是说，按一个时间段运行一个线程将需要400-500行。我使用的是一个功能齐全的专家顾问，不需要被监控。当然，我不拒绝它的进一步改进，但到目前为止，我已经在测试器中优化了所有可以优化的地方。但对你的方法有一定的兴趣，我将尝试应用一些东西，当然，如果我成功的话。

PS：我不是用一个大手的交易线，而是在不同时间段用小手的几个平行线，这完全是因为在这种交易中出现了类似最大跌幅过滤效应的事实。也就是说，如果你有几个随机过程（一个线程的余额动态），那么当把一个账户中的余额相加时，最大缩水将等于每个线程的缩水之和除以线程数的平方根，而不是每个线程的缩水之和！因此，我试图减少总的最大缩水。也就是说，如果你有6个线程，每个线程在1.5年的历史上缩减50美元，从逻辑上讲，6个线程的总缩减量应该是300美元，但实际上，这个数额应该除以6的平方根=2.45。这大致是测试器显示的情况。测试仪显示，你应该除以约2.2。我认为这与我减少最大缩水的想法很一致。

Forex Trader 2006.03.14 14:19 #93

一般来说，你可以想出你自己的 "电路"，我不能说这很容易，但只有这样你才会明白它是如何工作的，以及如何（以及为什么确切地、没有其他方式）解释信号。关于代码：我是用MKL4写的--它和C/C++非常相似，我已经用C/C++编程很长时间了，尽管它很慢--我会把所有东西重新编译成C++。关于程序的大小，其实并不大：0.5M是一个编译程序的大小，也就是一个.ex4文件的大小。你的行数有点错了--总共大约6000行--大部分都在函数、循环和多维数组中，所以如果你只是扩大它，我甚至无法想象:) .....

好运和良好的趋势。

Forex Trader 2006.03.14 15:08 #94

Hi Vladislav !

我不使用平滑算法--它们都落后了）。好运。

我不同意你的说法。只有当你决定分享你的经验和想法时，这个主题才变得有趣。

作为一个物理学家，我了解关于领域、潜能等的一切。所有的优化也很清楚--这是一个非难事和有趣的问题。至于数学统计，我只能笼统地掌握它的内容，唉。但这个主题很有意思。特别是在先验估计的显著性水平和非随机预测的可能性的部分。

我的方法（到目前为止）主要是围绕定义趋势性市场时期。我没有以上述文章中给出的形式使用赫斯特指数，也没有以任何其他方式使用。然而，我也试图依靠有我自己的计算算法的市场断裂性的措施。反趋势期可以和趋势期一样使用的想法，让我完全感到惊讶。有时甚至很难看到隐藏在下面的东西。:-)

因此，我很乐意继续对话，如果不在这个论坛上，那就通过你在Murray级别指标中给出的电子邮件，或在私人信息中的蜘蛛上。

无论如何，我想说：你的工作给我留下了深刻的印象!我第一次看到的不是业余爱好者（包括我自己）的 "形象思维 "的工作，而是数学家手中的数学。
我特别喜欢这句话：

...自2006年1月以来，我设法得到了解决方法，在任何数据源上都能给出相同的水平和反转区域的边界，也就是在任何DC上，尽管报价有一些差异，同时我不使用平滑算法--它们都滞后。

在不同的数据流上收敛结果，并且不使用平滑处理，意味着你的方法论已经达到了过程的本质 !

Forex Trader 2006.03.14 15:35 #95

所以我很愿意继续对话，如果不在这个论坛上，那就通过你在Murray级别指标中给出的电子邮件，或者在蜘蛛上私下进行对话。<br/ translate="no">

没问题 .

在不同的数据流上收敛结果，并且不使用平滑处理，意味着你的方法论已经达到了过程的本质 !

我想说得更谦虚一点--这意味着数学统计学方法是有效的--它们只需要被正确应用，而且仍然有许多TA的方法是有道理的。(即市场上存在着预先确定的运动区域)。定性方法，如艾略特或江恩，尽管正如我写的那样--由于缺乏定量估计，我不太喜欢艾略特。总之，祝你好运，趋势良好。寻找McCormick的 "交易策略百科全书 "和Bulashev的

"交易员统计"--在应用意义上非常有用--展示了方法的逻辑。

Forex Trader 2006.03.14 17:48 #96

我饶有兴趣地阅读了你的讨论，更有兴趣的是，由于我的专业职业，所使用的方法与我相当接近。请允许我做一个小小的贡献。

我不使用平滑算法--它们都是滞后的。

试试带衍射核的DCT变换--它的平滑度非常好，一点也不滞后。IMHO，它比传统的LCF效果更好。下面是一些C++代码的片段。使用方法，我想从评论中可以看出。

//*************************************************************************//
/////////////////////////////////////////////////////////////////////////////
//+-----------------------------------------------------------------------+//
//| Прямое дискретное косинус-преобразование (DCT) x[] --> y[]            |//
//+-----------------------------------------------------------------------+//
/////////////////////////////////////////////////////////////////////////////
/*
   Входные глобальные переменные:
 double x[]           // входной массив
   Входные локальные переменные:
 int    n_bars        // полное число баров для DCT-преобразования
   Выходные локальные переменные: нет
   Выходные глобальные переменные:
 double y[]           // массив гармоник
*/
void DCT(int n_bars, double x [], double y [])
{ 
 int k;                                // счетчик строк матрицы коэффициентов
 int n;                             // счетчик столбцов матрицы коэффициентов
 double sum;                                                    // накопитель
 double PIN2 = PI / (n_bars * 2.0);
 double wgt_zero = 1.0 / sqrt(n_bars);            // вес при 0-м коэффициенте
 double wgt_nzero = sqrt(2.0) * wgt_zero;           // вес при всех остальных
 //----
 // dct-преобразование
 for (k = 0; k < n_bars; k++)
 {                                                               // цикл по k
  sum = 0.0;                                           // обнуляем накопитель
  for (n = 0; n < n_bars; n++)
  { sum += x[n] * cos(PIN2 * (2.0 * n + 1.0) * k); }             // цикл по n
   if (k != 0)
   { y[k] = wgt_nzero * sum; } 
   else
   { y[k] = wgt_zero  * sum; }
  }                                                              // цикл по k
 //----
 return;
} 
//
//*************************************************************************//
/////////////////////////////////////////////////////////////////////////////
//+-----------------------------------------------------------------------+//
//| Обратное дискретное косинус-преобразование (IDCT) y[] --> x[]         |//
//+-----------------------------------------------------------------------+//
/////////////////////////////////////////////////////////////////////////////
/*
   Входные глобальные переменные:
 double y[]           // массив гармоник
   Входные локальные переменные:
 int    n_bars        // полное число баров для DCT-преобразования
   Выходные локальные переменные: нет
   Выходные глобальные переменные:
 double x[]           // выходной массив
*/
void IDCT(int n_bars, double x [], double y [])
{ 
 int k;                                // счетчик строк матрицы коэффициентов
 int n;                             // счетчик столбцов матрицы коэффициентов
 double sum;                                                    // накопитель
 double PIN2 = PI / (n_bars * 2.0);
 double wgt_zero = 1.0 / sqrt(n_bars);            // вес при 0-м коэффициенте
 double wgt_nzero = sqrt(2.0) * wgt_zero;           // вес при всех остальных
 //----
 // idct-преобразование
 for (n = 0; n < n_bars; n++)
 {                                                               // цикл по n
  sum = 0.0;                                           // обнуляем накопитель
  for (k = 0; k < n_bars; k++)
  {                                                              // цикл по k
   if (k != 0)
   { sum += wgt_nzero * y[k] * cos(PIN2 * (2.0 * n + 1.0) * k); }
   else
   { sum += wgt_zero  * y[k] * cos(PIN2 * (2.0 * n + 1.0) * k); }
  }                                                              // цикл по k
    x[n] = sum;
 }                                                               // цикл по n
 //----
 return;
} 
//
//*************************************************************************//
/////////////////////////////////////////////////////////////////////////////
//+-----------------------------------------------------------------------+//
//| Вычисление левой части уравнения y[] --> y[] (диффракционное ядро)    |//
//+-----------------------------------------------------------------------+//
/////////////////////////////////////////////////////////////////////////////
/*
   Входные глобальные переменные:
 double y[]            // массив гармоник
   Входные локальные переменные:
 int    n_bars         // полное число баров для расчета
 double eye            // размер "окна"
 double alfa           // параметр регуляризации
   Выходные локальные переменные: нет
   Выходные глобальные переменные:
 double y[]            // массив значений левой части уравнения 
*/
void GetDiffrLeftSide(int n_bars, double eye, double alfa, double y []) 
{
 double kern;   //
 double omega;  //
 double domega; //
 double omega2; // 1 + omega^2
 double delta = 2.0 * PI / (n_bars - 1);
 int i;
 //----
 for (i = 0; i < n_bars; i++)
 {
  omega  = i * delta;
  domega = omega * eye;
  omega2 = 1.0 + omega * omega;                  // 1. + omega^2
  kern   = (sin(domega) + EPS) / (domega + EPS); // sin(arg)/arg
  y[i]  = (kern * y[i]) / (kern * kern + alfa * omega2);
 }
 //----
 return;
}
//
//*************************************************************************//
/////////////////////////////////////////////////////////////////////////////
//+-----------------------------------------------------------------------+//
//| Линейное сглаживание массива x[] по 5 точкам; результат - y[]         |//
//+-----------------------------------------------------------------------+//
/////////////////////////////////////////////////////////////////////////////
/*
   Входные глобальные переменные:
 double x[]    // входной массив - аргумент;
   Входные локальные переменные:
 int    n_beg  // номер начального бара
 int    n_end  // номер конечного бара
   Выходные локальные переменные: нет
   Выходные глобальные переменные:   
 double y[]    // выходной массив - ответ;
*/
void GetSmooth5(int n_beg, int n_end, double x [], double y [])
{ 
 int i;
 //----
 y[n_beg] = (3.0 * x[n_beg] + 2.0 * x[n_beg+1] + 
                                    x[n_beg+2] - x[n_beg+4]) / 5.0;
 y[n_beg+1] = (4.0 * x[n_beg] + 3.0 * x[n_beg+1] + 
                                2.0 * x[n_beg+2] + x[n_beg+3]) / 10.0;
 for (i = n_beg + 2; i < n_end - 2; i++)
 { y[i] = (x[i-2] + x[i-1] + x[i] + x[i+1] + x[i+2]) / 5.0; }
 y[n_end-2] = (x[n_end-4] + 2.0 * x[n_end-3] + 
                            3.0 * x[n_end-2] + 4.0 * x[n_end-1]) / 10.0;
 y[n_end-1] = (3.0 * x[n_end-1] + 2.0 * x[n_end-2] + 
                                        x[n_end-3] - x[n_end-5]) / 5.0;
 //----
 return;
} 
//

而这是应用的方法。

//
//*************************************************************************//
/////////////////////////////////////////////////////////////////////////////
//+-----------------------------------------------------------------------+//
//| Сглаживание методом DCT-преобразования (без запаздывания)             |//
//+-----------------------------------------------------------------------+//
/////////////////////////////////////////////////////////////////////////////
/*
   Входные глобальные переменные:
 double x[]     // несглаженный массив значений аргумента (цена);
   Входные локальные переменные:
 int    n_bars  // полное число баров для преобразования
 double eye     // размер "окна"
 double alfa    // параметр регуляризации 
   Выходные локальные переменные: 
 int nn_tot     // число сглаженных баров
   Выходные глобальные переменные:
 double x[]     // ответ - сглаженный массив значений аргумента;
*/
MT4_EXPFUNC int __stdcall GetDiffrDCTS (int nn_tot, double eye,  double alfa,
                                                                 double x [])
{
 int err_code = 0;                                              // код ошибки
 int i;                                                            // счетчик
 //
 // ########################### Error Definitions ###########################
 // *** Ошибка: если превышено максимальное число баров, выход ***
 if (nn_tot > NN_MAX) 
 { 
	 err_code = -1;
	 return(err_code); 
 } 
 // *** Ошибка: для преобразования задано слишком мало баров, выход ***
 if (nn_tot < NN_MIN) 
 {  
	 err_code = -2;
	 return(err_code); 
 }  
 // *** Ошибка: параметр alfa = 0 при eye <> 0, выход ***
 if ((alfa == 0.0) && (eye != 0.0)) 
 {  
	 err_code = -3;
	 return(err_code); 
 }  
 // *** Ошибка: параметр eye_size < 0, выход ***
 if (eye < 0.0) 
 {  
	 err_code = -4;
	 return(err_code); 
 }  
 // *** Ошибка: параметр eye_alfa < 0, выход ***
 if (alfa < 0.0) 
 { 
	 err_code = -5;
	 return(err_code); 
 }  
 // #########################################################################
 //
 //----
 //
 DCT (nn_tot, x, y);                                           // x[] --> y[]
 GetDiffrLeftSide (nn_tot, eye, alfa, y);                      // y[] --> y[]
 IDCT (nn_tot, x, y);                                          // y[] --> x[]
 GetSmooth5 (0, nn_tot, x, y);                                 // x[] --> y[]
 for (i = 0; i < nn_tot; i++) { x[i] = y[i]; }                 // y[] --> x[]

 //
 //----
 err_code = nn_tot;
 return(err_code);
}
//

例如，尝试一下参数Eye = 2.5，Alfa = 0.5。一定要记住，组合（Eye !=0, Alfa ==0）是不允许的。EPS是用来避免像0/0这样的不确定性的。我认为EPS=1.0E-09。
平滑化的数组必须被规范化为nn_tot条上的价格变化范围。

//
/////////////////////////////////////////////////////////////////////////////
//+-----------------------------------------------------------------------+//
//| Нормировка результов вычислений на заданный диапазон значений         |//
//+-----------------------------------------------------------------------+//
/////////////////////////////////////////////////////////////////////////////
/*
   Входные глобальные переменные:
 double x[]    // неномированный массив значений аргумента;
   Входные локальные переменные:
 int    n_beg  // номер начального бара
 int    n_end  // номер конечного бара
 double v_max  // максимальное значение диапазона для нормировки;
 double v_min  // минимальное значение диапазона для нормировки;
   Выходные локальные переменные: нет
   Выходные глобальные переменные:
 double x[]    // ответ - нормированный массив значений аргумента;
*/
MT4_EXPFUNC int __stdcall NormRange(int n_beg, int n_end, 
                                    double v_max, double v_min, double x [])
{ 
 int    err_code = 0;                              // возвращаемый код ошибки
 double x_max;                 // максимальное значение в нормируемом массиве
 double x_min;                  // минимальное значение в нормируемом массиве
 double x_curr;                           // текущее ненормированное значение
 double x_norm;                             // текущее нормированное значение
 double coef_1;                              // 1-й нормировочный коэффициент
 double coef_2;                              // 2-й нормировочный коэффициент
 double diff_x;                                     // разность x_max - x_min
 int    n_bars;                                              // n_end - n_beg
 int    i;                                                         // счетчик
 //
 n_bars = n_end - n_beg;
 // ########################### Error Definitions ###########################
 // *** Ошибка: если перепутаны местами начальный и конечный бары, выход ***
 if (n_bars < 0) 
 { 
	 err_code = -6;
	 return(err_code); 
 } 
 // *** Ошибка: если превышено максимальное число баров, выход ***
 if ((n_bars > 0) && (n_bars > NN_MAX))
 { 
	 err_code = -1;
	 return(err_code); 
 } 
 // *** Ошибка: для преобразования задано слишком мало баров, выход ***
 if ((n_bars > 0) && (n_bars < NN_MIN))
 {  
	 err_code = -2;
	 return(err_code); 
 }  
 // #########################################################################
 //
 //----
 // находим максимумы и минимумы в массиве результата
 x_min =  999999999.0;
 x_max = -999999999.0;
 for (i = n_beg; i < n_end; i++)
 { 
  x_curr = x[i];
  if (x_curr >= x_max) { x_max = x_curr; }
  if (x_curr <= x_min) { x_min = x_curr; }
 } 
 diff_x = x_max - x_min;
 //
 // ########################### Error Definitions ###########################
 // *** Ошибка: diff_x = 0 ***
 if (diff_x == 0.0)
 {
  err_code = -7;
  return(err_code);
 }
 // #########################################################################
 //
 // находим коэффициенты пересчета   
 coef_1 = (v_min * x_max - v_max * x_min) / diff_x;
 coef_2 = (v_max - v_min) / diff_x;
 // нормируем результат на заданный диапазон
 for (i = n_beg; i < n_end; i++)
 { 
  x_curr = x[i];
  x_norm = coef_1 + x_curr * coef_2;
  x[i]   = x_norm;
 } 
 //----
 return(err_code);
} 
//

变量v_max和v_min应该在形成价格阵列进行处理时提前获得。

Forex Trader 2006.03.14 18:22 #97

弗拉迪斯拉夫，
，我理解你希望免去大话，以及你对数学统计学方法的态度。
然而，我有不同的看法。

市场是一个非稳定的、混乱的过程。而Matstatistics主要处理的是静止过程。过渡到极限是证明声明的主要方法之一。那么市场的极限状态是什么呢？布朗运动是一个封闭系统中的现象，而市场是一个实质上开放的系统。另一方面，市场是一个自我组织的过程，因此有这种自我组织的规律。

从我的观点来看，你的成功不是因为应用了数理统计方法，
，而是因为你的策略中的建设性部分对数理统计方法的限制。
这些限制是帮助捕捉一些重要的东西，而不是让方法（即工具）把它溶入应用的细节。

谢谢你的书，我一定会看一看。
你在蜘蛛上的绰号是一样的吗？

Forex Trader 2006.03.14 18:24 #98

<br / translate="no"> 你在蜘蛛上的绰号是一样的吗？

在蜘蛛上，它是VG.

祝您好运，祝您顺利通过考试。

Forex Trader 2006.03.14 18:29 #99

alexjou
这三个来源是否意味着你是和MT4一起使用的（看起来是这样）。而如果没有C语言环境来编译，会有什么感觉？

Forex Trader 2006.03.14 19:07 #100

alexjou
这三个来源是否意味着你是和MT4一起使用的（看起来是这样）。而如果没有C语言环境来编译，会有什么感觉？

你可以在MT中试试。最初，它们是用MQL编程，用于调试，然后以最小的改动移到C语言中，而最古老的版本是用汇编语言。

基于艾略特波浪理论的交易策略 - 页 10