Определение тренда

[AntFX 6,451]

Только что, DIMtrade сказал:

В общем домашнее задание Вам

Может все таки "Вам" с маленькой буквы? Боюсь, я не осилю ))))) Точнее, уже немного подустал и потерял нить. Но когда-нибудь вернусь к этой теме однозначно )

[kaif 6,733]

4 часа назад, DIMtrade сказал:

если в эту формулу подставить T = периоду до экспирации, то вы получите одну из возможных цен на дату экспирации.

 

Я Вас прекрасно понял.

Осталось понять, почему мой розыгрыш в лоб такого рода:

 

exp(k1*t + k2*w(t)),

где w(t) - нормально распределенная случайная величина с фиксированными свойствами,

 

дает иной результат. 

 

Объясните мне вот этот момент: 3. Умножил вероятность на волатильность, прибавил к цене в t0 момент времени;

 

цена в t0 момент времени это каждый раз цена на начало 01.01.2018, если я генерирую, начиная с 01.01.2018?

Или это цена, сложившаяся к очередной итерации?

 

Давайте отбросим дрифт. Без него будет проще.

 

У меня такое ощущение, что Вы разыгрываете цену, как случайную величину, распределенную нормально.

А не смещение цены в каждый момент времени N относительно предшествующего N-1, распределенное нормально.

 

А это разные вещи. Так как первое моделирует цену, как некий отклонение цены от нуля, к которому цена стремится вернуться.

А второе дает отклонение приращения цены относительно цены в предыдущий день (или секунду), приводящий к тому, что если цена удалилась от нуля, то вероятность того, что она вернется обратно, стремительно падает, и ем стремительнее, чем дальше ушла цена от первоначальной точки.

 

Именно второе есть модель броуновского движения (винеровский процесс). А не первое.

 

 

[DIMtrade 651]

Кайф, ну не поленитесь и откройте файл, щелкните на ячейки, там все ясно что и как считается.
 

14 минут назад, kaif сказал:

А не смещение цены в каждый момент времени N относительно предшествующего N-1, распределенное нормально.

Для синего графика - смещение. 

Кстати заметили, что зеленый график колбасит сильнее, чем красный, это потому что актив не может упасть ниже 0, а расти может бесконечно))), формула это учитывает. Это собственно та же ваша формула, что вы привели выше, только более адаптированная к рынку. Она выведена была из вашей.

Edited February 17 by DIMtrade

[DIMtrade 651]

Вот, волатильность 40%

[kaif 6,733]

У меня старый эксель почему-то не хочет открывать этот файл.

 

 

[kaif 6,733]

Поэтому я хочу понять на пальцах.

Допустим, у нас есть распределение вероятностей величины r (кривая). Каждая точка этой кривой дает вероятность того, что случайная r величина окажется меньше, чем X.

Что дальше на что я должен умножить, чтобы получить очередное значение нормально распределенной случайной величины r, зная отдельно взятое текущее значение а, где а - равномерно распределенная величина в диапазоне [0,1[?

 

Edited February 17 by kaif

[kaif 6,733]

Из общих соображений я должен взять обратную функцию и подставить вместо вероятности равномерно распределенную случайную величину.

Осталось убедиться в том, что Ваша хитрая функция правильно считает.

Вот я попытался ее воспроизвести у себя.

Подставляю в качестве X равномерно распределенную величину [0,1[.

Получаю какую-то чушь. У меня здесь ошибка?

 

function Gauss2(X: double): double;
var
  L,K,W, a1,a2,a3,a4,a5: double;
begin
  L := 0;
  K := 0;
  W := 0;
  a1 := 0.31938153;
  a2 := -0.356563782;
  a3 := 1.781477937;
  a4 := -1.821255978;
  a5 := 1.330274429;
  L := Abs(X);
  K := 1.0 / (1.0 + 0.2316419 * L);
  W := 1.0 - 1.0 / Sqrt(2 * 3.14159) *
  Exp(-L * L / 2.0) * (a1 * K + a2 * K * K + a3 * Power(K, 3.0) + a4 * Power(K, 4.0) + a5 * Power(K, 5.0));
  if (X < 0) then W := 1.0 - W;
  Result := W;
end;

 

procedure OHLC(Volume: integer; dev: double; Open: double; var High: double; var Low: double; var Close: double);
var
  i: integer;
begin
  Close := Open;
  High := Open;
  Low:= Open;
  for i := 1 to Volume do
  begin
    Close := Close + dev * Gauss2(Random);
    if Close > High then
      High := Close
    else if Close < Low then
      Low := Close;
  end;
end;
 

 

Скрытый текст

 

 

Edited February 17 by kaif

[DIMtrade 651]

2 часа назад, kaif сказал:

Что дальше на что я должен умножить, чтобы получить очередное значение нормально распределенной случайной величины r, зная отдельно взятое текущее значение а, где а - равномерно распределенная величина в диапазоне [0,1[?

 

  Вроде верно поняли:

2 часа назад, kaif сказал:

    Close := Close + dev * Gauss2(Random);
 

  Показать содержимое

 

 

Я вечером проверю еще раз код в C#, не в экселе и скину его Вам, его переделать на Дельфи очень быстро, языки похожи.
 

3 часа назад, kaif сказал:

У меня старый эксель почему-то не хочет открывать этот файл.

Ловите, сохранил под 2003, древний формат

https://drive.google.com/open?id=1dC-kYHv56_F5HHNZE9oPIYCstuZyK7Gv

Жмите F9 чтоб прогнать

Добавил еще туда частотный график приращений цен, по Y частота, по X - Z score, т.е. в сигмах.
Прогонов мало, но видно, чт онормално распределены.

[DIMtrade 651]

https://drive.google.com/file/d/1aEck7UBSok31mWOk2lX28ElD5N_yDhWp/view

Во, щелкайте сюда, эксель не нужен, через гугл докс все работает прямо в браузере

[kaif 6,733]

Cпасибо, Дмитрий - в Экселе заработало.

Смотрю, вроде бы все верно. Ячейка 86 рассчитывается на основе предыдущей ячейки 85.

=C85*EXP(($C$18-$C$17^2/2)*(1/$C$15)+$C$17*КОРЕНЬ(1/$C$15)*НОРМСТОБР(СЛЧИС()))

 

Мой алгоритм отличается только тем, что я не использую экспоненту и постоянную составляющую.

Просто прибавляю к цене предыдущей итерации нормально распределенное смещение, умноженное на секундную волатильность.

Но это ничтожное отличие, если нет постоянной составляющей и цена сдвигается на очень малую величину.

. 

Edited February 17 by kaif

[kaif 6,733]

Осталось добиться того, чтобы результат подстановки в функцию Gauss2 давал такое же нормальное распределение, что и тот метод, что я использую (формулу Бокса-Мюллера).

Edited February 17 by kaif

[DIMtrade 651]

5 часов назад, kaif сказал:

Осталось добиться того, чтобы результат подстановки в функцию Gauss2 давал такое же нормальное распределение, что и тот метод, что я использую (формулу Бокса-Мюллера).

 

8 часов назад, kaif сказал:

Получаю какую-то чушь. У меня здесь ошибка?

Ошибся я, не вы. Нужно использовать обратную кумулятивную функцию, нужна iCNDF, а не CNDF
У CNDF на вход подается z, на выходе вероятность, у iCNDF - наоборот, на вход подается вероятность, на выходе z. Я попутал дал вам CNDF, поэтому у вас и вышла чушь.

Набросал прогу на c# под винду, усе проверил, все работает, можете поиграться, синяя с дрифтом, красная - без, для сравнения, график можно колесиком приблидать - удалять. iCNDF в этой проге решил использовать на основе Ziggurat алгоритма, пишут он в 1.5 раза быстрее Box Muller. http://heliosphan.org/zigguratalgorithm/zigguratalgorithm.html#optimisations2

У меня есть исходники многих алгоритмов iCNDF, если нужны, правда все под c#

 

 

PriceModel.zip

Edited February 17 by DIMtrade

[DIMtrade 651]

Ну и если хотите проверить альтернативную iCNDF засуньте вот это в свою прогу за место CNDF, чтоб проверить

public static double iCNDF(double P)
        {
            double a1 = -39.69683028665376;
            double a2 = 220.9460984245205;
            double a3 = -275.9285104469687;
            double a4 = 138.3577518672690;
            double a5 = -30.66479806614716;
            double a6 = 2.506628277459239;

            double b1 = -54.47609879822406;
            double b2 = 161.5858368580409;
            double b3 = -155.6989798598866;
            double b4 = 66.80131188771972;
            double b5 = -13.28068155288572;

            double c1 = -0.007784894002430293;
            double c2 = -0.3223964580411365;
            double c3 = -2.400758277161838;
            double c4 = -2.549732539343734;
            double c5 = 4.374664141464968;
            double c6 = 2.938163982698783;

            double d1 = 0.007784695709041462;
            double d2 = 0.3224671290700398;
            double d3 = 2.445134137142996;
            double d4 = 3.754408661907416;

            double p_low = 0.02425;
            double p_high = 1 - p_low;
            double q, r, e, u;
            double x = 0.0;

            if (0 < P && P < p_low)
            {
                q = Math.Sqrt(-2 * Math.Log(P));
                x = (((((c1 * q + c2) * q + c3) * q + c4) * q + c5) * q + c6) / ((((d1 * q + d2) * q + d3) * q + d4) * q + 1);
            }

            if (p_low <= P && P <= p_high)
            {
                q = P - 0.5;
                r = q * q;
                x = (((((a1 * r + a2) * r + a3) * r + a4) * r + a5) * r + a6) * q / (((((b1 * r + b2) * r + b3) * r + b4) * r + b5) * r + 1);
            }

            if (p_high < P && P < 1)
            {
                q = Math.Sqrt(-2 * Math.Log(1 - P));
                x = -(((((c1 * q + c2) * q + c3) * q + c4) * q + c5) * q + c6) / ((((d1 * q + d2) * q + d3) * q + d4) * q + 1);
            }

            if ((0 < P) && (P < 1))
            {
                e = 0.5 * Erfc(-x / Math.Sqrt(2)) - P;
                u = e * Math.Sqrt(2 * Math.PI) * Math.Exp(x * x / 2);
                x = x - u / (1 + x * u / 2);
            }
            return x;
        }

Edited February 17 by DIMtrade

[kaif 6,733]

Спасибо, Дмитрий, вроде разобрались. 

Я позже попробую проверить.

[kaif 6,733]

Вроде все первел с с#.

Кроме Erfc.

Не знаю, что за зверь.

 

Скрытый текст

 

function Gauss2(P: double): double; //iCNDF
const
  a1 = -39.69683028665376;
  a2 = 220.9460984245205;
  a3 = -275.9285104469687;
  a4 = 138.3577518672690;
  a5 = -30.66479806614716;
  a6 = 2.506628277459239;

  b1 = -54.47609879822406;
  b2 = 161.5858368580409;
  b3 = -155.6989798598866;
  b4 = 66.80131188771972;
  b5 = -13.28068155288572;

  c1 = -0.007784894002430293;
  c2 = -0.3223964580411365;
  c3 = -2.400758277161838;
  c4 = -2.549732539343734;
  c5 = 4.374664141464968;
  c6 = 2.938163982698783;

  d1 = 0.007784695709041462;
  d2 = 0.3224671290700398;
  d3 = 2.445134137142996;
  d4 = 3.754408661907416;
  pi = 3.14159265359;

var
  p_low, p_high, q, r, e, u, x: double;
begin
  p_low := 0.02425;
  p_high := 1 - p_low;
  x := 0.0;
  if (0 < P) and (P < p_low) then
  begin
    q := Sqrt(-2 * Ln(P));
    x := (((((c1 * q + c2) * q + c3) * q + c4) * q + c5) * q + c6) / ((((d1 * q + d2) * q + d3) * q + d4) * q + 1);
  end;

  if (p_low <= P) and (P <= p_high) then
  begin
    q := P - 0.5;
    r := q * q;
    x := (((((a1 * r + a2) * r + a3) * r + a4) * r + a5) * r + a6) * q / (((((b1 * r + b2) * r + b3) * r + b4) * r + b5) * r + 1);
  end;

  if (p_high < P) and (P < 1) then
  begin
    q := Sqrt(-2 * Ln(1 - P));
    x := -(((((c1 * q + c2) * q + c3) * q + c4) * q + c5) * q + c6) / ((((d1 * q + d2) * q + d3) * q + d4) * q + 1);
  end;

  if (0 < P) and (P < 1) then
  begin
    e := 0.5 * Erfc(-x / Sqrt(2)) - P;
    u := e * Sqrt(2 * pi) * Exp(x * x / 2);
    x := x - u / (1 + x * u / 2);
  end;
  Result := x;
end;

 

 

Вообще, если речь идет о выигрыше не на порядок и розыгрыш занимает пару секунд,а не дней, я предпочту самый короткий и понятный код.

Не баллистическую ракету запускаем...

Edited February 17 by kaif

[kaif 6,733]

Дмирий, я нахожу этот наш разговор очень плодотворным для себя.

 

Так как "постоянные составляющие" явно уменьшают зрительно "относительный расколбас".

То есть движения, вызванные случайным блужданием, гораздо "зашумленнее"аналогичных по масштабу, так, скажем, "истинных" (имеющих иные причины).

Возможно, что этим надо попытаться воспользоваться. 

Допустим, размер дневного бара сильно выскакивает за корень из квадрата волатильности, если опираться на минутную статистику (а она большая).

Это означает, что с большой вероятностью мы имеем дело не со случайным блужданием.

Возможно, это какая-то полезная информация о состоянии рынка (сигнал).

 

Это близко к тому, что Вы когда-то говорили (сложить пятнадцатиминутные бары и сравнить с дневным для оценки "зашумленности").

 

 

Edited February 17 by kaif

[DIMtrade 651]

13 часов назад, kaif сказал:

Вроде все первел с с#.

Кроме Erfc.

Не знаю, что за зверь.

 

Вообще, если речь идет о выигрыше не на порядок и розыгрыш занимает пару секунд,а не дней, я предпочту самый короткий и понятный код.

Не баллистическую ракету запускаем...

Этот зверь Gauss error function (зовется erfc или erf ) есть у меня от Sun Microsystems, но должна быть готовая для дельфи, так как используется довольно часто в статистике

/// <summary>
        /// Returns the value of the complementary error function at <paramref name="x"/>.
        /// </summary>
        public static double Erfc(double x)
        {
            /*
            Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
            *
            * Developed at SunPro, a Sun Microsystems, Inc. business.
            * Permission to use, copy, modify, and distribute this
            * software is freely granted, provided that this notice
            * is preserved.
            */

            #region Constants

            const double tiny = 1e-300;
            const double erx = 8.45062911510467529297e-01;

            // Coefficients for approximation to erf on [0, 0.84375]
            //const double efx = 1.28379167095512586316e-01; /* 0x3FC06EBA; 0x8214DB69 */
            //const double efx8 = 1.02703333676410069053e+00; /* 0x3FF06EBA; 0x8214DB69 */
            const double pp0 = 1.28379167095512558561e-01; /* 0x3FC06EBA; 0x8214DB68 */
            const double pp1 = -3.25042107247001499370e-01; /* 0xBFD4CD7D; 0x691CB913 */
            const double pp2 = -2.84817495755985104766e-02; /* 0xBF9D2A51; 0xDBD7194F */
            const double pp3 = -5.77027029648944159157e-03; /* 0xBF77A291; 0x236668E4 */
            const double pp4 = -2.37630166566501626084e-05; /* 0xBEF8EAD6; 0x120016AC */
            const double qq1 = 3.97917223959155352819e-01; /* 0x3FD97779; 0xCDDADC09 */
            const double qq2 = 6.50222499887672944485e-02; /* 0x3FB0A54C; 0x5536CEBA */
            const double qq3 = 5.08130628187576562776e-03; /* 0x3F74D022; 0xC4D36B0F */
            const double qq4 = 1.32494738004321644526e-04; /* 0x3F215DC9; 0x221C1A10 */
            const double qq5 = -3.96022827877536812320e-06; /* 0xBED09C43; 0x42A26120 */

            // Coefficients for approximation to erf in [0.84375, 1.25]
            const double pa0 = -2.36211856075265944077e-03; /* 0xBF6359B8; 0xBEF77538 */
            const double pa1 = 4.14856118683748331666e-01; /* 0x3FDA8D00; 0xAD92B34D */
            const double pa2 = -3.72207876035701323847e-01; /* 0xBFD7D240; 0xFBB8C3F1 */
            const double pa3 = 3.18346619901161753674e-01; /* 0x3FD45FCA; 0x805120E4 */
            const double pa4 = -1.10894694282396677476e-01; /* 0xBFBC6398; 0x3D3E28EC */
            const double pa5 = 3.54783043256182359371e-02; /* 0x3FA22A36; 0x599795EB */
            const double pa6 = -2.16637559486879084300e-03; /* 0xBF61BF38; 0x0A96073F */
            const double qa1 = 1.06420880400844228286e-01; /* 0x3FBB3E66; 0x18EEE323 */
            const double qa2 = 5.40397917702171048937e-01; /* 0x3FE14AF0; 0x92EB6F33 */
            const double qa3 = 7.18286544141962662868e-02; /* 0x3FB2635C; 0xD99FE9A7 */
            const double qa4 = 1.26171219808761642112e-01; /* 0x3FC02660; 0xE763351F */
            const double qa5 = 1.36370839120290507362e-02; /* 0x3F8BEDC2; 0x6B51DD1C */
            const double qa6 = 1.19844998467991074170e-02; /* 0x3F888B54; 0x5735151D */

            // Coefficients for approximation to erfc in [1.25, 1/0.35]
            const double ra0 = -9.86494403484714822705e-03; /* 0xBF843412; 0x600D6435 */
            const double ra1 = -6.93858572707181764372e-01; /* 0xBFE63416; 0xE4BA7360 */
            const double ra2 = -1.05586262253232909814e+01; /* 0xC0251E04; 0x41B0E726 */
            const double ra3 = -6.23753324503260060396e+01; /* 0xC04F300A; 0xE4CBA38D */
            const double ra4 = -1.62396669462573470355e+02; /* 0xC0644CB1; 0x84282266 */
            const double ra5 = -1.84605092906711035994e+02; /* 0xC067135C; 0xEBCCABB2 */
            const double ra6 = -8.12874355063065934246e+01; /* 0xC0545265; 0x57E4D2F2 */
            const double ra7 = -9.81432934416914548592e+00; /* 0xC023A0EF; 0xC69AC25C */
            const double sa1 = 1.96512716674392571292e+01; /* 0x4033A6B9; 0xBD707687 */
            const double sa2 = 1.37657754143519042600e+02; /* 0x4061350C; 0x526AE721 */
            const double sa3 = 4.34565877475229228821e+02; /* 0x407B290D; 0xD58A1A71 */
            const double sa4 = 6.45387271733267880336e+02; /* 0x40842B19; 0x21EC2868 */
            const double sa5 = 4.29008140027567833386e+02; /* 0x407AD021; 0x57700314 */
            const double sa6 = 1.08635005541779435134e+02; /* 0x405B28A3; 0xEE48AE2C */
            const double sa7 = 6.57024977031928170135e+00; /* 0x401A47EF; 0x8E484A93 */
            const double sa8 = -6.04244152148580987438e-02; /* 0xBFAEEFF2; 0xEE749A62 */

            // Coefficients for approximation to erfc in [1/0.35, 28]
            const double rb0 = -9.86494292470009928597e-03; /* 0xBF843412; 0x39E86F4A */
            const double rb1 = -7.99283237680523006574e-01; /* 0xBFE993BA; 0x70C285DE */
            const double rb2 = -1.77579549177547519889e+01; /* 0xC031C209; 0x555F995A */
            const double rb3 = -1.60636384855821916062e+02; /* 0xC064145D; 0x43C5ED98 */
            const double rb4 = -6.37566443368389627722e+02; /* 0xC083EC88; 0x1375F228 */
            const double rb5 = -1.02509513161107724954e+03; /* 0xC0900461; 0x6A2E5992 */
            const double rb6 = -4.83519191608651397019e+02; /* 0xC07E384E; 0x9BDC383F */
            const double sb1 = 3.03380607434824582924e+01; /* 0x403E568B; 0x261D5190 */
            const double sb2 = 3.25792512996573918826e+02; /* 0x40745CAE; 0x221B9F0A */
            const double sb3 = 1.53672958608443695994e+03; /* 0x409802EB; 0x189D5118 */
            const double sb4 = 3.19985821950859553908e+03; /* 0x40A8FFB7; 0x688C246A */
            const double sb5 = 2.55305040643316442583e+03; /* 0x40A3F219; 0xCEDF3BE6 */
            const double sb6 = 4.74528541206955367215e+02; /* 0x407DA874; 0xE79FE763 */
            const double sb7 = -2.24409524465858183362e+01; /* 0xC03670E2; 0x42712D62 */

            #endregion

            if (double.IsNaN(x))
                return double.NaN;

            if (double.IsNegativeInfinity(x))
                return 2.0;

            if (double.IsPositiveInfinity(x))
                return 0.0;

            int n0, hx, ix;
            double R, S, P, Q, s, y, z, r;
            unsafe
            {
                double one = 1.0;
                n0 = ((*(int*)&one) >> 29) ^ 1;
                hx = *(n0 + (int*)&x);
            }
            ix = hx & 0x7FFFFFFF;

            if (ix < 0x3FEB0000) // |x| < 0.84375
            {
                if (ix < 0x3C700000) // |x| < 2**-56
                    return 1.0 - x;
                z = x * x;
                r = pp0 + z * (pp1 + z * (pp2 + z * (pp3 + z * pp4)));
                s = 1.0 + z * (qq1 + z * (qq2 + z * (qq3 + z * (qq4 + z * qq5))));
                y = r / s;
                if (hx < 0x3FD00000) // x < 1/4
                    return 1.0 - (x + x * y);
                else
                {
                    r = x * y;
                    r += (x - 0.5);
                    return 0.5 - r;
                }
            }
            if (ix < 0x3FF40000) // 0.84375 <= |x| < 1.25
            {
                s = Math.Abs(x) - 1.0;
                P = pa0 + s * (pa1 + s * (pa2 + s * (pa3 + s * (pa4 + s * (pa5 + s * pa6)))));
                Q = 1.0 + s * (qa1 + s * (qa2 + s * (qa3 + s * (qa4 + s * (qa5 + s * qa6)))));
                if (hx >= 0)
                {
                    z = 1.0 - erx;
                    return z - P / Q;
                }
                else
                {
                    z = erx + P / Q;
                    return 1.0 + z;
                }
            }
            if (ix < 0x403C0000) // |x| < 28
            {
                x = Math.Abs(x);
                s = 1.0 / (x * x);
                if (ix < 0x4006DB6D) // |x| < 1/.35 ~ 2.857143
                {
                    R = ra0 + s * (ra1 + s * (ra2 + s * (ra3 + s * (ra4 + s * (ra5 + s * (ra6 + s * ra7))))));
                    S = 1.0 + s * (sa1 + s * (sa2 + s * (sa3 + s * (sa4 + s * (sa5 + s * (sa6 + s * (sa7 + s * sa8)))))));
                }
                else // |x| >= 1/.35 ~ 2.857143
                {
                    if (hx < 0 && ix >= 0x40180000)
                        return 2.0 - tiny; // x < -6
                    R = rb0 + s * (rb1 + s * (rb2 + s * (rb3 + s * (rb4 + s * (rb5 + s * rb6)))));
                    S = 1.0 + s * (sb1 + s * (sb2 + s * (sb3 + s * (sb4 + s * (sb5 + s * (sb6 + s * sb7))))));
                }
                z = x;
                unsafe { *(1 - n0 + (int*)&z) = 0; }
                r = Math.Exp(-z * z - 0.5625) *
                Math.Exp((z - x) * (z + x) + R / S);
                if (hx > 0)
                    return r / x;
                else
                    return 2.0 - r / x;
            }
            else
            {
                if (hx > 0)
                    return tiny * tiny;
                else
                    return 2.0 - tiny;
            }
        }

 

[DIMtrade 651]

Вот для Дельфи, но не от Sun

http://www.delphisources.ru/forum/showthread.php?t=24165

Вот тут все есть вроде и iCNDF тоже, но разбираться нужно)))

Edited February 18 by DIMtrade

[DIMtrade 651]

Инфа в вики про erfc
https://ru.wikipedia.org/wiki/Функция_ошибок

[DIMtrade 651]

14 часов назад, kaif сказал:

Дмирий, я нахожу этот наш разговор очень плодотворным для себя.

 

Так как "постоянные составляющие" явно уменьшают зрительно "относительный расколбас".

То есть движения, вызванные случайным блужданием, гораздо "зашумленнее"аналогичных по масштабу, так, скажем, "истинных" (имеющих иные причины).

Возможно, что этим надо попытаться воспользоваться. 

Допустим, размер дневного бара сильно выскакивает за корень из квадрата волатильности, если опираться на минутную статистику (а она большая).

Это означает, что с большой вероятностью мы имеем дело не со случайным блужданием.

Возможно, это какая-то полезная информация о состоянии рынка (сигнал).

 

Это близко к тому, что Вы когда-то говорили (сложить пятнадцатиминутные бары и сравнить с дневным для оценки "зашумленности").

 

 

Да, согласен с вашими мыслями, и в любом случае, любые подобные обсуждения всегда очень полезны

Если говорить о тренде, то волатильность в рамках тренда - это и есть шум, поэтому стох. тренды (как часть волатильности) и собстенно сам тренд нужно отделять. ИМХА конечно.

Edited February 18 by DIMtrade

[DIMtrade 651]

Искать тренды в СБ МО=0 это как рассматривать что-то в микроскоп

Вот с трендовой составляющей 5% в год и красная - без тренда

[DIMtrade 651]

Т.е. по моему Модель цены выглядит типа так:

 

В изменения в точках 1,2,3,4 обусловненны внешними событиями, экономисческими показателями, денежными потоками и .т.д. Это тренды, ну а все остальное - это волатильность. Если наша цель тренд, то вола для нас шум. Поэтому у долгосрочников нет коротких стопов или тейков, которые сбиваются волатильностью.

Есть еще волновая теория, которой я не привержен. Суть ее примерна такая же - движение цены является суммой отдельных процессов.

 

Складываем, получаем

[AntFX 6,451]

5 часов назад, DIMtrade сказал:

Есть еще волновая теория, которой я не привержен. Суть ее примерна такая же - движение цены является суммой отдельных процессов.

Её суть в том, что у этих процессов есть четко определенная внутренняя структура, которая не должна нарушаться, и это как раз абсолютный бред и ересь.  Структура и последовательность "волн" может быть любой. Не нужно приписывать вещам того, чем они не являются, твое утверждение как раз является осмысленным, а "волновая теория" - нет.

[kaif 6,733]

Гаусс получил:

Мой любимый Бокс-Мюллер 2 (год розыгрыша по 60 тиков на минуту - 18 сек)

 

Скрытый текст

 

function Gauss: double; //2-й вариант преобразования Бокса-Мюллера
var
  u,v,s,k: double;
begin
  while true do
  begin
    u := 2 * Random - 1;
    v := 2 * Random - 1;
    s := u * u + v* v;
    if (s = 0) or (s > 1) then
      continue;
    Result := u * Sqrt(-2*ln(s)/s);
    exit;
  end;
end;
 

 

 

 

 

iCNDF  (год розыгрыша по 60 тиков на минуту - 17 сек)
 

Скрытый текст

 

function erfc(const x: Double): Double;
var
  t,z,ans: Double;
begin
  z := abs(x);
  t := 1.0/(1.0+0.5*z);
  ans := t*exp(-z*z-1.26551223+t*(1.00002368+t*(0.37409196+t*(0.09678418+
    t*(-0.18628806+t*(0.27886807+t*(-1.13520398+t*(1.48851587+
    t*(-0.82215223+t*0.17087277)))))))));
  if x>=0.0 then begin
    Result := ans;
  end else begin
    Result := 2.0-ans;
  end;
end;

function Gauss2(P: double): double; //iCNDF
const
  a1 = -39.69683028665376;
  a2 = 220.9460984245205;
  a3 = -275.9285104469687;
  a4 = 138.3577518672690;
  a5 = -30.66479806614716;
  a6 = 2.506628277459239;

  b1 = -54.47609879822406;
  b2 = 161.5858368580409;
  b3 = -155.6989798598866;
  b4 = 66.80131188771972;
  b5 = -13.28068155288572;

  c1 = -0.007784894002430293;
  c2 = -0.3223964580411365;
  c3 = -2.400758277161838;
  c4 = -2.549732539343734;
  c5 = 4.374664141464968;
  c6 = 2.938163982698783;

  d1 = 0.007784695709041462;
  d2 = 0.3224671290700398;
  d3 = 2.445134137142996;
  d4 = 3.754408661907416;
  pi = 3.14159265359;

var
  p_low, p_high, q, r, e, u, x: double;
begin
  p_low := 0.02425;
  p_high := 1 - p_low;
  x := 0.0;
  if (0 < P) and (P < p_low) then
  begin
    q := Sqrt(-2 * Ln(P));
    x := (((((c1 * q + c2) * q + c3) * q + c4) * q + c5) * q + c6) / ((((d1 * q + d2) * q + d3) * q + d4) * q + 1);
  end;

  if (p_low <= P) and (P <= p_high) then
  begin
    q := P - 0.5;
    r := q * q;
    x := (((((a1 * r + a2) * r + a3) * r + a4) * r + a5) * r + a6) * q / (((((b1 * r + b2) * r + b3) * r + b4) * r + b5) * r + 1);
  end;

  if (p_high < P) and (P < 1) then
  begin
    q := Sqrt(-2 * Ln(1 - P));
    x := -(((((c1 * q + c2) * q + c3) * q + c4) * q + c5) * q + c6) / ((((d1 * q + d2) * q + d3) * q + d4) * q + 1);
  end;

  if (0 < P) and (P < 1) then
  begin
    e := 0.5 * Erfc(-x / Sqrt(2)) - P;
    u := e * Sqrt(2 * pi) * Exp(x * x / 2);
    x := x - u / (1 + x * u / 2);
  end;
  Result := x;
end;
 

 

 

 

 

Бокс-Мюллер

 

Скрытый текст

 

 

iCNDF

 

Скрытый текст

 

 

ИМХО, Бокс-Мюллер краткостью кода дал прикурить.

А в скорости я разницы не вижу. Так что я буду юзать БМ. На Delphi по крайней мере.

 

Edited February 18 by kaif

[kaif 6,733]

Итого 1.2 млн итераций в секунду (это включая вычисление OHLC минутки и последующее добавление в таблицу в памяти)

Интересно, какова скорость на C# 

А в Экселе? )))))))))

Edited February 18 by kaif