エリオット波動理論に基づくトレーディング戦略 - ページ 10

新しいコメント
 
基本的にはこのような感じです。ハースト比はチャネルごとに計算され、その中のバーの数が一定の値（例えば30）を超えていることを確認することが重要です - Òôôは、3-5-7日の日足チャネルから計算するので重要ではありません（すべてはあなたが得たい精度次第 - 1日収集は不安定かもしれません） - 日中バーで十分です）。そして初めて、このチャンネルが予測に適しているか、反転帯の予測を構築できるかについて結論を出す。異なるチャンネルのMurrayによる1つの同じ反転レベルは、異なる信頼区間に なる - 何とかしてそれを切り離す必要がありますね？そして、品質基準はポテンシャルエネルギーです。2次形については、何も珍しいことではありません。

そして、DONE SOLUTIONではなく、方法論をお伝えするのですが、どうぞ、ご遠慮ください。

幸運と幸せなトレンドを
 
<br / translate="no"> そして、私はDIRECTの解決策を共有するつもりはありませんが、方法論 - no problem。

一般的にはクリアです。すべてが論文の通りです。このシンプルなスキームがなければ、何もうまくいかないのです。）そして回路図は、それを発明した人だけが知っていて、それ以外のものは、周りにたくさんあるただの紙なのです。でも、私は事実を述べたまでで、それ以外の意味はありません。とにかくみんな自分の自転車に乗らなければならない。やっぱりFOREXですね！（笑)

そして、ここでもうひとつ質問です。これらはすべて、何に基づいて実装されているのですか？MT4で？
つまり、MT4には、ご指摘のMurrayのインジケーターがあります。明確である。
しかし、チャンネルやハーストの計算には何を使うのでしょうか？MT4も使っているのですか？以前、コードサイズ0.5Mという話がありましたね。どういうことですか？mql4で計算プログラムのテキストの重さ？そうだとしたら、率直に言って、そんなボリュームがあるとは到底思えません。なぜなら、私の控えめな見積もりでは、このようなプログラムのテキストは10000行程度になるはずだからです。私が使っている単純なホワイトノイズ戦略は、異なる時間枠の情報を使う6つの取引スレッドを並行して起動するだけなのに、たった1000行で済みます。このようなコードの断片は、配列を使って400～500行に変換するより、今のままにしておく方が簡単（さらなる修正に便利）です（将来的にはそのような計画も可能でしょうが）。つまり、1つのスレッドを1つの時間軸で動かすと、400〜500行かかる。私は、監視する必要のない、完全に機能するExpert Advisorを使用しています。もちろん、これ以上の改良を拒むつもりはありませんが、今のところ、テスターで最適化できるものはすべて最適化済みです。しかし、あなたの方法にはある種の興味があり、もちろん成功すれば何か応用してみようと思っています。

PS：また、私が大きなロットで1つのスレッドを使用するのではなく、小さなロットで異なる時間枠でいくつかの並行スレッドを使用しているという事実は、この種の取引では最大ドローダウンのフィルタリング効果のようなものが現れるという事実だけで説明されます。つまり、ランダムプロセス（1スレッドの残高動態）が複数ある場合、1口座の残高を合計すると、最大ドローダウンは、各スレッドのドローダウンの合計ではなく、スレッド数の平方根で割ったものになる！ したがって、最大ドローダウンの合計を減らすようにしています。つまり、1,5年の履歴でそれぞれ50USDのドローダウンを持つスレッドが6つあれば、論理的には6つのスレッドのドローダウンの合計は300USDとなるはずですが、実際にはこの金額を6の平方根=2,45で割る必要があります。テスターではだいたいこんな感じです。テスターでは、約2.2で割るように表示されています。これは、最大ドローダウンを減らすという私の考えとよく一致していると思います。
 
一般に、自分で「回路」を考えることはできますが、それが簡単だとは言えません。しかし、そうすることによって初めて、それがどのように機能し、どのように（正確に、なぜ、他の方法では）信号が解釈されるのかを理解することができるのです。コードについて：MKL4で書きました。長い間プログラミングしてきたC/C++にとても似ています。遅いですが。すべてC++用に再コンパイルします。0.5Mはコンパイルされたプログラムのサイズ、つまり.ex4ファイルのサイズです。行数を少し間違えていますね。合計で約6000行、ほとんどが関数やループ、多次元 配列で、そのまま展開すると、想像もつきません :) .....................です。


頑張って、良い流れを作ってください。
 
Hi Vladislav !
私はスムージング・アルゴリズムを使いません。すべて遅れているのです)。頑張ってください。


私はそうは思いません。このスレッドが面白くなったのは、あなたが自分の経験やアイデアを共有しようと思ったときだけです。

物理学者として、フィールドやポテンシャリティなど、すべて理解しています。最適化もすべてクリアしている。自明ではない、面白い問題だ。数学的な統計学については、残念ながら一般論としてしか内容を把握できていません。でも、このテーマは面白いですね。特に、有意水準の先験的推定と非ランダム予測の可能性の部分において。

私のアプローチは、これまでのところ、トレンド相場の期間を定義することに重点を置いています。私は、上記の記事にあるような形でハースト社のインデックスを 利用したことはありませんし、それ以外の方法でもありません。しかし、私も独自の計算アルゴリズムを持つ市場フラクタル性の指標に頼ろうとしています。トレンドの期間と同じようにカウンタートレンドの期間も使えるという考え方は、私にとって全く意外なことでした。その下にあるものまで見えなくなってしまうこともあるのです。:-)

ですから、このフォーラムでなくても、マレーレベルのインジケーターに記載されているメールや、プライベートメッセージのスパイダーで、対話を続けることができれば幸いです。

とにかく、私はあなたの作品に感動しました。素人（私も含めて）の「造形的思考」ではなく、数学者の手になる数学の仕事を初めて目にした。
特に気に入ったのは、
。
...2006年1月以来、私はどのデータフィードでも同じレベルと反転ゾーンの境界を与えるソリューションメソッドを得ることに成功しました、それは引用のいくつかの違いにもかかわらず、どのDCにあり、同時に私は平滑化アルゴリズムを使用しません - 彼らはすべて遅れています。

異なるデータストリームで平滑化せずに結果を収束させることは、その手法がプロセスの本質に迫っていることを意味する !
 
ですから、このフォーラムでなくても、マレー・レベル・インジケータに記載されているメールや、スパイダーで、プライベートで対話を続けたいと思います。<br/ translate="no">。


問題ありません。


異なるデータストリームで平滑化せずに結果を収束させるということは、その方法論がプロセスの本質に迫っていることを意味する !


もう少し控えめに言うと、統計学の手法は正しく適用すればうまくいくし、多くのTA手法には正当な理由があるということです。(つまり、市場にあらかじめ決められた動きのある領域が存在する)。エリオットやギャンなどの定性的な手法もありますが、エリオットは定量的な見積もりができないので、あまり好きではありません。とにかく、頑張って、いい流れを作ってください。 マコーミックの "Encyclopedia of Trading Strategies "やブラシェフの



"Statistics for Traders"は応用的な意味で非常に有用で、手法のロジックが示されている。
 
職業柄、かなり身近な手法なので、なおさら興味深く読ませていただきました。微力ながら、貢献させてください。
私はスムージングアルゴリズムを使用しません。

回折カーネルを使用した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 は、処理用の価格配列を作成する際に、先に取得しておく必要があります。

 
Vladislav,
大言壮語をやめたい気持ちや、数理統計学の 手法に対する考え方はよくわかります。
しかし、私は違う意見を持っています。

市場は非定常的で混沌としたプロセスである。そして、数理統計学は主に定常過程を扱います。極限への移行は、ステートメントを証明する主な方法の1つです。また、市場の限界状態はどうなっているのでしょうか？ブラウン運動は閉じた系での現象であるが、市場は実質的に開いた系である。一方、市場は自己組織化プロセスであり、それゆえ、この自己組織化の法則が存在する。

私の見解では、あなたの成功は、マト統計学の手法の適用によるものではなく、
、あなたの戦略の構成的な部分のマト統計学の手法のLIMITATIONSに起因するものです。
こうした制約があるからこそ、手法（＝道具）に溶かされることなく、大切なものをとらえることができたのです。

本の紹介ありがとうございます！ぜひ見てみます。
スパイダーでのニックネームは同じですか？
 
<br / translate="no"> スパイダーでのニックネームは同じですか？


スパイダーではVG .

頑張って、Trndsも頑張ってください。
 
アレクセーユ
この3つのソースは、MT4と併用しているということでしょうか（そのように見えます）。また、コンパイルするC言語環境がない場合、どのように感じるのでしょうか。
 
alexjou
この3つのソースは、MT4と併用しているということでしょうか（そのように見えます）。また、コンパイルするC言語環境がない場合、どのように感じるのでしょうか。

MTで試してみてはいかがでしょうか。元々はデバッグ用にMQLでプログラムされていたものを、最小限の変更でCに移行したもので、一番古いバージョンはアセンブラだったんです。
1...34567891011121314151617...309
新しいコメント