Incep sa scriu acest articol in ideea ca ar putea deveni folositor intr-un interval de timp nu prea indepartat. M-am gandit la asta de ceva vreme. Ideea de autoreglare a aparut de ceva vreme, dar complexitatea extrema a sistemelor de retail trading au facut-o imposibil de aplicat. Totusi, sistemele HFT sunt in general simple, si reguli similare sunt aplicate pe sute de titluri, intr-o maniera parametrizata. De aceea, daca regulile ar fi simple si ar putea fi scrise gen “cand apare asta, faci asta, rezultand asta”, in loc de logica de labirint a sistemelor de retail, atunci un set de statistici optime pe datele de intrare (intinzandu-se pe un tablou de cotatii, date de orderbook s.a.m.d.) este premisa pentru operatii gen cotare, primire de executii, take profit sau stop loss in doar cativa ticksi. Asa cum s-a vazut in articolul despre Progress Apama, acesti algoritmi sunt foarte instabili, fiind o continua cautare pentru algoritmi mai noi.

Acum poti intreba, de ce am incerca autoreglarea sistemelor de trading din moment ce institutionalii nu o fac (cel putin la nivelul HFT). Chestia e ca algoritmii lor sunt atat de rapizi incat pot sa nici nu aiba timp suficient de a inregistra datele in baza de date, incat autoreglarea, care necesita analiza suplimentara, ar fi o completa pierdere de timp, aducand prea putine imbunatatriri algoritmilor comparata cu latenta suplimentara care se formeaza. Ce va veni in aceste articole are de aceea o natura experimentala si nu trebuie luata ca solutie, ci ca incercare – nu pot spune sigur daca exista vreun sens in a incerca sa gasesti, cu statistici obisnuite, parametri recurenti ai unui proces stochastic.

Asa ca, sa presupunem ca un tablou de parametri (cum ar fi volatilitati individuale, medii mobile, volume de executii) va fi inregistrat intr-o baza de date sau un tablou. Trebuie sa luam in considerare si faptul ca un semnal de trading poate exista permanent, la fiecare tick. Presupunand volumul a fi constant, acelasi semnal poate fi in doua directii : cumparare sau vanzare. Fiecare semnal poate avea doua rezultate, unul pentru cumparare, unul pentru vanzare. Putem crea totusi reguli separate pentru vanzare.

De exemplu, un semnal cuprinse de volatilitate si distanta dintre cotatia mediana si media mobila a cotatiei mediene este de : 0.03 stddev si 2 ticksi. Ca sa-l rasucim putin , introducem cotarea, si notam 0 pentru situatia fara executii. Pusa intr-un buy cu 3 ticksi take profit si 2 ticksi stop loss, la un anumit moment, face 2 ticksi profit, pusa intr-un sell, nu are executii. Deci bazei de date cu cumparari va fi adaugata inregistrarea (0.03 ; 2 ; 2), iar celei cu vanzari (0.03 ; 2 ; 0).

Si acum lucrurile devin interesante. La sfarsit, dupa ce datele sunt stranse pentru o masa de semnale care constituie “numarul mare” pentru statistici, ne uitam prin baza de date. Mai intai, la o prima privire vom grupa baza de date dupa actiune si rezultat. In acest caz, avem sase stari finale:

1. BUY: coteaza, executie, take profit (BQFT)
2. BUY: coteaza, executie, stop loss (BQFS)
3. BUY: coteaza, fara executie, anulare ordin (BQC)
4. SELL: coteaza, executie, take profit (SQFT)
5. SELL: coteaza, executie, stop loss (SQFS)
6. SELL: coteaza, fara executie, anulare ordin (SQC)

Avem deci sase cazuri. Analizand BUY cu cotatie, executie si take profit, este doar una din cele sase stari si va consta intr-o parte mare a datelor, la fel ca si celelalte stari. Scopul analizei statistice e de a avea o statistica pregatita pentru fiecare caz. De exemplu, cazul nostru ar trebui sa arate, la sfarsit, cam asa:

0.03, 2 : 45% BQFT, 35% BQSL, 20% BQC ; 30% SQFT, 30% SQSL, 40% SQC

Dupa ce masa initiala de semnale impreuna cu rezultatele este colectata, statisticile trebuie sa fie lansate pentru fiecare combinatie de parametri. Avand numere reale ca parametri, cu multe zecimale, va conduce la faptul de a avea un numar mare de cazuri, egal cu numarul de semnale de input, facand statistica imposibila. Asa ca e nevoie de agregarea datelor. De exemplu, pentru fiecare set de parametri, pot fi calculate quartilele si apoi numarul de grupuri cu formula Freedman-Diaconis (e doar un exemplu, alte metode pot fi aplicate). Aceasta va conduce la un numar diferit de grupuri pentru fiecare dintre parametri. Apoi un nou tabel va fi creat, iar fiecare caz va avea o eticheta cu numarul de grupuri. De exemplu stddev 0.03 poate fi denumita ca “Grupul 1″ pe scara stddev si cei 2 ticksi distanta pot fi “Grupul 2″ pe scala distantelor in ticksi. Numarul total de cazuri poate fi mai mic sau egal decat produsul grupurilor per fiecare criteriu. Daca ai 3 criterii de 10 grupuri fiecare, pot fi si mai mult de 1000 de cazuri. Mai mult ca sigur, cazurile din miez vor avea un numar mare de situatii inregistrate, iar celelalte de-abia vor avea cate una. Totusi, cu cat mai platykurtica este repartitia situatiilor per cazuri, cu atat mai mare nevoia pentru un “numar mai mare” de situatii. Dupa aplicarea statisticilor, statistica bazei de date va arata cam asa:

Grupul 1, Grupul 2 : 45% BQFT, 35% BQSL, 20% BQC ; 30% SQFT, 30% SQSL, 40% SQC

Ce e important e ca trebuie sa fie extrase statistici relevante. Daca asa stau lucrurile, care ar fi decizia de trading? Mergi pe o cumparare cu o sansa de profit in 45% din cazuri? Numai ca sa suporti 35% stop losses… Pentru ca pe latura de vanzari e mult mai rau, cu situatii de stop loss aproape egale cu cele de profit. In acest caz, decizia este una de cumparare, dar totusi cu rezerve. Daca profiturile nu sunt destul de relevante, nicio decizie nu trebuie sa se ia. Totusi, este necesar ca algoritmul sa aiba un modul de decizii care sa aleaga numai cazurile relevante pentru trading.. Dar cat de rapida trebuie sa fie masina, intrucat dupa ce datele initiale sunt stranse, cu fiecare nou semnal (care poate fi si un tick, intr-un algoritm gen HFT) va fi lansata o masiva recalculare a marimilor grupurilor pe intreaga baza de date, pentru a aduce statistica la zi, si in acelasi timp de a veni cu decizia de trading si executia in timp real ?

Amintiti-va articolul meu despre motorul CEP. CEP este vazut acolo ca un modul de recunoastere – lansare, dar daca CEP poate fi utilizat ca dispozitiv de inregistrare ? Daca CEP poate fi legat de motorul statistic? Cata latenta va adauga calculului? Mai putem vorbi de timp real?

Daca n-ar fi acea abreviere CEP probabil ati intreba cum ceva inerent complex ar putea deveni simplu. Chestia e ca totul incepe mai intai a fi simplu inainte de a evolua in ceva complicat.

Chiar si daca mi-ati citit articolul despre Progress Apama, va reamintesc definitia data CEP de Dan Hubscher : “abilitatea de a lega doua sau mai multe evenimente, chiar daca acestea apar intr-un interval de timp, si de a le determina semnificatia din acea relatie imediat, cum ar fi detectia unui semnal de trading, sau a unei oportunitati de genera alfa.”

Deci, dat fiind ca trebuie sa se formeze conexiuni intre evenimente, avand o constrangere temporala, trebuie sa existe o coada de evenimente, care stocheaza evenimente individuale pe masura ce acestea sunt receptionate. Desigur, stocarea nu are loc la infinit intr-o coada in continua crestere; marimea cozii trebuie sa fie dinamica, dar lungimea ei in timp trebuie sa nu depaseasca un interval de timp predeterminat, sa zicem 5 minute. De aceea un motor CEP, care este in principal pentru HFT si trading de Nivel II, nu trebuie sa fie amestecat cu evenimente de Nivel I, deoarece acestea se intind pe un interval de timp mult mai larg, ceea ce ar face nu numai ca stiva de evenimente sa creasca pana la o marime necontrolabila, ci ar si reduce viteza motorului.

Intervalul de timp acoperit este prima limitare a motorului.

A doua, este legatura dintre evenimentele simple. Evenimentele simple nu sunt complet independente, asa cum ar reiesi din webinarul Progress Apama. De exemplu, ai putea considera o intersectie a unei Benzi Bollinger superioare ca si eveniment, dar si intersectia Benzii Bollinger inferioare. Aceste evenimente sunt complet opuse. Daca s-ar intampla amandoua, cand al doilea are loc, primul ar trebui eliminat din coada de evenimente, dupa cum se vede in schema de mai jos, evenimentul 4 este sters. Se poate opta pentru doua cai : o varianta in care evenimentele opuse sunt cautate pe o perioada in coada de evenimente – perioada dificil de estimat – sau o alta in care inainte de validarea unui eveniment complex sunt cautate evenimente opuse aflate dupa evenimentele simple care constituie evenimentul complex.

In al treilea rand, este evitarea redundantei. Implementarile proaste pot cauza redundanta, adica acelasi eveniment sa fie raportat in continuu. De exemplu, “MSFT este sub media mobila de 5 minute”. O paranteza aici – nu ma refer la chartul de 5 minute, ci la media mobila a ticksilor care au aparut in ultimele 5 minute, de aceea am zis ca MetaTrader ar trebui sa aibe istoric la nivel de tick si perioada tick activata. Cand aceasta se intampla, e un eveniment. Dar in secunda urmatoare, la tickul urmator, va fi raportata din nou, iar motorul trebuie sa o respinga, pentru ca este deja in coada de evenimente, asa cum e cazul cu evenimentul colorat in portocaliu din schema, care nici nu ia un numar, pentru ca este respins de la inceput. Asemenea situatii ar trebui evitate din start – motorul nu ar trebui sa piarda timp cu verificarea redundantei, altfel ar trebui sa filtreze aceste evenimente, dar e mai bine ca fluxul de evenimente sa fie curatat dinainte.

Aceasta e schema de functionare a motorului. Evenimentele de tick, sau evenimente mai complexe provin din evenimentul OnChart() care este declansat de mai multi EA Tick Event, asa cum am descris in articolul Evenimente de tick in MQL5 : complicate deocamdata, dar functionale .

Prima coloana este numarul evenimentului din coada, de la cel mai recent la cel mai vechi. Fiecare eveniment simplu, care este legat la date, are un numar alocat. Acelasi eveniment, cand are loc pe un instrument diferit, are alocat un alt numar, asa ca aceeasi secventa de evenimente care formeaza un eveniment complex va fi construit din aceleasi evenimente simple dar cu alti identificatori. Motorul trebuie sa stie ce evenimente sunt opuse, de exemplu 1 si 3, de asemenea caror evenimente le este permis sa apara de mai multe ori in lant, pentru ca unora le va fi permis (de exemplu evenimentele de executie (cele care incep cu E in schema)). Tuturor celorlalte evenimente li se interzice sa apara de mai multe ori – dar toturi nu de catre motorul propriu-zis, care anima coada de evenimente – ci chiar din faza de preprocesare.

In acelasi timp, motorul CEP trebuie sa recunoasca fiecare eveniment complex cunoscand toate aranjamentele de evenimente simple.
De exemplu, daca un eveniment complex pentru Microsoft (MSFT) consta in “10 urmat de (11 sau (12 si 13))” in 3 minute, atunci motorul va cauta , in 3 minute : 10, 11 ; 10, 12, 13 ; 10, 13, 12 insemnand toate caile alternative. Daca acelasi eveniment ar fi mapat pentru SP500 (^GSPC) , dat fiind ca toate subevenimentele au numere diferite, conditia va arata gen “5 urmat de (15 sau (16 si 17))”, avand aranjamentele ; 5, 15 ; 5, 16, 17 ; 5, 17, 16. Asemenea aranjamente pot fi date direct motorului, scrise direct in interior, sau generate cu un algoritm, transformand expresia binara, cu diferenta notabila ca “URMAT DE” e un “SI” necomutativ.. Pentru ca regulile sunt construite ca serii de evenimente ce apar intr-o anumita ordine, negatia nu poate exista la fel ca intr-o expresie binara. Poate fi implementata doar ca si interdictie de aparitie a anumitor evenimente pe parcursul restrictiei temporale sau in anumite secvente , drept simple evenimente interzise intre evenimentele cerute.

Se poate vedea ca am inclus in schema doua coloane de asociere. Adica, un eveniment simplu poate fi asociat la mai mult decat un eveniment complex, pentru ca altfel anumite reguli nu s-ar declansa niciodata. Evenimentele complexe trebuie sa aiba un set diferit de ID-uri la evenimente, pentru a nu se intersecta cu cele simple. Motorul va trimite evenimentele complexe spre a fi procesate de utilizator in EventsCallback(), dar in acelasi timp, userul le poate trimite printr-o conducta la un alt motor CEP.

Algoritmul de potrivire incepe cu constructia evenimentelor simple per fiecare eveniment complex. Matricea evenimentelor simple va contine pe fiecare linie cate un aranjament. Pentru ca verificarea este facuta invers, de la evenimentele recente catre evenimentele mai vechi, aranjamentele trebuie sa fie scrise invers in matrice. Fiecare eveniment complex va necesita o trecere prin coada de evenimente numai cata vreme se intinde constrangerea temporala, intr-o maniera verticala: prima trecere va verifica evenimentele de pe prima coloana, si evenimentele simple gasite in acest fel vor fi pre-asociate. Urmatoarea trecere va fi pe a doua coloana numai pentru aranjamentele care au avut o pre-asociere pe prima. Cand nu mai au loc pre-asocieri noi, cautarea este anulata pentru evenimentul complex in cauza. Totusi, pentru a minimiza timpul necesar, fiecare trecere va privi toate evenimentele pana are loc inceperea urmatoarei treceri. Cand cautarile sunt anulate pentru toate evenimentele, algoritmul se termina.
Cand un aranajament are toate evenimentele simple pre-asociate, e timpul pentru verificarea negatiilor. Mai intai, se verifica toata perioada pentru negatiile globale – evenimentele interzise pe toata perioada evenimentului complex, apoi pentru evenimentele interzise intre evenimentele pre-asociate, si in final verificarea de timp pentru a ne asigura ca ele inca respecta constrangerea temporala, evenimentele simple sunt asociate evenimentului complex, exceptie atunci cand in tabelul de asocieri al evenimentului simplu nu se gaseste deja aceasta asociere – pentru a evita re-asocierea lui la acelasi eveniment complex.
Evenimentul complex rezultat este pus intr-o coada si transmis la EventsCallback(). Trimiterea evenimentelor la EventsCallback() trebuie sa aiba loc dupa terminarea algoritmului altfel ar putea aparea apelari recursive ale motorului care nu isi vor inceta executia.Pentru evenimentele simple care sunt asociate, pozitia in tabelul de asocieri va fi completata cu evenimentul complex, si pozitia va incrementata cu o unitate.

Aici e un exemplu cu doua evenimente complexe is stagii difererite de pre-asociere:

Pentru evenimentul de MSFT, motorul gaseste evenimentul 12 la prima trecere, si il pre-asociaza pe al treilea aranjament. La a doua trecere, gaseste evenimentul 13, si il pre-asociaza pe al doilea aranjament. Mai gaseste si 12 inca o data, dar nu il pre-asociaza pe al doilea aranjament pentru ca a aparut inainte de 13. Daca la urmatoarea trecere gaseste evenimentul mai vechi, 10, al treilea aranjament este complet, si, in lipsa negatiilor, daca restrictia temporala inca e aplicabila, in conditiile in care evenimentul complex 1 nu a fost asociat inca, atunci evenimentele simple de pe al treilea aranjament sunt asociate evenimentului complex 1, contorul de asocieri incrementat, evenimentul pus in coada de asocieri. Pentru evenimentul de ^GSPC (evenimentul complex 2), motorul a completat deja primul aranjament. Evenimentul 5 nu apare verificat pentru al doilea si al treilea aranjament intrucat evenimentele de pe coloanele precedente nu au fost verificate.

Cat despre evenimentele de executie, acestea sunt trimise de EnumCallbacks(), eveniment al clasei DealHandler din articolul a title=”Distingirea executiilor cvasisimultane – clasa de raportare a ultimelor tranzactii” href=”http://mqlmagazine.com/ro/programarea-in-mql/distingirea-executiilor-cvasisimultane-clasa-de-raportare-a-ultimelor-tranzactii/” target=”_top”>Distingirea executiilor cvasisimultane – clasa de raportare a ultimelor tranzactii. Evenimentele simple de executie pot fi mapate in evenimente mai complex de executie deoarece tranzactiile au numere magice si comentarii, si daca ar fi sa cumperi de doua ori aceleasi 1000 de actiuni, vei stie fiecare din ce eveniment complex face parte. De aceea asemenea evenimente pot fi tratate ori separat ori in combinatie cu evenimentele de piata.

Vom veni cu un exemplu de cod intr-un articol viitor.

Acesta este o continuare a articolului nostru Introducere in optiuni. Partea a II-a : Evaluarea optiunilor si coeficientii lor . Totusi, poate fi vazut si inteles separat, pentru se axeaza pe partea de programare.

Modelele de evaluare a optiunilor sunt extrem de complicate din punct de vedere matematic. Scopul acestui articol este de a prezenta o implementare a modelului de evaluare Black-Scholes, introducand totodata metodele virtuale.

Una dintre functiile care apar mereu si mereu in matematica financiara, inclusiv in modelul Back-Scholes, este
functia distributiei cumulate (cummulative distribution function).

Functia care descrie forma de clopot a distributiei se numeste functia densitatii de probabilitate (probability density function). Zona care este sub ea, adica integrala ei definita, este functia distributiei cumulate. Si pentru cazul cu medie 0 si deviatie standard 1 (fara balans, The area that is below it, meaningly the defined integral , is the cummulative distribution function. And for the case with 0 mean and 1 standard deviation, (de asemenea fara balans, mezokurtica), aceasta distributie este numita si normala.

Integrala definita, cunoscuta ca si suma Riemann, calculeaza zona de sub graficul unei functii adaugand arii infinitezimale care se intind intre functie si axa x. Evident, procedura Riemann este intotdeauna aceeasi, pe cand functia este definita de utilizator. Atat Pascal cat si C++ permit definirea tipurilor functie. De exemplu, o declaratie C++ ar fi aratat asa:
A C++ declaration would have looked like this:

typedef  double (*SingleVarFunction) (double) ;
double Riemann(SingleVarFunction pFunc,double a, double b, int divisions)

In acest caz in C++, Riemann ar fi primit ca parametru orice functie care ar fi acceptat ca parametru un double si ar fi returnat un double ca rezultat. Totusi, acest mecanism nu exista in MQL5.

Aici intra in joc “metodele virtuale”. Obiectele au proprietati. Proprietati care sunt proiectate sa fie publice pentru a fi accesate din afara obiectelor, si apoi metodele apelate din nou. De exemplu, utilizatorul poate schimba raza unui cerc si rechema metoda de de redesenare. Dar in cazul sumei Riemann, ceea ce trebuie trimis ca si valoare este chiar o metoda. Metodele definite de utilizator care sunt apelate de metode mostenite se numesc metode virtuale.

Aceasta este implementarea MQL5 pentru suma Riemann:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

class RiemannSumCalculus
    {
     public:
     virtual double IntegratableFunction(double x)
       {
        return (0.0);
       }     
     double Riemann(double a,double b,uint divisions)
       {
        double sum,swap,stepsize,x;
        long istep;
        if (a>b) 
          {
           swap=a;
           a=b;
           b=swap;
          }
        sum=0.0;
        if (divisions==0)
          divisions=1;
        stepsize=(b-a)/divisions;
        for (istep=1;istep<=divisions;istep++)
           {
            x=a+(istep-0.5)*stepsize;
            sum=sum+IntegratableFunction(x)*stepsize;
           }
        return(sum);
       }
     };

Dupa cum se vede, metoda IntegratableFunction este specificata ca virtual. Functia in sine nu face nimic, intoarce intotdeauna un zero. Ea joaca rolul unui loc liber pentru functii IntegratableFunction definite de utilizator care sa fie apelate de metoda Riemann.

Urmatorul pas este sa avem distributia cumulata Gauss.

1
2
3
4
5
6
7
8
9
10
11
12
13
14

class GaussCummulativeFunction : public RiemannSumCalculus          
  { 
    private: double sigma;  
    public:                                 
    virtual double IntegratableFunction(double x)
       { 
        return( exp((-x*x)/(2*sigma*sigma)) );
       }
    double CummulativeDistribution(double stddev,double l1,double l2,uint divisions)
       {
        sigma=stddev;
        return( (1/(stddev*sqrt(2*M_PI))) * Riemann(l1,l2,divisions) );
       }
  };

Dupa cum se poate vedea, clasa este mostenita din RiemannSumCalculus. Functia IntegratableFunction este redefinita, si functia CummulativeDistribuition din interior apeleaza metoda Riemann mostenita, care, la randul ei, apeleaza functia locala IntegratableFunction in loc de cea mostenita care intoarce numai zerouri. Si pentru ca aceasta este o clasa, putem crea un mod mai facil de a accesa aceasta functie, apeland metoda dintr-o functie:

1
2
3
4
5

double cum_norm(double x)
  {
   GaussCummulativeFunction normaldistribution;      
   return(normaldistribution.CummulativeDistribution(1,-7.0,x,1000000));   
  }

Poate ca 1.000.000 de diviziuni e cam mult, dar e necesar pentru a pastra corectitudinea rezultatelor.

Ceea ce urmeaza este versiunea MQL5 a procedurii Black-Scholes scrisa de George Levy in cartea sa , “Computational finance using C and C++”, pagina 76 (cu mici modificari):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

struct Greeks
  {
   double delta;
   double gamma;
   double vega;
   double theta;
   double rho;
  };  
 
void black_scholes(double& value, Greeks &greeks, double s0, double x, double sigma, double t, double r, double q, bool iscall, long &iflag)
    {
     /* 
     Input parameters:
     =================
     s0 - the current price of the underlying asset
     x - the strike price
     sigma - the volatility
     t - the time to maturity
     r - the interest rate
     q - the continuous dividend yield
     iscall - true if option is a call
 
     Output parameters:
     ==================
     value - the value of the option
     greeks[] - the hedge statistics output;
     iflag - an error indicator
     */
 
     greeks.delta=0.0;
     greeks.gamma=0.0;
     greeks.vega=0.0;
     greeks.theta=0.0;
     greeks.rho=0.0;
     double one=1.0,two=2.0,zero=0.0;
     double eps,d1,d2,temp,temp1,temp2,np;
     /* Check if any of the the input arguments are too small */
     eps=1.0e-16;
     if ( (x < eps) || (sigma < eps) || (t < eps) ) 
       { 
        iflag = 2;
        return;
       }
     temp = log(s0/x);
     d1 = temp+(r-q+(sigma*sigma/two))*t;
     d1 = d1/(sigma*sqrt(t));
     d2 = d1-sigma*sqrt(t);
     /* evaluate the option price */
     if (iscall==true)
       value = (s0*exp(-q*t)*cum_norm(d1)- x*exp(-r*t)*cum_norm(d2));
     else
       value = (-s0*exp(-q*t)*cum_norm(-d1) + x*exp(-r*t)*cum_norm(-d2));
     /* then calculate the Greeks */
     temp1 = -d1*d1/two;
     d2 = d1-sigma*sqrt(t);
     np = (one/sqrt(two*M_PI)) * exp(temp1);
     if (iscall==true) 
       { 
        /* a call option */
        greeks.delta = (cum_norm(d1))*exp(-q*t); 
        greeks.theta = -s0*exp(-q*t)*np*sigma/(two*sqrt(t)) + q*s0*cum_norm(d1)*exp(-q*t)- r*x*exp(-r*t)*cum_norm(d2); 
        greeks.rho = x*t*exp(-r*t)*cum_norm(d2);
       }
     else 
       { 
        /* a put option */
        greeks.delta = (cum_norm(d1) - one)*exp(-q*t);
        greeks.theta = -s0*exp(-q*t)*np*sigma/(two*sqrt(t)) - q*s0*cum_norm(-d1)*exp(-q*t) + r*x*exp(-r*t)*cum_norm(-d2); 
        greeks.rho = -x*t*exp(-r*t)*cum_norm(-d2);
       }
     greeks.gamma = np*exp(-q*t)/(s0*sigma*sqrt(t)); 
     greeks.vega = s0*sqrt(t)*np*exp(-q*t);
    return;
    }

Si urmatoarea, din aceeasi carte, pentru a obtine volatilitatea implicita:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

void implied_volatility(double value, double s0, double x, double& sigma[],double t, double r, double q, bool iscall, long& iflag)
   {
    /* Input parameters:
    =================
    value - the current value of the option
    s0 - the current price of the underlying asset
    x - the strike price
    sigma[] - the input bounds on the volatility: sigma[0], the lower bound and, sigma[1],the upper bound
    t - the time to maturity
    r - the interest rate
    q - the continuous dividend yield
    iscall - true if option is a call;
 
    Output parameters:
    ==================
    sigma[] - the element sigma[0] contains the estimated implied volatility
    iflag - an error indicator
    */
    double zero=0.0;
    double fx, sig1, sig2;
    double val,tolx;
    double temp,eps,epsqrt,temp1,v1;
    long max_iters, i, ind, ir;
    double c[20];
    double sig,vega;
    Greeks greeks;
    long done;
    tolx = eps;
    eps=1.0e-16;
    epsqrt = sqrt(eps);
    if (iscall == true) /* a call option */
      temp1 = MathMax(s0*exp(-q*t)-x*exp(-r*t),zero);
    else /* a put option */
      temp1 = MathMax(x*exp(-r*t)-s0*exp(-q*t),zero);
    v1 = fabs(value-temp1);
    if (v1 <= epsqrt) 
      { /* the volatility is too small */
       iflag = 3;
       return;
      }
   iflag = 0;
   i = 0;
   max_iters = 50;
   done = 0;
   sig = sigma[0]; /* initial estimate */
   val = value;
   while ((i < max_iters) && (!done)) 
        { /* Newton iteration */
         black_scholes(val,greeks,s0,x,sig,t,r,q,iscall,iflag); /* compute the Black-Scholes option value, val */
         vega = greeks.vega; /* and vega. */
         sig1 = sig - ((val - value)/vega); /* compute the new estimate of sigma using Newton’s method */
         if (tolx > fabs((sig1 - sig)/sig1)) 
           { /* check whether the specified accuracy has been reached */
             done = 1;
           }
         sig = sig1; /* up date sigma */
         ++i;
        }
   sigma[0] = sig1; /* return the estimate for sigma */
   return;
  }

Acum, pastrand acestea ca pe inceputul unui script, vom completa scriptul pentru a testa modelul Black-Scholes.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
   double StockPrice=100.00;
   double SelectedStrike=100.00;
   double r=0.1;
   double sigma=0.3;
   double q=0.06;
   ObjectsDeleteAll(ChartID(),-1,-1);
   int s0;
   Greeks greeks;
   double value;
   double t;
   int T;   
   long iflag;
 
 
   for (T=10;T>=1;T--)
      {
       t=0.1*T;
       black_scholes(value, greeks, StockPrice, SelectedStrike, sigma, t, r, q, true, iflag);       
       Print(DoubleToString(t,1)," :: ",DoubleToString(value,3)," ",DoubleToString(greeks.delta,3)," ",DoubleToString(greeks.gamma,3)," ",DoubleToString(greeks.vega,3)," ",DoubleToString(greeks.theta,3)," ",DoubleToString(greeks.rho,3));
      }
   Print("Time    Value     Delta    Gamma    Vega    Theta      Rho");
   Print("Calls");
   Print("");
   for (T=10;T>=1;T--)
      {
       t=0.1*T;
       black_scholes(value, greeks, StockPrice, SelectedStrike, sigma, t, r, q, false, iflag);       
       Print(DoubleToString(t,1)," :: ",DoubleToString(value,3)," ",DoubleToString(greeks.delta,3)," ",DoubleToString(greeks.gamma,3)," ",DoubleToString(greeks.vega,3)," ",DoubleToString(greeks.theta,3)," ",DoubleToString(greeks.rho,3));
      }      
   Print("Time    Value     Delta    Gamma    Vega    Theta      Rho");   
   Print("Puts");  
   Print("");
   Print("Continuous dividend yield: ",q*100,"%");  
   Print("Implied volatility: ",sigma*100,"%");
   Print("Riskless rate: ",r*100,"%");
   Print("Selected strike: ",SelectedStrike);
   Print("Stock price: ",StockPrice);
   Print("ASSUMPTIONS: ");         
  }
//+------------------------------------------------------------------+

Si iesirea va arata in felul urmator:

Acum sterge liniile adaugate mai inainte care au completat scriptul, si adauga-le pe urmatoarele, pentru a testa functia volatilitatii implicite:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
  double S = 10.0;
  double X = 10.5;
  double r = 0.1;
  double sigmat = 0.5;
  double q = 0.04;  
  Greeks greeks;
  double sigma[2];
  double value, T;
  long i, ifail, put;
  double origsigma=sigmat;
  long flag;
  ifail = 0;
  for (i = 5;i >= 1; i--) 
    {
     T = (double)i*0.5;
     black_scholes(value,greeks,S,X,sigmat,T,r,q,true,flag);
     sigma[0] = 0.05;
     sigma[1] = 1.0;
     implied_volatility(value,S,X,sigma,T,r,q,true,flag);
     printf("%8.4f %15.4f    %15.4f     (%8.4e) ",T,value,sigma[0],fabs(sigmat-sigma[0]));  
     sigmat = sigmat - 0.1;
    }
  printf (" Time(years)  Option value  True sigma   Error");
  Print("");
  Print("Underlying= ",DoubleToString(S,2));
  Print("Strike= ",DoubleToString(X,2));
  Print("Continuous dividend yield= ",DoubleToString(q*100,2),"%");
  Print("Implied volatility= ",DoubleToString(origsigma*100,2),"%");
  Print("Riskless rate= ",DoubleToString(r*100,2),"%");
  Print("x= ",DoubleToString(X,2));
  Print("S= ",DoubleToString(S,2));
  Print("ASSUMPTIONS");  
  return;
 }

Scriptul pune niste valori in modelul Black-Scholes, obtine valoarea optiunilor, seteaza un iunterval de estimare si apeleaza functia volatilitatii implicite, care da rezultate destul de corecte:

Volatilitate. Un cuvant care genereaza panica pentru investitori, ca si batai de inima mai accelerate pentru traderi. De cate ori inainte n-ai incercat sa tranzactionezi numai pietele in trend si sa prinzi momentum-ul ?

Dupa InvestorWords.com, volatilitatea este rata relativa la care pretul unei valori mobiliare se misca in sus si in jos. Volatilitatea este gasita calculand deviatia standard anualizata a schimbarilor zilnice de pret. Daca pretul unei actiuni se misca in sus sau in jos rapid in perioade scurte de timp, are volatilitate ridicata. Daca pretul aproape ca nu se schimba deloc, are volatilitate redusa. Deci volatilitatea este masurata de deviatia standard (notata cu litera greceasca sigma mica). Si care e cel mai popular indicator bazat pe deviatia standard? Ati ghicit, faimoasele Benzi Bollinger. Benzile Bollinger (BB) sunt printre primii indicatori pe care ai invatat sa-i folosesti in trading. Ti s-a spus ca, un semnal de cumparare sau de vanzare cand piata atinge una dintre benzi, este urmat de un posibil mers pe langa una dintre benzi, dupa care se intoarce, si va merge asa pana cand atinge media mobila. Regula asta nu spune prea mult. Nu exista nimic care sa spuna cat anume va merge pe langa banda pana cand se intoarce. Lucru care il vei descoperi foarte frustrant… pe contul propriu. Daca reprezinti grafic baza acestui indicator, deviatia standard, vei gasi un chart sinusoidal. Volatilitatea se misca in sus si in jos intr-o maniera relativ continua, fara miscari bruste. Din moment ce nu face miscari bruste, inseamna ca volatilitatea e mai predictibila decat pretul. Daca e predictibila, de ce sa nu folosim BB peste volatilitate ? Dar stai. Deviatia standard e relativa. Ea masoara dispersia pe perioada analizata. Daca adaugam BB peste deviatia standard, inseamna ca vom folosi deviatia standard a deviatiei standard pentru a prinde miscarile volatilitatii. De data asta nu e nevoie sa ne temem de semnale false, pentru ca setul analizat de date, deviatia standard calculata asupra pretului, este o functie continua. In al doilea rand, chiar daca semnalul este gresit si volatilitatea se intoarce inapoi si se misca pe un trend descrescator, nu mai produce stricaciuni prea mari, pentru ca volatilitatea este deja jos cand un semnal este preluat si o miscare in jos a volatilitatii va insemna o miscare mai mica a pretului . Linia albastruie este deviatia standard a pretului de deschidere a ultimelor 20 de bare. Semnalele in care suntem interesati sunt cele in care volatilitatea intersecteaza propria bara Bollinger de sus. Bineinteles, nu suntem interesati in intersectiile in jos, pentru ca acestea inseamna ca volatilitatea se reduce mai repede decat ar fi normal. In timpul unui trend, o puternica contramiscare va fi reflectata printr-o miscare a volatilitatii in jos. Cele mai bune semnale apar atunci cand intersectiile cu BB de sus apar la o volatilitate istorica foarte redusa – sub 20% din intervalul de pe ecran. Daca e sa compari cu celelalte semnale de pe chart, BB peste pret intersectata cu pretul, vei vedea ca pot aparea intersectii chiar cand volatilitatea este in interiorul propriei ei BB, asadar acesta este un mod de a elimina afinitatea pentru erori a semnalelor date de intersectia pretului cu BB.  Un criteriu bun intrare-iesire este atunci cand distanta dintre BB de sus a volatilitatii si volatilitate este sub 2% din intervalul de fluctuare a volatilitatii. Mai jos este versiunea MQL4 a indicatorului Benzi Bollinger peste Deviatia Standard.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

//+------------------------------------------------------------------+
//|                                                    BBoverSTD.mq4 |
//|                                                 Bogdan Caramalac |
//|                                     mailto:fxeconomist@yahoo.com |
//+------------------------------------------------------------------+
#property copyright "Bogdan Caramalac"
#property link      "mailto:fxeconomist@yahoo.com"
 
#property indicator_separate_window
#property indicator_buffers 4
#property indicator_color1 LightSeaGreen //STDDEV
#property indicator_color2 Blue          //MA
#property indicator_color3 Yellow        //Upper BB
#property indicator_color4 Yellow        //Lower BB
 
//---- input parameters
extern int       STDLEN=20;
extern int       BBLEN=10;
extern double    BBMULT=2.0;
extern string    MATYPE="SMA";
extern int       MALEN=0;
extern int       Logarithm=0;
 
double ExtMapBuffer1[];
double ExtMapBuffer2[];
double ExtMapBuffer3[];
double ExtMapBuffer4[];
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
  {
//---- indicators
   SetIndexStyle(0,DRAW_LINE, 0, 1, indicator_color1);
   SetIndexBuffer(0, ExtMapBuffer1);
   SetIndexStyle(1,DRAW_LINE, 0, 1, indicator_color2);
   SetIndexBuffer(1, ExtMapBuffer2);
   SetIndexStyle(2,DRAW_LINE, 0, 1, indicator_color3);
   SetIndexBuffer(2, ExtMapBuffer3);
   SetIndexStyle(3,DRAW_LINE, 0, 1, indicator_color4);
   SetIndexBuffer(3, ExtMapBuffer4);
//----
   SetIndexDrawBegin(0,STDLEN);
 
   SetIndexDrawBegin(1,STDLEN+BBLEN-1);
   SetIndexDrawBegin(2,STDLEN+BBLEN-1);
   SetIndexDrawBegin(3,STDLEN+BBLEN-1);
   return(0);
  }
 
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start()
   {
   if (Bars<=MathMax(STDLEN+BBLEN,MALEN))      
      return(0);    
   int pos=Bars-1;    
   ArraySetAsSeries(ExtMapBuffer1,true);    
   while (pos>=0)
     {
      if (MATYPE=="SMA")
        {
         ExtMapBuffer1[pos]=iStdDev(Symbol(),Period(),STDLEN,0,MODE_SMA,MODE_OPEN,pos);
         if (Logarithm==1&&ExtMapBuffer1[pos]!=0.00)
           ExtMapBuffer1[pos]=MathLog(ExtMapBuffer1[pos]);
        }
      if (MATYPE=="EMA")
        {
         ExtMapBuffer1[pos]=iStdDev(Symbol(),Period(),STDLEN,0,MODE_EMA,MODE_OPEN,pos);
         if (Logarithm==1&&ExtMapBuffer1[pos]!=0.00)
           ExtMapBuffer1[pos]=MathLog(ExtMapBuffer1[pos]);
        }
      if (MATYPE=="SMMA")
        {
         ExtMapBuffer1[pos]=iStdDev(Symbol(),Period(),STDLEN,0,MODE_SMMA,MODE_OPEN,pos);
         if (Logarithm==1&&ExtMapBuffer1[pos]!=0.00)
           ExtMapBuffer1[pos]=MathLog(ExtMapBuffer1[pos]);
        }
      if (MATYPE=="LWMA")
        {
         ExtMapBuffer1[pos]=iStdDev(Symbol(),Period(),STDLEN,0,MODE_LWMA,MODE_OPEN,pos);
         if (Logarithm==1&&ExtMapBuffer1[pos]!=0.00)
           ExtMapBuffer1[pos]=MathLog(ExtMapBuffer1[pos]);
        }
       pos--;
     }
   pos=Bars-1;
   while(pos>=0)
     {
      if (MATYPE=="SMA")
        {
         if (MALEN!=0)
           ExtMapBuffer2[pos]=iMAOnArray(ExtMapBuffer1,0,MALEN,0,MODE_SMA,pos);
         else
           ExtMapBuffer2[pos]=EMPTY_VALUE;
        }
      if (MATYPE=="EMA")
        {
         if (MALEN!=0)
           ExtMapBuffer2[pos]=iMAOnArray(ExtMapBuffer1,0,MALEN,0,MODE_EMA,pos);
         else
           ExtMapBuffer2[pos]=EMPTY_VALUE;
        }
      if (MATYPE=="SMMA")
        {
         if (MALEN!=0)
           ExtMapBuffer2[pos]=iMAOnArray(ExtMapBuffer1,0,MALEN,0,MODE_SMMA,pos);
         else
           ExtMapBuffer2[pos]=EMPTY_VALUE;
        }
      if (MATYPE=="LWMA")
        {
         if (MALEN!=0)
           ExtMapBuffer2[pos]=iMAOnArray(ExtMapBuffer1,0,MALEN,0,MODE_LWMA,pos);
         else
           ExtMapBuffer2[pos]=EMPTY_VALUE;
        }
       pos--;
     }
   pos=Bars-1;
   while(pos>=0)
     {
      ExtMapBuffer3[pos]=EMPTY_VALUE;
      ExtMapBuffer4[pos]=EMPTY_VALUE;
      ExtMapBuffer3[pos]=iBandsOnArray(ExtMapBuffer1,0,BBLEN,BBMULT,0,MODE_HIGH,pos);
      ExtMapBuffer4[pos]=iBandsOnArray(ExtMapBuffer1,0,BBLEN,BBMULT,0,MODE_LOW,pos);
      pos--;
     }
   return(0);
  }

Parametri:

STDLEN – perioada pentru care deviatia standard este calculata;

BBLEN – pentru care sunt calculate Benzile Bollinger;

BBMULT – multiplicatorul deviatiei standard pentru Benzile Bollinger;

MATYPE – o medie mobila ajutatoare este creata, de acest tip ; acelasi tip este aplicat la constructia deviatiei standard in primul moment;

MALEN – perioada mediei mobile ajutatoare (este dezactivata cu 0);

Logarithm – folosit logaritmarea deviatiei standard ; pentru 0, dezactivata, pentru 1, logaritm natural;

Multumiri lui Irtron si Ruptor de pe forumul mql4.com pentru reparatii aduse acestui indicator.

Functia iMAOnArray are probleme ; un indicator MQL4 trebuie sa contina mai mult decat un singur loop de calculatie daca foloseste aceasta functie.

Sa ne uitam la anatomia unui indicator MQL4.

Liniile 9 – 15 formeaza preambulul indicatorului ; este specificat daca indicatorul este intr-o fereastra separata , numarul de buffere si culoarea pentru fiecare.

Liniile 17 – 22 includ definitiile parametrilor ; ceea ce-i face sa fie parametri, spre deosebire de cele ce sunt cunoscute sub numele de variabile globale in alte limbaje de programare (de exemplu declaratiile Public in Visual Basic) este cuvantul extern in fata tipului ; cand indicatorul este instalat (tras cu mouse-ul pest chart) , acesti parametri pot fi modificati . De asemenea, acesti parametri poti fi modificati oricand de catre utilizator ; dar nici un expert sau script nu se poate atinge de parametri indicatorului care ruleaza intr-o fereastra.

Liniile 24 – 27 cuprind definitiile bufferelor ; intrucat 4 sunt specificate, 4 sunt definite. Bufferele indicatorului sunt numere care specifica tablouri in interiorul indicatorului, care contin date. De exemplu, daca un indicator ar copia datele OHLC in buffere, 0 ar fi pentru preturile de deschidere, 1 pentru high, 2 pentru low, 3 pentru inchidere. In cazul nostru, asa cum o sa vezi mai jos, 0 este pentru deviatia standard, 1 pentru media mobila ajutatoare, 2 pentru BB superioara si 3 pentru BB inferioara.

Liniile 31 – 49 constituie functia init() . Functia este apelata de fiecare data cand parametrii chartului sunt schimbati (simbol, periodicitate) sau conexiunea, intrerupta, revine. Functia defineste stilul de desenare pentru fiecare dintre buffere si asigneaza tablouri bufferelor indicatorului. De asemenea specifica unde incepe desenarea pentru fiecare buffer. Punctul de desenare trebuie sa fie ales cu grija, astfel incat datele care sunt la baza sa fie deja calculate la momentul respectiv. De exemplu, daca e sa calculezi media mobila pentru 10 elemente, punctul de incepere trebuie sa nu fie mai mare de 10 elemente sub numarul maxim de bare.

Liniile 54 – 131 constituie functia start() . Aceasta este apelata dupa functia la fiecare cotatie sosita. Incepe cu o conditie in care verifica daca sunt suficiente bare (Bars) ca sa deseneze indicatorul. Apoi seteaza pozitia de inceput a desenarii. Pozitia este un index de bara. Indicatorul este calculat de la o pozitie pozitiva care zero (bara curenta). Functia ArraySetAsSeries() altereaza modul de functionarea al unui tablou, facandu-l sa functioneze ca o serie temporala. Nu afecteaza tabloul per se. Ci spune unor functii speciale care lucreza cu tablouri sa-l trateze inversat. Functiile care calculeaza indicatori peste tablouri (ca iMAOnArray() , iStdDevOnArray() s.a.m.d.) traverseaza tabloul de la stanga spre dreapta, de la indecsi mai mici spre indecsi mai mari. Functia ArraySetAsSeries() aplicata unui tablou fac ca aceste functii sa traverseze tabloul de la dreapta la stanga, de la indecsi mai mari la indecsi mai mici, exact cum face bucla principala a unui indicator. Ce urmeaza apoi sunt buclele. Un indicator simplu calculeaza cam totul intr-o singura bucla, dar aici sunt necesare trei pentru a rezolva problemele. Primul loop va calcula deviatia standard ; al doilea va calcula media mobila ajutatoare, iar al treilea va calcula Benzile Bollinger.

Acelasi indicator, versiunea MQL5

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

//+------------------------------------------------------------------+
//|                                                    BBoverSTD.mq5 |
//|                                       Copyright Bogdan Caramalac |
//|                                                  mqlmagazine.com |
//+------------------------------------------------------------------+
#property copyright "Bogdan Caramalac"
#property link      "mqlmagazine.com"
#property version   "1.02"
 
#property indicator_separate_window
#property indicator_buffers 4
#property indicator_applied_price PRICE_OPEN
 
#property indicator_plots   4
#property indicator_type1 DRAW_LINE
#property indicator_label1 "Stddev"
#property indicator_color1 LightSeaGreen //STDDEV
#property indicator_type2 DRAW_LINE
#property indicator_label2 "Helper MA"
#property indicator_color2 Blue          //MA
#property indicator_type3 DRAW_LINE
#property indicator_label3 "Upper BB"
#property indicator_color3 Yellow        //Upper BB
#property indicator_type4 DRAW_LINE
#property indicator_label4 "Lower BB"
#property indicator_color4 Yellow        //Lower BB
 
//---- input parameters
input int       STDLEN=20;
input int       BBLEN=10;
input double    BBMULT=2.0;
input string    MATYPE="SMA";
input int       MALEN=2;
input int       Logarithm=0;
 
double ExtMapBuffer1[];
double ExtMapBuffer2[];
double ExtMapBuffer3[];
double ExtMapBuffer4[];
 
#include <MovingAverages.mqh>
 
int StdDevHandle;
 
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- indicator buffers mapping
   SetIndexBuffer(0, ExtMapBuffer1);
   SetIndexBuffer(1, ExtMapBuffer2);
   SetIndexBuffer(2, ExtMapBuffer3);
   SetIndexBuffer(3, ExtMapBuffer4);
//----
   PlotIndexSetInteger(0,PLOT_DRAW_BEGIN,STDLEN);
   PlotIndexSetInteger(1,PLOT_DRAW_BEGIN,STDLEN+BBLEN-1);
   PlotIndexSetInteger(2,PLOT_DRAW_BEGIN,STDLEN+BBLEN-1);
   PlotIndexSetInteger(3,PLOT_DRAW_BEGIN,STDLEN+BBLEN-1);
//---
   //we create iStdDev handler for use in main cycle;
   if (MATYPE=="SMA")
     StdDevHandle=iStdDev(Symbol(),Period(),STDLEN,0,MODE_SMA,PRICE_OPEN);
   if (MATYPE=="EMA")
     StdDevHandle=iStdDev(Symbol(),Period(),STDLEN,0,MODE_EMA,PRICE_OPEN); 
   if (MATYPE=="LWMA")
     StdDevHandle=iStdDev(Symbol(),Period(),STDLEN,0,MODE_LWMA,PRICE_OPEN); 
   if (MATYPE=="SMMA")
     StdDevHandle=iStdDev(Symbol(),Period(),STDLEN,0,MODE_SMMA,PRICE_OPEN);  
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime& time[],
                const double& open[],
                const double& high[],
                const double& low[],
                const double& close[],
                const long& tick_volume[],
                const long& volume[],
                const int& spread[])
   {
    double res[]; //array to hold current iStdDev value;
    double buffer_helper[500];
    double stddevonstddev=0.0;    //current stddev on stddev
    double squaredsum=0.0;        //current squared sum
    double bbma=0.0;              //current ma for bollinger bands calculus
    double bbsum=0.0;             //current sum for calculus of bbma
    double prevma=0.0;            //previous helper moving average value, for use with SMMA or LWMA   
    int buff_stddevs=0;           //used length of stddevs buffer
    int buff_helper_len=0;        //used length of helper buffer   
    int startpos=MathRound(MathMin(prev_calculated,rates_total-1)); //this is the start position ; it goes UPWARD, we are on an array, not on series
    if (rates_total<STDLEN)
      return(rates_total);
    if (startpos<STDLEN)
      startpos=STDLEN;
    for (int pos=startpos;pos<rates_total;pos++) //main cycle, going from startpos to rates_total
       {
        //Reads 1 element from position rates_total-pos, buffer 0 of StdDevIndicator calculus designated by StdDevHandle
        //rates_total-pos to convert position ; buffers are time series (curent value has index 0)
        CopyBuffer(StdDevHandle,0,rates_total-pos,1,res);
        ExtMapBuffer1[pos]=res[0];//copy value from temporary res[0] array index to final ExtMapBuffer1        
        if (Logarithm==1)
          ExtMapBuffer1[pos]=MathLog(ExtMapBuffer1[pos]);
        if (Logarithm==2)
          ExtMapBuffer1[pos]=MathLog10(ExtMapBuffer1[pos]);
        if (pos>STDLEN+BBLEN)
          {
           //enough values to calculate Bollies over volatility
           squaredsum=0.0;
           bbsum=0.0;
           //calculating the moving average for bollinger bands
           for (int j=pos-BBLEN+1;j<=pos;j++)
              bbsum=bbsum+ExtMapBuffer1[j];
           bbma=bbsum/BBLEN;
           //calculating the squared sum for the stddev over stddev needed for bollinger bands
           for (int j=pos-BBLEN+1;j<=pos;j++)
              squaredsum=squaredsum+(ExtMapBuffer1[j]-bbma)*(ExtMapBuffer1[j]-bbma);
           //stddev on stddev and bollinger bands
           stddevonstddev=MathSqrt(squaredsum/BBLEN);
           ExtMapBuffer3[pos]=bbma+BBMULT*stddevonstddev;
           ExtMapBuffer4[pos]=bbma-BBMULT*stddevonstddev;
           if (pos>MALEN+BBLEN+STDLEN)
             {
              if (MALEN!=0) //goes in only if helper moving average is indeed enabled
                {
                 //making buffer for helper MA
                 for (int j=1;j<=MALEN;j++)    
                    buffer_helper[MALEN-j+1]=ExtMapBuffer1[pos-j+1];            
                 //calculating different kinds of moving averages, by calling moving average methods from MovingAverages.mqh
                 if (MATYPE=="SMA")
                   ExtMapBuffer2[pos]=SimpleMA(MALEN,MALEN,buffer_helper);
                 if (MATYPE=="EMA")
                   {
                    ExtMapBuffer2[pos]=ExponentialMA(MALEN,MALEN,prevma,buffer_helper);
                    prevma=ExtMapBuffer2[pos];
                   }
                 if (MATYPE=="SMMA")
                   {
                    ExtMapBuffer2[pos]=SmoothedMA(MALEN,MALEN,prevma,buffer_helper);
                    prevma=ExtMapBuffer2[pos];
                   }
                 if (MATYPE=="LWMA")
                   ExtMapBuffer2[pos]=LinearWeightedMA(MALEN,MALEN,buffer_helper);      
                }//if (MALEN!=0)
             }//if (pos>MALEN+STDLEN)                           
          }//else if if (buff_stddevs<BBLEN)
       }//for (pos=startpos;pos<rates_total;pos++)
   return(rates_total);
  }
//+------------------------------------------------------------------+

Ei bine, programarea in MQL5 este semnificativ mai dificila. MQL5 are un mod total diferit de gandire a indicatorilor, asa incat comparatiile cu MQL4 nu si-ar avea sensul. Indicatorul incepe intr-o maniera similara, cu un intro mai larg, liniile 10-26. Acest intro are un mult mai mare numar de setari comparativ cu MQL4. Apoi urmeaza parametrii, liniile 29-34, si in final bufferele, liniile 36-39. Observa in liniile 29-34 inlocuirea lui extern cu input , care-i ia locul in MQL5. extern ramane valabil in MQL5, dar are un alt rol.

Pana aici nu pare prea complicat, deoarece codul este similar cu MQL4. Dar de aici, ia o cu totul diferita turnura…
Mai intai, o includere a MovingAverages.mqh pe linia 41. Aceasta va fi necesara mai jos, deoarece diferitele calculatii de medii mobile sunt realizate prin apeluri la rutine din aceasta biblioteca. Apoi, pe linia 43, o declaratie publica a handlerului pentru indicatorul Standard Deviation (numai unul, pentru ca alegem in functie de tipul mediei mobile).. In MQL5, apelurile la indicatori nu intorc valori, asa cum faceau in MQL4. Ci, intorc un handler. Acest handler este necesar ulterior pentru a intoarce valorile indicatorului, prin apeluri la CopyBuffer(). OnInit(), intinzandu-se pe liniile 48-71, este similar cu init() din MQL4, cel putin pe liniile 50-59, unde incep asignarile bufferelor si setarile desenelor. OnInit() se termina cu apeluri la iStdDev ; indicatorul va fi folosit in bucla principala, dar handlerul este generat o singura data! Patru apeluri catre iStdDev, generand un handler unic in functie de tipul de mobila specificat de parametrul MATYPE.

Evenimentul OnCalculate() este practic noua bucla principala. Functia are un prototip destul de misterios. Detaliile de implementare nu sunt cunoscute complet, deci functia permite o serie larga de prototipuri. Cel pe care l-am folosit in indicator este cel pe care il obtii ca default creezi indicatorul. Spre deosebire de MQL4, unde barele sunt descendente de la Bars la 0, bara curenta, in MQL5, indecsii barelor sunt ascendenti de la prev_calculated-1 to rates_total-1.

Urmand declaratiile variabilelor, bucla incepe la linia 100. Primul lucru de facut, e sa primim valoarea curenta a deviatiei standard. Pentru ca avem handlerul, apelam CopyBuffer() ca sa obtinem prima valoare a deviatiei standard. Pozitia curenta este variabila de ciclu pos. Totusi, CopyBuffer() intelege pozitia ca o pozitie intr-o serie temporala, nu ca o pozitie intr-un tablou. De aceea, vom copia o valoare de la rates-total-pos, din prima serie, 0. Daca indicatorul ar fi returnat mai multe valori, de exemplu Heiken Ashi, de exemplu, care intoarce informatii de bare, am fi avut mai mult decat o serie, adresand seriile 0,1,2 si 3 pentru a obtine preturile barelor Heiken Ashi. Valorile pe care le obtinem cu CopyBuffer() sunt puse intr-un tablou. Dar avem nevoie de un singur numar, deci tabloul in care punem datele, res va detine o singura valoare, res[0] , care este copiata catre primul nostru buffer, ExtIndexBuffer1, si apoi logaritmarea este aplicata, in functie de parametrul Logarithm, liniile 106-109 (acum logaritmul zecimal este inclus si el, pe langa cel natural).

Ce urmeaza e destul de usor de urmarit. Numaram daca avem destule valori pentru a incepe calculul Benzilor Bollinger peste deviatia standard. Cand avem destule date (ramura de “if” de la linia 110) , ne intoarcem inapoi BBLEN valori si calculam media, apoi mai facem bucla o data si calculam deviatia standard peste deviatia standard, si incele din urma Benzile Bollinger, liniile 124-125.

La fel ca inainte, dar acum conditia este sa avem o deviatie standard peste deviatia standard calculata, verificam daca avem MALEN valori din acestea, pentru a calcula prima medie mobila ajutatoare. Dar spre deosebire de data trecuta, acum copiem valorile deviatiei standard initiale intr-un buffer. Bufferul se va intinde de la MALEN catre 1, cu indecsi mai mari pentru valorile mai vechi. Motivul pentru a face asta e ca vom transmite acest buffer drept parametru catre metodele de calcul ale mediilor mobile importate din MovingAverages.mqh, si implementarea lor interna este trecerea in acest fel prin tablouri. Acestea sunt functii simple. Spre deosebire de indicatori, rezultatele lor sunt raspunsuri la calculele interne, nu handlere. Si aceste rezultate sunt scrise in bufferul mediei mobile ajutatoare, ExtMapBuffer2. Dupa calculul mediei mobile ajutatoare, toate calculele sunt terminate si bucla se inchide.

Previziunea volatilitatii

De aceea am inclus in indicator o medie mobila ajutatoare : pentru a ajuta la previziunea volatilitatii. As pune accentul, totusi, ca anumite cerinte cheie sa fie intrunite inainte de a trece la analiza:
1. Distanta dintre Benzile Bollinger sa fie sub 2% din intervalul istoric al deviatiei standard – asta va asigura ca semnalul nu are loc accidental atunci cand Benzile Bollinger sunt prea departe una de alta.
2. Deviatia standard curenta sa fie sub 5% din maximul deviatiei standard istorice -asta va asigura ca e o sansa ridicata sa urmeze o explozie a volatilitatii dupa ce semnalul se produce.

Semnalul normal va fi o intersectie cu BB superioara. Semnalul de iesire va fi determinarea unei slabiri in viteza volatilitatii. Si aceasta se intampla cand volatilitatea isi atinge varful in timp ce BB superioara continua sa creasca. Pentru a determina aceasta foarte rapid, vom folosi o medie mobila rapida – cu o perioada de 2. Odata ce se intersecteaza cu volatilitatea, deja se poate considera semnalul de iesire. Dar poate fi determinat chiar si mai repede, cand exista o distanta prea mare intre BB superioara si deviatia standard. Una din cele mai bune interpretari ale chartului se va face convertind data – BB , deviatia standard, media mobila, etc. in echivalentele lor grafice – coordonate punct pe chart. Asta iti va spune de exemplu cand deviatia standard atinge BB superioara.

Intrucat calculezi BB pentru un numar fix de bare – poate WindowBarsPerChart() – care da numarul total de bare din fereastra unde ruleaza expertul sau indicatorul , sau un numar dat de bare, si extragi valoarea maxima a BB superioara , si valoarea minima a BB inferioara , sa le numim bbmax si bbmin – poti calcula o pozitie grafica a oricarei valori (fie ea BB, deviatie standard sau medie mobila ajutatoare) , folosind o inaltime a unui ecran ipotetic (sa zicem 300 de pixeli “virtuali”). Sa numim aceasta valoare testvalue. Atunci pozitia lui testvalue pe ecran va fi :

double pozitie=MathRound( inaltime*(testvalue-bbmin)/bbmax );

In acest fel, o conditie compozita ar fi ca, dupa ce conditiile 1. si 2. sunt indeplinite, sa existe o incrucisare orio atingere.
Criteriul de iesire va fi : deviatia standard este sub BB superioara si nu mai exista nici o atingere. Totusi, la primul semn de slabiciune a volatilitatii, semnalul de iesire va fi lansat, si s-ar putea intampla prea devreme. Ar trebui verificat statutul atingerii folosind o rezolutie mai mica.

Exista doua situatii posibile care contribuie la cresterea deviatiei standard : ori preturile se duc in sus sau in jos intr-o maniera accelerata ori preturile schimba directia de la sus la jos si viceversa cu o amplitudine crescatoare.

Daca volatilitatea ultimelor bare continua sa creasca, putem presupune prima conditie : preturile sunt in trend. In acest caz, verificam ultimele 2-3 preturi de deschidere pentru a vedea directia si a o tranzactiona, daca e stabila. Dar, indiferent daca directia e stabila sau nu, volatilitatea se poate duce in sus. Fluctuatiile de pret pot urmari o schema sus-jos cu o amplitudine crescatoare, pana cand directia se stabilizeaza. Totusi, volatilitatea este in continuare coborata. Fiind coborata, inseamna ca preturile nu se misca suficient de mult – ne putem permite sa pierdem . Nu conteaza ce directie tranzactionam, verificam la fiecare bara daca directia a fost corecta. Daca nu, taiem pierderile si tranzactionam din nou. Pentru ca daca semnalul e corect si volatilitatea va traversa intre 30% si 70% din intervalul sau istoric, ne asteptam la bani multi!

Previziunea volatilitatii e destul de simpla, si e mai mult manuala decat automata. Din moment ce ne asteptam ca volatilitatea sa “treaca prin acoperis”, putem face o previziune liniara sau parabolica. Modelul liniar e simplu. Daca avem deviatia curenta pe bara 0 (s0) si deviatia standard asteptata pentru bara m (sm), atunci avem volatilitatea previzionata per bara dupa functia f(bar)=so+(sm-so)*bar/m.

Modelul parabolic este mai dificil, pentru ca necesita un punct in plus pentru definirea curburii. Acesta este rezolvabil cu un sistem de ecuatii. Fiind date 3 puncte (b1,stddev1) , (b2,stddev2) , (b3,stddev3) unde b1, b2, b3 sunt indecsii barelor, iar stddev1,stddev2,stddev3 sunt deviatiile standard estimate :

Odata ce avem parametrii functiei de gradul al II-lea care descrie deviatia standard trecand prin punctele estimate, putem genera deviatia standard pe fiecare bara , vezi scriptul MQL4 :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

double Determinant(double &origa[][],int l1,int c1,int l2,int c2,int jumpline,int jumpcol)
    {
    double a[50,50];
    int degree,i,j,ip,jp,dets;
    double result=0;
    double reshere=0;
    double r;
    string image;
    int ipm,jpm;
    for (i=0;i<50;i++)
       {
       for (j=0;j<50;j++)
          a[i,j]=0.0;
       }
    if (l1==0)
       l1=1;
    if (c1==0)
       c1=1;
    degree=c2-c1+1;
    if (jumpcol!=0)
       degree=degree-1;
    ip=1;
    for (i=l1;i<=l2;i++)
      {
      ipm=ip-1;       
      jp=1;
      if (i!=jumpline)
        {
        for (j=c1;j<=c2;j++)
          {
          jpm=jp-1;
          if (j!=jumpcol)
             {
             r=origa[i-1,j-1]*1.0;                          
             a[ipm,jpm]=r;             
             jp=jp+1;
             }
          }//for (j=c1;j<=c2;j++c2)              
        ip=ip+1;
        }//if (i!=jumpline)
      }//for (i=l1;i<=l2;i++)
    result=0;
    if (degree==1)
       result=0;  
    if (degree==2)
       result=a[1-1,1-1]*a[2-1,2-1]-a[2-1,1-1]*a[1-1,2-1];
    if (degree==3)
       result=a[1-1,1-1] * a[2-1,2-1] * a[3-1,3-1] + 
              a[1-1,2-1] * a[2-1,3-1] * a[3-1,1-1] + 
              a[1-1,3-1] * a[2-1,1-1] * a[3-1,2-1] - 
              a[1-1,3-1] * a[2-1,2-1] * a[3-1,1-1] - 
              a[1-1,2-1] * a[2-1,1-1] * a[3-1,3-1] - 
              a[1-1,1-1] * a[2-1,3-1] * a[3-1,2-1] ;    
    if (degree>3)
       {
       for (dets=1;dets<=degree;dets++)
           {
           reshere=Determinant(origa,1,1,degree,degree,1,dets);
           result=result + MathPow(-1,1+dets)*origa[1-1,dets-1]*reshere;
           }
       }
    return(result);
    }
 
void EstablishStddevFunction(int b1,double stddev1,int b2,double stddev2,int b3,double stddev3,double &a, double &b, double &c)
  {
   double d,da,db,dc;
   double barray[3];
   double stddev[3];
   double det_d[3][3];
   double det_da[3][3];
   double det_db[3][3];
   double det_dc[3][3];
   barray[0]=b1*1.0;
   barray[1]=b2*1.0;
   barray[2]=b3*1.0;
   stddev[0]=stddev1;
   stddev[1]=stddev2;
   stddev[2]=stddev3;
   det_d[0][0]=barray[0]*barray[0];  det_d[0][1]=barray[0];   det_d[0][2]=1;   
   det_d[1][0]=barray[1]*barray[1];  det_d[1][1]=barray[1];   det_d[1][2]=1;
   det_d[2][0]=barray[2]*barray[2];  det_d[2][1]=barray[2];   det_d[2][2]=1;
 
   det_da[0][0]=stddev[0];  det_da[0][1]=barray[0];   det_da[0][2]=1;   
   det_da[1][0]=stddev[1];  det_da[1][1]=barray[1];   det_da[1][2]=1;
   det_da[2][0]=stddev[2];  det_da[2][1]=barray[2];   det_da[2][2]=1;
 
   det_db[0][0]=barray[0]*barray[0];  det_db[0][1]=stddev[0];   det_db[0][2]=1;   
   det_db[1][0]=barray[1]*barray[1];  det_db[1][1]=stddev[1];   det_db[1][2]=1;
   det_db[2][0]=barray[2]*barray[2];  det_db[2][1]=stddev[2];   det_db[2][2]=1;
 
   det_dc[0][0]=barray[0]*barray[0];  det_dc[0][1]=barray[0];   det_dc[0][2]=stddev[0];   
   det_dc[1][0]=barray[1]*barray[1];  det_dc[1][1]=barray[1];   det_dc[1][2]=stddev[1];
   det_dc[2][0]=barray[2]*barray[2];  det_dc[2][1]=barray[2];   det_dc[2][2]=stddev[2];
 
   d=Determinant(det_d,1,1,3,3,0,0);
   da=Determinant(det_da,1,1,3,3,0,0);
   db=Determinant(det_db,1,1,3,3,0,0);
   dc=Determinant(det_dc,1,1,3,3,0,0);   
   a=da/d;
   b=db/d;
   c=dc/d;
  }
 
//+------------------------------------------------------------------+
//| script program start function                                    |
//+------------------------------------------------------------------+
int start()
  {
   double aa,bb,cc;
   Print("Standard Deviation parabolic forecasting example");        
   EstablishStddevFunction(0,0.003,3,0.006,9,0.1,aa,bb,cc);
   Print("Forecasted standard deviations");
   for (int bar=0;bar<10;bar++)
      {
       Print("bar ",DoubleToStr(bar,0),"  stddev=",DoubleToStr(aa*bar*bar+bb*bar+cc,4));
      }
   return(0);
  }
//+------------------------------------------------------------------+

De observat ca functia Determinant are o aplicatie recursiva, pana la gradul 3, unde se aplica regula lui Sarrus. Astfel poti folosi functia pentru a calcula determinanti de ordinul n – dar atentie la timp si cerintele de alocare a memoriei. Un prototip MQL5 al functiei
Determinant va arata in felul urmator:

double Determinant(double &origa[][50],ushort l1,ushort c1,ushort l2,ushort c2,ushort jumpline,ushort jumpcol)

De observat ca a doua dimensiune este fixata la 50. MQL5 nu suporta dimensiuni mai mari decat unu cu marime nespecificata.

Toate acestea pot suna bine, dar nu uitati ca nu tranzactionam volatilitatea . Nu avem inca o directie a pretului.

Dar directia pretului poate fi extrasa din evolutia volatilitatii.

Previziunea pretului din previziunea volatilitatii

Trebuie sa consideram ca la fiecare bara, un pret iese din analiza si altul intra in loc. Daca avem Vechiul pentru cel mai vechi pret si Noul pentru pretul care intra, avem:

Noua Medie = Vechea Medie – Vechiul/N + Noul/N ;

Acum, dat fiind faptul ca am trasat deja deviatiile standard care vor veni, intrebarea este care este noul pret care va da noua deviatie standard la rand ?

Asa ca luam deviatia standard, obtinuta cu modelul de previziune, si o ridicam la patrat. Avem astfel dispersia. Inmultind dispersia cu N (numarul de preturi din analiza) , incepem sa formam ecuatia pentru membrul cel mai nou. Luand in consideratie n , elemente, de la P1 (elementul care va iesi din analiza) , la Pn (ultimul element), Pn+1 (noul pret care trebuie sa fie determinat) si media mobila curenta, formam ecuatia deviatiei standard, ridicand la patrat si inmultind-o cu n, care da suma patratelor Pi – noua medie, care este calculata ca mai sus, scotand influenta lui P1 si adaugand influenta lui Pn+1. Folosim o variabila ajutatoare, avgc , care este media curenta fara influenta lui P1: (Nu mai e nevoie sa o zicem, ecuatia este scrisa pentru cazul in care deviatia standard este calculata folosind media aritmetica simpla)

Deci ce se poate vedea e ceea ce era de asteptat. Fiecare deviatie standard apare ca rezultat al unui nou pret, care poate fi ori in sus, ori in jos, iar acestea sunt bineinteles radacinile ecuatiei de gradul al II-lea. Am grupat elementele ca sa se vada clar coeficientii lui Pn+1, Pn+1 la patrat si termenul liber. Fiind date m deviatii standard previzionate, avem 2^m preturi previzionate dupa m bare. Desigur, acestea nu pot fi generate direct ; ele formeaza un arbore . Astfel, in urma primei calculatii vor rezulta doua preturi ; fiecare dintre ele va fi baza unui nou calcul si asa mai departe. Astfel vom avea 2, 4, 8, 16… 2^m preturi pana la sfarsit. Cel mai probabil, pretul nu va avea o miscare sus-jos si viceversa cu o amplitudine in crestere pentru toate cele m bare. Ci, ne putem astept doar la cateva bare sa aiba o astfel de miscare, dupa care directia se va stabiliza. Putem avea cateva semnale directionale gresite la inceput, in timpul catorva balansari, dar dupa acestea miscarile pretului vor fi mult mai puternice. Sfatul meu este ca metoda sa fie folosita mai ales pentru timeframe-uri(perioada ocupata de o singura bara) mai mari decat patru ore.
Se poate lucra si cu timeframe-uri mai mici, dar semnalele de volatilitate prinse pe timeframe-uri mari pot produce rezultate spectaculoase.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

void CalculateStats(double &data[],int lastindex,double &avg, double &stddev)
  {
   double sum=0;
   int i;
   for (i=0;i<=lastindex;i++)
      {
       sum=sum+data[i];
      }
   avg=sum/(lastindex+1);
   sum=0;
   for (i=0;i<=lastindex;i++)
      {
       sum=sum+(data[i]-avg)*(data[i]-avg);
      }
   stddev=MathSqrt(sum/(lastindex+1));
  }
 
void CalculateNextPrices(double &p[],int lastindex,double newstddev,double &newprice1,double &newprice2)
  {
   double avg,avgc,stddev,suma2pi,sumapi2,sumapimavgc,sumapimavgc2,delta,a,b,c;
   int n,i;
   CalculateStats(p,lastindex,avg,stddev);
   n=lastindex+1;
   avgc=avg-p[0]/n;
   for (i=1;i<=lastindex;i++)
     {
      suma2pi=suma2pi+(2*p[i]);
      sumapi2=sumapi2+(p[i]*p[i]);
      sumapimavgc=sumapimavgc+(p[i]-avgc);
      sumapimavgc2=sumapimavgc2+(p[i]-avgc)*(p[i]-avgc);
     }
   a=1-(1.0/n);
   b=(2.0*avgc/n)-(2.0/n)*sumapimavgc-2.0*avgc;
   c=sumapimavgc2+avgc*avgc-newstddev*newstddev*n;
 
   delta=b*b-4.0*a*c;
   newprice1=(-b-MathSqrt(delta))/(2.0*a);
   newprice2=(-b+MathSqrt(delta))/(2.0*a);
  }

Prima functie calculeaza parametrii statistici: media si deviatia standard . A doua functie calculeaza noile preturi care se potrivesc cu noua deviatie standard. Ambele tablouri pleaca de la indexul zero. Parametrul lastindex parameter este ultimul index care contine date. Se observa utilizarea constantelor intregi in formule care calculeaza variabile double. Aceste constante trebuie scrise intr-o maniera double : 1.0 in loc de 1, 2.0 in loc de 2 s.a.m.d., altfel rezultatele sunt expuse la erori.

Aveti grija cand folositi calculul parabolic pentru deviatia standard. Daca primul punct este ales inainte de varful parabolei, deviatia standard pe parcurs poate deveni zero sau negativa, iar ecuatia va avea o radacina sau niciuna – radacinile complexe nu au sens aici!