Tutte le domande dei nuovi arrivati su MQL4 e MQL5, aiuto e discussione su algoritmi e codici - pagina 19
Ti stai perdendo delle opportunità di trading:
- App di trading gratuite
- Oltre 8.000 segnali per il copy trading
- Notizie economiche per esplorare i mercati finanziari
Registrazione
Accedi
Accetti la politica del sito e le condizioni d’uso
Se non hai un account, registrati
Per correggere questo errore, dovete capire la vostra formula - cosa, perché e come state contando.
E solo allora sarete in grado di elaborare il vostro algoritmo ed eliminare l' errore.
Con il metodo "gut feeling" e non capendo la vostra formula - eliminerete l'errore, ma farete un calcolo sbagliato.
p.s. Spiega in dettaglio cosa stai calcolando - commenta il tuo codice in dettaglio - e poi capiremo come risolverai l'errore.
Abbiamo bisogno di un indicatore che si basa sui valori del coefficiente di correlazione di Pearson per i prezzi di chiusura. Prendiamo un array di 24 barre (nel mio caso è la variabile n), partendo dalla prima barra - per 2 valute. Calcolare la correlazione per 24 barre - ottenere il valore sulla prima barra. Poi calcola la correlazione per 24 barre, ma partendo dalla seconda barra e così via.
1. Ho preso un array bidimensionale di prezzi di chiusura (i elementi e p dimensioni).
{
for(int p=0; p<m; p++)
{
Price_CloseX[i][p]=iClose(sym_x, PERIOD_H1, i+p);
Price_CloseY[i][p]=iClose(sym_y, PERIOD_H1, i+p);
}
}
{
for(int p=0; p<m; p++)
{
sum_x[i][p]=sum_x[i][p-1]+Price_CloseX[i][p];
sum_y[i][p]=sum_y[i][p-1]+Price_CloseY[i][p];
}
}
3. Prezzo medio di chiusura su 24 barre(n-1) in ogni array
{
for(int p=0; p<m; p++)
{
Mx[i][p]=sum_x[p+1][m-1]/(n-1);
My[i][p]=sum_y[p+1][m-1]/(n-1);
}
}
4. la deviazione dal prezzo medio in ogni array
{
for(int p=0; p<m; p++)
{
dx[i][p]=Price_CloseX[i][p]-Mx[i][p];
dy[i][p]=Price_CloseY[i][p]-My[i][p];
}
}
5. Il quadrato della deviazione dal prezzo medio di chiusura
{
for(int p=0; p<m; p++)
{
dx2[i][p]=(dx[i][p]*dx[i][p]);
dy2[i][p]=(dy[i][p]*dy[i][p]);
}
}
6. Il prodotto delle deviazioni, cioè ogni elemento della matrice della valuta 1 viene moltiplicato per un elemento simile nella valuta 2,
per esempio il valore di dx[1][0] (valuta 1) è moltiplicato per dy[1][0] (valuta 2); dx[3][4]*dy[3][4], ecc.
{
for(int p=0; p<m; p++)
{
dxdy[i][p]=(dx[i][p]*dy[i][p]);
}
}
7. Calcolare la somma dei quadrati delle deviazioni e la somma del prodotto delle deviazioni
{
for(int p=0; p<m; p++)
{
Edx2[i][p]=(Edx2[i-1][p]+dx2[i][p]);
Edy2[i][p]=(Edy2[i-1][p]+dy2[i][p]);
Edxdy[i][p]=(Edxdy[i-1][p]+dxdy[i][p]);
}
}
8. Beh, in realtà il coefficiente di correlazione e sostituirlo nel buffer
{
Koef[p]=Edxdy[n-1][p]/sqrt(Edx2[n-1][p]*Edy2[n-1][p]);
Buffer1[p]=Koef[p];
}
__________________________________________________________________________________________
Come scritto sopra, l'errore è un overrun dell'array. Lo script con lo stesso codice per il calcolo del coefficiente di correlazione considera questo coefficiente
Quando è stato scritto #property strict, il compilatore ha generato errori in ogni ciclo for() dicendo che le variabili devono essere di tipo, quindi ho dovuto scrivere int i e int p in ogni ciclo. Dopo di che il compilatore non ha generato errori, ma la linea non ha costruito. Quando ho rimosso #property strict, il compilatore non ha richiesto di dichiarare il tipo in ogni ciclo, e la linea è stata costruita.
int i e int p devono essere dichiarati solo una volta - prima di init()
potete scrivere una tale linea prima del doppio Buffer1[];
nel codice int rimuovere
#proprietà rigorosa deve essere restituita
poi eseguire di nuovo la compilazione
poi controlla gli errori
poi, in caso di superamento dell'array, guardare in quale linea di codice (il numero è interessante e la linea stessa). Prima era la linea numero 90 nel tuo codice.
L'errore significa che se avete 24 valori nell'array, e richiedete il 24esimo indice, allora . è un errore. Cerca di capirlo. La numerazione dell'indice inizia da zero, cioè nel vostro caso 0,1,...23.
Se non riusciamo a capire - butta qui questa linea, penseremo
int i e int p devono essere dichiarati solo una volta - prima di init()
"La strada per l'inferno della programmazione è lastricata di variabili globali". S. McConnell.
A volte è più difficile senza di loro, ma non nel caso dell'indicatore in questione.
Sono d'accordo, a volte non si può proprio farne a meno. Ma non in questo caso.
In questo caso, si scrive più codice di quanto sia necessario e sufficiente.
A proposito, potete anche scrivere type prima di ogni variabile anche se il nome della variabile è lo stesso...., ma non è la giusta costruzione del codice.
In questo caso, si scrive più codice del necessario.
A proposito, potete anche scrivere type prima di ogni variabile, anche se il nome della variabile è lo stesso...., ma questa non è la giusta costruzione del codice.
In realtà sì, probabilmente non dovrebbe essere consigliato, ma forse riconsidererà la sua decisione quando incontrerà qualche problema.
...
In questo caso avete scritto più codice del necessario e sufficiente.
A proposito, potete anche scrivere type prima di ogni variabile, anche se il nome della variabile è lo stesso...., ma questa non è la giusta costruzione del codice.