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

Nuovo commento
 
Alexey Viktorov:

Le funzioni IntegerToString() e DoubleToString() rappresentano semplicemente il numero come una stringa che viene passata alla funzione. Nell'esempio

è la conversione di r in una stringa e le stringhe vengono "aggiunte". Ma prima di questo, il valore di r cambia.

Non ho capito bene la domanda, ma se avete bisogno di selezionare solo elementi pari dall'array, il ciclo dovrebbe essere costruito in questo modo


Grazie per la spiegazione.

 
Alexey Viktorov:

Le funzioni IntegerToString() e DoubleToString() rappresentano semplicemente il numero come una stringa che viene passata alla funzione. Nell'esempio

è la conversione di r in una stringa e le stringhe vengono "aggiunte". Ma prima di questo il valore di r cambia.



Non riesco a capire il processo di "aggiunta" dei valori delle variabili stringa. Vedo 2 varianti di "aggiungere" stringhe nel mio codice.

1. Sommano il valore della variabile stringa dell'iterazione corrente con il valore della stessa variabile stringa dell'iterazione precedente.

2. All'iterazione corrente, i valori delle due variabili termine sono aggiunti, cioè IntegerToString(r) + DoubleToString(LoY[r],4).

Mi sembra che tu intenda la prima variante.

Ma poi .... Il valore di IntegerToString(r) nell'iterazione precedente = "0" e sull'iterazione corrente = "1" . Il risultato dell'addizione dovrebbe essere "01".

Se nell'iterazione corrente prima della somma il valore di IntegerToString(r) cambia dal precedente 0 all'attuale 1, otteniamo ancora una rappresentazione stringa a due cifre del numero, cioè "11".

Se usiamo lo stesso algoritmo per sommare i valori della variabile stringa DoubleToString(LoY[r],4), allora il risultato della somma di due stringhe dovrebbe essere valori come 1.61041.6105

Ma Print() stampa i risultati dell'addizione come altri numeri per qualche motivo (come dovrebbero essere)
Non lo capisco.
Ecco il vostro esempio di come i valori delle variabili stringa vengono sommati "...... e se sommate le stringheDoubleToString(2.3, 1)+DoubleToString(3.6, 1), sarà 2.33.6 come stringa". Cioè, prima dell'addizione, la rappresentazione stringa del numero di ogni variabile era di 2 caratteri, ma dopo l'aggiunta di due variabili stringa, il risultato dell'addizione è una rappresentazione stringa del numero di 4 caratteri. Perché l'addizione nel tuo codice non dà come risultato un numero con il doppio dei caratteri?

 
Alexey Viktorov:


Non ho capito bene la domanda, ma se volete selezionare solo elementi pari da un array, allora il ciclo dovrebbe essere costruito così


In realtà, questo è quello che intendevo con .... Ecco il codice originale completato con BOX 2

int P1=0;
double LoY[31];
void OnTick()
{
if (P1==0)
{
for(int r=0; r<31;r++)
{
LoY[r]=1.6104+(r*2)*0.0001;
Print("-------------------------------------LoY[r]--------------=",  LoY[r]);
P1=1;
}
}
//*************************************************************  Б Л О К    N 2
for(int x=0; x<31;x++)
{
if (Bid < LoY[x] )
{
LoY[x]=Bid;
ArraySort(LoY,WHOLE_ARRAY,0,MODE_ASCEND);
Print("---LoY[0]--",  X, "---LoY[1]--" ,  X,   "---LoY[2]--" ,  X,  "---LoY[3]--" ,  X,  "---LoY[4]--" ,  X, ................  "---LoY[30]--" ,  X );
}
}
}

Nel secondo blocco, i valori degli elementi della matrice non differiscono più dello stesso delta del primo blocco. Il delta tra elementi adiacenti può essere diverso e quindi l'algoritmo per collegare le stringhe del primo blocco non è adatto al secondo blocco.... mi sembra.

DOMANDA Con quale costrutto o funzione del linguaggio MQL4 nel secondo blocco del codice di cui sopra, la funzione Print(), alla fine del ciclo, stamperàsolo una volta, con tutti i valori degli elementi dell'array compilati, disposti in una riga, cioè avrà la seguente forma

Print("---LoY[0]--" , X,"---LoY[1]--", X,"---LoY[2]--", X,"---LoY[3]--", X,"---LoY[4]--", X................"---LoY[30]--", X );

Non giudicatemi duramente, ma non sono sicuro di poter capire la spiegazione a parole, perché il secondo blocco è molto più complicato del primo.... mi sembra.
Grazie per il vostro aiuto.

 

Quando si programma, c'è molto lavoro di routine, almeno all'inizio. Si pensa all'idea, poi si scrive il codice e poi si fa il debug. A volte il tempo del debug richiede più tempo di tutto il resto.

Spesso succede che l'idea iniziale non funziona. Si comincia a guardare dall'alto verso il basso in ordine di ciò che non va.

Inserite printf() ovunque, e vedete se è quello che vi aspettate o no. In questo modo, capirete più velocemente come funziona il codice e dove avete un errore. Altrimenti, la comprensione richiederà molto tempo.


Non sono affari miei, ma cerca di scrivere bene. Scegli uno stile per te e attieniti ad esso. Mettere le parentesi nei passi per rendere visibili gli allegati. Se usate spazi tra le dichiarazioni, allora usateli ovunque, o al contrario, non usateli ovunque.

for(int x=0; x<31;x++)

if (Bid < LoY[x] )

Allora sarà più facile per voi leggere il vostro codice.

-----------------

Sul secondo blocco:

Nel secondo blocco, la x minuscola e la x maiuscola sono variabili diverse, il codice non funzionerà come volete.

Sarebbe meglio ordinare l'array al di fuori del ciclo.

In Stampa si usa X molte volte, si stamperà lo stesso numero di volte.

-----------------

Per quanto riguarda il codice. È difficile capire la domanda, quindi vi dirò quello che ho capito io.

Se scrivete Print in un ciclo, otterrete tante stampe quante sono le iterazioni di quel ciclo. Se avete bisogno di stampare l'output una volta, mettete Print dopo il ciclo.

In questo caso, usate una variabile, nella quale scriverete il valore di ogni iterazione, per raccogliere le informazioni. La nostra variabile è una stringa, quindi tutti i numeri devono essere convertiti in stringa.

Abbiamo una variabile stringa perché la funzione Print accetta una stringa.

Cosa sta succedendo:

Primo passaggio. Prima del primo passaggio prima del ciclo, abbiamo una variabile vuota: string str="";
Successivamente, assegniamo un valore vuoto alla variabile più "--LoY["+IntegerToString(r)+"]--, "+DoubleToString(LoY[r],4)+",";
qui r è 0 e aggiungiamo effettivamente qualche stringa:

"--LoY["+

IntegerToString(0)+

"]--, "+

DoubleToString(LoY[0],4)+

", ";

Secondo passaggio.

A tutto questo aggiungiamo le informazioni del secondo elemento

"--LoY["+IntegerToString(1)+"]--, "+DoubleToString(LoY[1],4)+", ";

Questo non cambia la stringa dal primo elemento.



È meglio che spieghi lo scopo a parole, cosa ti serve piuttosto che come lo fai. Altrimenti potremmo discutere il tuo codice per tanto tempo e si scoprirà che il tuo obiettivo può essere risolto in un altro modo.

 
ANDREY:

Non riesco a capire il processo di "aggiunta" dei valori delle variabili stringa. Vedo 2 opzioni per "aggiungere" stringhe nel mio codice.

1. Il valore della variabile stringa dell'iterazione corrente viene aggiunto al valore della stessa variabile stringa dell'iterazione precedente.

2. All'iterazione corrente, i valori delle due variabili termine sono aggiunti, cioè IntegerToString(r) + DoubleToString(LoY[r],4).

Mi sembra che tu intenda la prima variante.

Ma poi .... Il valore di IntegerToString(r) nell'iterazione precedente = "0" e sull'iterazione corrente = "1" . Il risultato dell'addizione dovrebbe essere "01".

Se il valore di IntegerToString(r) cambia dal precedente 0 all'attuale 1 prima dell'addizione , otteniamo ancora una rappresentazione stringa a due cifre del numero, cioè "11".

Se sommiamo i valori della variabile stringa DoubleToString(LoY[r],4) con lo stesso algoritmo , allora il risultato della somma di due stringhe deve essere valori come 1.61041.6105

Ma Print() per qualche motivo stampa i risultati dell'addizione come altri numeri (come dovrebbero essere)
Non lo capisco.
Ecco il tuo esempio di aggiunta di valori di variabili stringa "...... e se aggiungi stringheDoubleToString(2.3, 1)+DoubleToString(3.6, 1), sarà 2.33.6 come stringa". Cioè, prima dell'addizione, la rappresentazione stringa del numero di ogni variabile era di 2 caratteri, ma dopo l'aggiunta di due variabili stringa, il risultato dell'addizione è una rappresentazione stringa del numero di 4 caratteri. Perché l'addizione nel tuo codice non dà come risultato un numero con il doppio dei caratteri?

In effetti, questo è proprio come scrivere qualsiasi testo. Iniziamo con un foglio bianco, o dovrei dire una linea bianca. Poi scriviamo la prima parola, aggiungiamo la seconda parola e così via.......... E quando vediamo dei numeri nel testo, li scriviamo come simbolo di linea. Cioè, se aggiungiamo 2 + 5, si ottiene 7, e se scriviamo semplicemente questi stessi numeri, allora prima scriviamo 2 e poi 5... così otteniamo due numeri 25, scritti uno accanto all'altro. Non so come altro spiegarlo.

In realtà, se ignorate gli avvertimenti del compilatore, la conversione dei valori r in una stringa nel vostro esempio non è necessaria. Qui puoi controllare queste due opzioni

Print("Test 1 " + (string)1 + (string)2);
Print("Test 2 " + 1 + 2);
 
Aleksei Stepanenko:


Grazie per il vostro aiuto e i vostri consigli.

 
Alexey Viktorov:

In effetti, è esattamente lo stesso che scrivere qualsiasi testo. Per prima cosa abbiamo un foglio bianco, o dovrei dire una linea bianca. Poi scriviamo la prima parola, aggiungiamo la seconda parola e così via.......... E quando vediamo dei numeri nel testo, li scriviamo come simbolo di linea. Cioè, se aggiungiamo 2 + 5, si ottiene 7, e se scriviamo semplicemente questi stessi numeri, allora prima scriviamo 2 e poi 5... così otteniamo due numeri 25, scritti uno accanto all'altro. Non so come altro spiegarlo.

In realtà, se ignorate gli avvertimenti del compilatore, la conversione dei valori r in una stringa nel vostro esempio non è necessaria. Ecco a voi e controllate due di queste varianti.

Grazie di tutto

 
ANDREY:

Questo è in realtà quello che intendevo con .... Ecco il codice originale, completato dal BOX 2

Nel secondo blocco, i valori degli elementi dell'array non differiscono dello stesso delta che nel primo blocco. Il delta tra elementi adiacenti può essere diverso e quindi l'algoritmo per collegare le stringhe del primo blocco non è adatto al secondo blocco.... mi sembra.

DOMANDA Con quale costrutto o funzione del linguaggio MQL4 nel secondo blocco del codice di cui sopra, la funzione Print() stamperàsolo 1 volta al termine del ciclo, con tutti i valori degli elementi dell'array riempiti in una riga, cioè avrà la seguente forma

Print("---LoY[0]--" , X,"---LoY[1]--", X,"---LoY[2]--", X,"---LoY[3]--", X,"---LoY[4]--", X................"---LoY[30]--", X );

Non giudicatemi duramente, ma non sono sicuro di poter capire la spiegazione a parole, perché il secondo blocco è molto più complicato del primo.... mi sembra.
Grazie per l'aiuto.

E perché ordinare l'array ad ogni iterazione del ciclo? Perché se avete sostituito il valore dell'elemento 0-esimo dell'array e dopo l'ordinamento è andato alla fine dell'array, allora zero sarà il valore che era il primo, e il primo sarà il valore che era il secondo. Così, il valore del primo elemento dell'array sarà saltato e otterrete "spazzatura". Tutto sommato, tutto il vostro codice è qualcosa fuori posto.

A cosa vi serve il primo blocco in cui riempite l'array? Riempite subito l'array con i valori che vi servono e poi ordinatelo. Vero, dovrete eseguire un altro ciclo per riempire la stringa e stampare. Vorrei che mql4 avesse ArrayPrint()... Ma è solo un esperimento, e non avrete effettivamente bisogno di stampare i valori dell'array.

 
Aleksei Stepanenko:

Meglio spiegare il tuo obiettivo a parole, cosa ti serve, non come lo fai. Altrimenti, possiamo discutere il tuo codice per tanto tempo, e si scoprirà che il tuo obiettivo può essere risolto in un altro modo.

Mentre studio mql4 (e un po' di mql5), sto scrivendo vari codici. Questo include i codici che usano gli array. Spesso è necessario controllare gli elementi dell'array in qualche punto del codice. Ho imparato a farlo usando Print() in un ciclo. Ma in questo caso, Print() viene stampato ad ogni iterazione. Quando ci sono molte iterazioni, è scomodo sia per il programma che per la lettura. Avete detto correttamente che Print( ) deve essere rimosso al di fuori del ciclo per Print() con i valori degli elementi dell'array da stampare solo una volta. L'avevo intuito prima delle tue parole.

Ho imparato molto rapidamente a mettere Print() fuori dal ciclo. E ora sto cercando di imparare come fare in modo che Print() stampi tutti i valori degli elementi dell'array in una riga.

Mi è stato spiegato come fare rispetto al primo blocco del mio codice. Finora, in termini generali, ho capito questa tecnologia. Continuerò a scervellarmi per capire i dettagli di questo metodo.
Ma nel secondo blocco del mio codice, come mi sembra, il metodo del primo blocco non è adatto perché, a differenza del primo blocco, il delta tra i valori degli elementi dell'array nel secondo blocco è diverso.
Se ho ragione e il metodo del primo blocco non si adatta al secondo, vi sarei grato se poteste mostrarmi come fare la stessa cosa che è stata fatta nel primo blocco, ma con riferimento al secondo blocco.

Ho corretto il secondo blocco. Ho messo Print() e ArraySort() fuori dal ciclo. Ho rimosso la variabile X da Print() per non indurvi in errore.

int P1=0;
double LoY[31];
void OnTick()
{
if (P1==0)
{
for(int r=0; r<31;r++)
{
LoY[r]=1.6104+(r*2)*0.0001;
P1=1;
}
}
//*************************************************************  Б Л О К    N 2
for(int x=0; x<31;x++)
{
if (Bid < LoY[x] )
{
LoY[x]=Bid;
}
}
ArraySort(LoY,WHOLE_ARRAY,0,MODE_ASCEND);
Print("-LoY[0]-", (знач.эл.масс с инд.0), "---LoY[1]--" ,  (знач.эл.масс с инд.1),   "---LoY[2]--" ,  (знач.эл.масс с инд.2),  "---LoY[3]--" ,  (знач.эл.масс с инд.3),................  "---LoY[30]--" ,  (знач.эл.масс с инд.30) );
}
  
Print("-LoY[0]-", DoubleToString(LoY[0],4), "---LoY[1]--", DoubleToString(LoY[1],4), "---LoY[2]--" , DoubleToString(LoY[2],4), "---LoY[3]--" , DoubleToString(LoY[3],4),................  "---LoY[30]--" ,  DoubleToString(LoY[30],4) );

o fare una funzione di stampa separata dell'array:

void PrintArray(double &eArray)
   {
   string eStr="";
   int eSize=ArraySize(eArray);
   for(int i=0; i<eSize; i++)
      {
      eStr+=IntegerToString(i)+": "+DoubleToString(eArray[i],4)+", ";
      }
   Print(str);
   }

E chiamarlo da qualsiasi luogo

PrintArray(LoY);
1...140614071408140914101411141214131414141514161417141814191420...1953
Nuovo commento