Tutte le domande dei nuovi arrivati su MQL4 e MQL5, aiuto e discussione su algoritmi e codici - pagina 808

Nuovo commento
 
Kos Mos:

Quindi sto cercando di scoprire in che cosa sto fallendo, capisco che nessuno probabilmente mi dirà qualcosa gratuitamente - il capitalismo, per la miseria)). Non ho nulla contro di esso, ho solo bisogno di capire perché i trade si aprono su ogni candela nella direzione di acquisto.

Non stavo rispondendo a te.

Se vuoi che i tuoi sci funzionino, devi almeno stampare i valori delle variabili che sono importanti quando il segnale viene ricevuto e guardare nel log per vedere cosa succede con loro.

 

C'è un ciclo for(int i=0;i<ArrayRange(arr2,0);i++), quindi voglio sapere quante volte questo calcolo ArrayRange(arr2,0) viene eseguito: una volta e la macchina ricorda il valore, o ogni volta che il ciclo è in esecuzione, il valore viene restituito dalla funzione ArrayRange(arr2,0)? Esempio:

Prima opzione.

i=0,i<(valore restituito), incremento, quindi

i<(valore di ritorno di nuovo), incremento, quindi

i<(di nuovo restituisce un valore), incrementa in questo modo,

2a variante.

oppure, restituiamo un valore da questo calcolo ArrayRange(arr2,0) una volta, lasciamo che restituisca 5 e la macchina ricorda questo 5 e otteniamo il seguente risultato

i=0,i<(valore restituito)i<5, incremento, poi

i<5, incremento, quindi

i<5, incremento - è così che funziona?

Chiedo perché: se tutto avviene con la prima variante, allora ha senso estrarre questo valore prima del ciclo e memorizzarlo in una variabile, in modo che il programma non calcoli la funzione ArrayRange(arr2,0) ad ogni passaggio del ciclo.

 
Seric29:

C'è un ciclo for(int i=0;i<ArrayRange(arr2,0);i++), quindi voglio sapere quante volte questo calcolo ArrayRange(arr2,0) viene eseguito: una volta e la macchina ricorda il valore, o ogni volta che il ciclo è in esecuzione, il valore viene restituito dalla funzione ArrayRange(arr2,0)? Esempio:

Prima opzione.

i=0,i<(valore restituito), incremento, quindi

i<(valore di ritorno di nuovo), incremento, quindi

i<(di nuovo restituisce un valore), incrementa in questo modo,

2a variante.

oppure, restituiamo un valore da questo calcolo ArrayRange(arr2,0) una volta, lasciamo che restituisca 5 e la macchina ricorda questo 5 e otteniamo il seguente risultato

i=0,i<(valore restituito)i<5, incremento, poi

i<5, incremento, quindi

i<5, incremento - è così che funziona?

Perché lo chiedo: se tutto avviene sulla prima variante, allora ha senso prima del ciclo estrarre prima questo valore e memorizzarlo in una variabile, in modo che ad ogni passaggio del ciclo il programma non faccia la funzione ArrayRange(arr2,0).

nel caso generale - 1° caso.

PS/ Il 2° è possibile solo per compilatori "ottimizzanti", che possono capire che se non c'è ArrayResize all'interno di un ciclo, allora ArrayRange:=const ; non sono sicuro che il compilatore mql scavi già così a fondo nel codice, anche se per le sue funzioni "native" questo è teoricamente possibile.

PPS/ L'esempio di ArrayRange() non è del tutto corretto, perché probabilmente non ci sarà una chiamata diretta alla funzione, il compilatore deve solo ridurla a confrontare i con una variabile interna dell'array, perché sa tutto sugli array.

 
Maxim Kuznetsov:

nel caso generale - 1a variante.

PS/ Il 2° è possibile solo per compilatori "ottimizzanti", che possono capire che se non c'è ArrayResize all'interno del ciclo, allora ArrayRange:=const; non so se il compilatore mql scava già così in profondità nel codice, anche se per le sue funzioni "native" è teoricamente possibile.

PPS/ l'esempio con ArrayRange() non è del tutto corretto, perché probabilmente non ci sarà una chiamata diretta alla funzione, il compilatore deve solo ridurla al confronto di i con la variabile interna dell'array, perché sa tutto sugli array.

Prendiamo l'espressione5+5*5

la 1a variante.

i=0,i<(5+5*5), incremento, poi

i<(5+5*5), incremento, quindi

i<(5+5*5), incrementa in questo modo,

2a variante.

o, in questo caso, il risultato è un singolo ritorno di 5+5*5, lasciamo che ritornino 30 e la macchina ricorda questo 30-ku, così otteniamo i seguenti risultati

i=0,i<(valore restituito) i<30, incremento, successivo (il motore ricorda automaticamente 30 perché non ho salvato 30 da qualche parte)

i<30, incremento, quindi

i<30, incremento, è così che funziona?

Immagino che sarà la 1a variante? 5+5*5 è un'espressione che sarà valutata ad ogni iterazione del ciclo. Potete calcolare questa espressione prima del ciclo e memorizzare 30 in una variabile e inserirla nel ciclo, e questo sarà più facile da usare per la macchina, a meno che non calcoli automaticamente questo 30 e lo memorizzi nella sua memoria.


Se non c'è una chiamata di funzione, il compilatore non può controllare l'espressione booleana i<5, quindi probabilmente la prima opzione funzionerà.

 

Il risultato di una funzione(ArrayRange) può essere cambiato all'interno di un ciclo o di una funzione.
E l'espressione costante(5+5*5) sarà sempre la stessa.

Pertanto, la funzione sarà calcolata ad ogni passaggio.
E il valore costante sarà sostituito nel codice dal compilatore al momento della compilazione.

 
Taras Slobodyanik:

Il risultato di una funzione(ArrayRange) può essere cambiato all'interno di un ciclo o di una funzione.
E l'espressione costante(5+5*5) sarà sempre la stessa.

Pertanto, la funzione sarà calcolata ad ogni passaggio.
E il valore costante sarà sostituito nel codice dal compilatore al momento della compilazione.

5+5*5 è anche un'espressione e ha bisogno di essere calcolata ad ogni passaggio, poiché per la funzione si suppone che restituisca lo stesso risultato, il punto è che ad ogni passaggio del ciclo il compilatore calcolerà ancora sia la funzione che l'espressione 5+5*5. Quindi sarà la prima opzione - cioè il calcolo viene eseguito ad ogni passaggio del ciclo, quindi ha senso contare questo valore prima del ciclo e memorizzarlo in una variabile e usare la variabile come lo stesso valore statico così nessun calcolo ha luogo ad ogni passaggio del ciclo, questo in definitiva può

int k=5+5*5;//k=30

for(int i=0;i<k;i++){}

dove k è sempre 30 o

int k=ArrayRange(arr2,0)//k=5

for(int i=0;i<k;i++){}

dove k è sempre uguale a 5.

 
Seric29:

5+5*5 è anche un'espressione e deve essere calcolata ad ogni passaggio, per quanto riguarda la funzione si suppone che restituisca lo stesso risultato, stiamo parlando del fatto che ad ogni passaggio del ciclo il compilatore continuerà a contare sia la funzione che l'espressione 5+5*5. Quindi sarà la prima opzione - cioè, il calcolo viene fatto ad ogni passaggio del ciclo, quindi ha senso calcolare questo valore prima del ciclo e memorizzarlo in una variabile e usare la variabile come lo stesso valore statico così non ci saranno calcoli ad ogni passaggio del ciclo, eventualmente può

int k=5+5*5;//k=30

for(int i=0;i<k;i++){}

dove k è sempre 30 o

int k=ArrayRange(arr2,0)//k=5

for(int i=0;i<k;i++){}

dove k è sempre uguale a 5.

Si potrebbe semplicemente espandere il ciclo e non creare variabili extra.

 
Seric29:

5+5*5 è anche un'espressione e deve essere calcolata ad ogni passaggio, per quanto riguarda la funzione si suppone che restituisca lo stesso risultato, stiamo parlando del fatto che ad ogni passaggio del ciclo il compilatore continuerà a contare sia la funzione che l'espressione 5+5*5. Quindi ci sarà la prima opzione - cioè il calcolo viene fatto ad ogni passaggio del ciclo, quindi ha senso contare questo valore prima del ciclo e memorizzare in una variabile e utilizzare la variabile come lo stesso valore statico in modo che non ci siano calcoli ad ogni passaggio del ciclo, alla fine mo

Il compilatore lavora sempre una volta sola - al momento della compilazione del testo nel codice.
(per quanto mi ricordi MT4 compila già direttamente in codice)

5+5*5 - questa è un'espressione con costanti, non hanno bisogno di essere ricalcolate - quindi sarà calcolata solo una volta, a tempo di compilazione, e il codice conterrà il numero 30

5+5*5+i è un'espressione con una variabile, e questa sarà calcolata nel codice ad ogni passaggio come 30+i

La funzioneArrayRange restituisce un valore, ma il compilatore non sa quale sarà questo valore, quindi sostituirà la chiamata della funzione nel codice, e ad ogni passaggio (nel codice) la funzione sarà chiamata
 
Taras Slobodyanik:

Il compilatore lavora sempre una volta sola - al momento della compilazione del testo in codice.
(per quanto mi ricordi MT4 compila già direttamente in codice)

5+5*5 è un'espressione con costanti, non hanno bisogno di essere ricalcolate - quindi questo sarà calcolato solo una volta, a tempo di compilazione, e nel codice sarà 30

5+5*5+i è un'espressione con una variabile, e sarà calcolata nel codice ad ogni passaggio come 30+i

La funzioneArrayRange restituisce un valore, ma il compilatore non sa quale sarà questo valore, quindi sostituirà la chiamata della funzione nel codice, e ad ogni passaggio (nel codice) la funzione sarà chiamata

Capisco. Grazie. Non è una domanda seria, naturalmente, ma ci sono delle sottigliezze.

 
Artyom Trishkin:

Potete semplicemente espandere il ciclo e non creare variabili extra.

nel mio caso, ci sono 2 espressioni matematiche 1st-ArrayRange(arr2,0) 2nd5+5*5 il mio obiettivo è quello di creare condizioni in cui il compilatore lavorerà con meno carico

for(int i=0;i<ArrayRange(arr2,0);i++) in questo caso, il valore di confronto è restituito ad ogni passaggio

int k=ArrayRange(arr2,0)//k=5 for(int i=0;i<k;i++){}in questo caso il valore di confronto viene restituito 1 volta invece di 4 volte, ma viene creata una variabile, tuttavia il carico è inferiore, soprattutto quando si parla di migliaia o milioni.

Puoi mostrarci come espandere un ciclo in modo da non dover creare variabili?

1...801802803804805806807808809810811812813814815...1953
Nuovo commento
Motivazione: