[ARCHIVIO]Qualsiasi domanda da principiante, per non ingombrare il forum. Professionisti, non passate oltre. Non posso andare da nessuna parte senza di te - 5. - pagina 323

Nuovo commento
 

Questo è quello che succede:

//+-------------------------------------------------------------------------------------+
//| Расчитываем количество идущих один за одним баров одного признака                   |
//+-------------------------------------------------------------------------------------+
int LastCandlesType(int directionMA)
{
   int cntUp,                                                                           // Счётчик идущих друг за другом свечей с..
       cntDn,                                                                           // .. требуемыми признаками
       t;                                                                               // Счётчик всех просчитанных баров
       
   for (int i=i_AnyBarsToHistory; i>=1; i--, t++)
   {
      if (directionMA == CROSS_UP)                                                      // Если машки направлены вверх
      {
         if ((Open[i] - Close[i]) >= i_sizeOfSequentialCorrectionBar * pt)              // Если бар соответствует требуемым признакам..
             cntDn++;                                                                   // .. прибавим 1 к счётчику
         if ((Close[i] - Open[i]) >= i_sizeOfTrandBar * pt)                             // Если бар, не соответствует основному признаку..
             cntDn = 0;                                                                 // .. счётчик обнуляем
                                                                                        
         if (i == 1)
            Print(" directionMA ", directionMA, "; i = ", i, "; Open[i] - Close[i] = ", Open[i] - Close[i], "; cntDn = ", cntDn);

         if (t == i_AnyBarsToHistory)
         {
             if (cntDn == i_sequentBarsСount)                                                // Если cnt баров в подряд медвежьи..
                 return (REQUIRED_SEQUENTIAL_BEARS_GOT);                                     // .. Выходим из функции
         }
      }

      if (directionMA == CROSS_DN)                                                      // Если машки направлены вниз
      {
         if ((Close[i] - Open[i]) >= i_sizeOfSequentialCorrectionBar * pt)              // Если бар соответствует требуемым признакам..
             cntUp++;                                                                   // .. прибавим 1 к счётчику
         if ((Open[i] - Close[i]) >= i_sizeOfTrandBar * pt)                             // Если бар, не соответствует основному признаку..
             cntUp = 0;                                                                 // .. счётчик обнуляем
         if (i == 1)
            Print(" directionMA ", directionMA, "; i = ", i, "; Close[i] - Open[i] = ", Close[i] - Open[i], "; cntUp = ", cntUp);

         if (t == i_AnyBarsToHistory)
         {
             if (cntUp == i_sequentBarsСount)                                                // Если cnt баров в подряд бычьи..
                 return (REQUIRED_SEQUENTIAL_BULLS_GOT);                                     // .. Выходим из функции
         }
      }
      return (REQUIRED_SEQUENTIAL_MISS);
   }
}

Infatti, non viene stampata nemmeno una riga:

Print(" directionMA ", directionMA, "; i = ", i, "; Close[i] - Open[i] = ", Close[i] - Open[i], "; cntUp = ", cntUp);

Quindi probabilmente c'è un qualche tipo di bug in quanto sopra.

La cosa più interessante è che una volta che ho aggiunto un ritorno predefinito qui, in qualche modo funziona sempre. Intendo la corda:

return (REQUIRED_SEQUENTIAL_MISS);

Anche se è ovvio che il codice è elementare, e non ci possono essere errori.

 

Saluti a tutti! Cari guru, potete dirmi perché v_s aumenta e diminuisce quando il profitto aumenta e diminuisce nella valuta di deposito?

value_profit() è un calcolo del profitto nella valuta del deposito.

doppio value_stop,value_step;
value_stop=((AccountBalance()/100)*1);
value_step=((AccountBalance()/100)*4);
doppio v_s;
se (value_profit()>=(value_step+value_stop))
per (int v=1;v<=100;v++)
{
se (value_profit()>=(value_step+(value_stop*v))
{
v_s=valore_stop*v;
}
else
{
se (valore_profitto()<=v_s)
close_all();
}
}
 
hoz:

Infatti, non viene stampata nemmeno una riga:

1. Perché fare esattamente la modularità in una volta sola? Naturalmente, ognuno ha il proprio stile, ma io luciderei prima la versione compatta, e poi, quando funziona come un orologio, passerei alla modularità. La variante compatta (senza le funzioni inserite Trade, LastCandlesType, GetStateOfMA, GetGeneralSignal) è stata data come variante di start() interna nell'ultima pagina. Come funziona per voi? Se funziona, allora dividetelo in moduli.

2. Il codice mi sembra assolutamente identico al precedente, poiché il contatore t cambia assolutamente in parallelo al contatore i. Perché allora confrontare con t se si può confrontare con i? E, andando ulteriormente per logica, allora perché confrontare con i se abbiamo un codice che non ha funzionato?

3. Scusate se mi intrometto, ma come funzionerebbe questa variante con il togliere l'uscita dal loop?

int LastCandlesType(int directionMA){
        int cntUp, cntDn;
        for (int i=i_AnyBarsToHistory; i>=1; i--){
                if (directionMA == CROSS_UP){
                        if ((Open[i] - Close[i]) >= i_sizeOfSequentialCorrectionBar * pt) cntDn++; else cntDn=0;
                        if (i == 1) Print(" directionMA ", directionMA, "; i = ", i, "; Open[i] - Close[i] = ", Open[i] - Close[i], "; cntDn = ", cntDn);
                }
                if (directionMA == CROSS_DN){
                        if ((Close[i] - Open[i]) >= i_sizeOfSequentialCorrectionBar * pt) cntUp++; else cntUp=0;
                        if (i == 1) Print(" directionMA ", directionMA, "; i = ", i, "; Close[i] - Open[i] = ", Close[i] - Open[i], "; cntUp = ", cntUp);
                }
        }
        if ((directionMA==CROSS_UP)&&(cntUp>=i_sequentBarsСount)) return(REQUIRED_SEQUENTIAL_BEARS_GOT);
        if ((directionMA==CROSS_DN)&&(cntDn>=i_sequentBarsСount)) return(REQUIRED_SEQUENTIAL_BULLS_GOT);
        return(REQUIRED_SEQUENTIAL_MISS);
}

Capisco che potrebbe anche non funzionare, qualunque cosa, ma ho bisogno di essere sicuro per capire meglio.

4. Puramente il mio adattamento personale: digitate il codice non in meta editor, ma in qualsiasi altro editor con linee numerate, e stampate su ogni cambiamento di qualsiasi variabile e su ogni controllo if o switch, nella stessa linea (dopo l'ultimo punto e virgola). Stampa nel numero di riga - valore(i) da controllare. Stampatelo dopo if(tracing) {Print(StringConcatenate("line_number: variable_name=", variable_name));} e dichiarate una variabile nell'intestazione, come: bool tracing=false;//enable tracing. In questo caso avrete un tracciamento completo e quindi un debug completo. Ma bisogna pulire i registri più spesso, ovviamente. Se hai intenzione di usare direttamente il meta editor, puoi prima fare un template vuoto come

/*001*/

...

/*999*/

all'inizio delle linee (e funziona), e poi in una copia di questo modello per digitare il codice. Ma questo è solo quello che penso, in pratica ho provato così, ma in modo incoerente.

 
rajak:

Saluti a tutti! Cari guru, potete dirmi perché v_s aumenta e diminuisce quando il profitto aumenta e diminuisce nella valuta di deposito?

value_profit() è un calcolo del profitto nella valuta del deposito.

doppio value_stop,value_step;
value_stop=((AccountBalance()/100)*1);
value_step=((AccountBalance()/100)*4);
doppio v_s;
se (value_profit()>=(value_step+value_stop))
per (int v=1;v<=100;v++)
{
se (value_profit()>=(value_step+(value_stop*v))
{
v_s=valore_stop*v;
}
else
{
se (valore_profitto()<=v_s)
close_all();
}
}
Dopo una rapida occhiata, ho visto subito un bug con le virgolette. Insegnate come usare l'istruzione if.
 
gyfto:

3. Scusa se mi impiccio, ma come funzionerebbe per te togliere l'uscita dal ciclo dopo tutto?

int LastCandlesType(int directionMA){
        int cntUp, cntDn;
        for (int i=i_AnyBarsToHistory; i>=1; i--){
                if (directionMA == CROSS_UP){
                        if ((Open[i] - Close[i]) >= i_sizeOfSequentialCorrectionBar * pt) cntDn++; else cntDn=0;
                        if (i == 1) Print(" directionMA ", directionMA, "; i = ", i, "; Open[i] - Close[i] = ", Open[i] - Close[i], "; cntDn = ", cntDn);
                }
                if (directionMA == CROSS_DN){
                        if ((Close[i] - Open[i]) >= i_sizeOfSequentialCorrectionBar * pt) cntUp++; else cntUp=0;
                        if (i == 1) Print(" directionMA ", directionMA, "; i = ", i, "; Close[i] - Open[i] = ", Close[i] - Open[i], "; cntUp = ", cntUp);
                }
        }
        if ((directionMA==CROSS_UP)&&(cntUp>=i_sequentBarsСount)) return(REQUIRED_SEQUENTIAL_BEARS_GOT);
        if ((directionMA==CROSS_DN)&&(cntDn>=i_sequentBarsСount)) return(REQUIRED_SEQUENTIAL_BULLS_GOT);
        return(REQUIRED_SEQUENTIAL_MISS);
}

Ha funzionato. Ho eseguito diversi "schermi" nella visuale, tutto è chiaro in questo intervallo. Devo ancora capire perché non ha funzionato l'ultima volta. Sarà utile per non inciampare in futuro.
 
hoz:

Hmm, funziona.


Glad))))

hoz:

Devo ancora capire perché non ha funzionato l'ultima volta. Sarà utile per evitare di inciamparci in futuro.

Perché in futuro, non uscite per prima di arrivare a Close[0] o qualunque sia il limite della finestra in qualsiasi altro algoritmo. Non è mentre.

 
gyfto:

1. Perché fare la modularità tutta in una volta? Naturalmente, ognuno ha il suo stile, ma io luciderei prima la versione compatta, e poi, quando funziona come un orologio, passerei alla modularità. La variante compatta (senza le funzioni inserite Trade, LastCandlesType, GetStateOfMA, GetGeneralSignal) è stata mostrata come variante di start() internals nella pagina precedente. Come funziona per voi? Se funziona, allora dividetelo in moduli.

In realtà, sono abituato a scrivere così. Ed è più facile cercare gli errori. Perché ho capito subito che l'errore era nella funzioneLastCandlesType(). Ma non ho ancora scoperto la ragione, anche se il tuo modo ha funzionato.

gyfto:

2. Il codice mi sembra assolutamente identico al precedente, poiché il contatore t cambia assolutamente in parallelo al contatore i. Perché allora confrontare con t se si può confrontare con i? E, andando ulteriormente per logica, allora perché confrontare con i se abbiamo un codice che non ha funzionato?

Troppo tardi per scrivere, ... sovraccarico morale, credo.

gyfto:

Capisco che potrebbe anche non funzionare, qualunque cosa, ma ho bisogno di assicurarmi che lo faccia per capire meglio.

Funziona! Quello che resta da capire è perché quel codice non ha funzionato. La prima cosa che ha attirato la mia attenzione è l'uscita dalla funzione quando il contatore raggiunge il valore i_seqqtBarstCounter. Ma, di nuovo, ho stampato e il valore del contatore ha mostrato solo 1 per tutto il tempo, quando ho messo l'uscita predefinita dalla funzionereturn(REQUIRED_SEQUENTIAL_MISS);

Prima di posizionarlo, tutto era calcolato correttamente, ma il gufo non veniva scambiato correttamente. Non c'era niente di niente. Anche se, in teoria, se nessuna delle condizioni sopra l'output di default ha funzionato, significa che nessuna delle condizioni è scattata e anche se mettiamo l'output di default nella condizione non dovrebbe funzionare. Al contrario, se la condizione è valida, dovrebbe essere valida.


gyfto:

4. Puramente il mio adattamento personale: digitate il codice non in meta-editor, ma in qualsiasi altro editor con numerazione delle linee, e stampate su ogni cambiamento di qualsiasi variabile e su ogni controllo if o switch, sulla stessa linea (dopo l'ultimo punto e virgola). Stampa nel numero di riga - valore(i) da controllare. Stampatelo dopo if(tracing) {Print(StringConcatenate("line_number: variable_name=", variable_name));} e dichiarate una variabile nell'intestazione, come: bool tracing=false;//enable tracing. In questo caso avrete un tracciamento completo e quindi un debugging completo. Ma bisogna pulire i registri più spesso, ovviamente. Se hai intenzione di usare direttamente il meta editor, puoi prima fare un template vuoto come

/*001*/

...

/*999*/

all'inizio delle linee (e funziona), e poi in una copia di questo modello per digitare il codice. Ma questo è solo quello che penso, in pratica ho provato così, ma in modo incoerente.


Beh, noi stampiamo sulla base dei dati di Expert Advisor, non dei numeri di linea. Perché avete bisogno di numeri di linea? Personalmente lo uso per l'analisi del codice, dato che ci sono momenti davvero utili. Ma scrivere e fare il debug del codice basandosi sui numeri di linea per me non ha senso.
 
hoz:

Resta da capire perché quel codice non ha funzionato.


Il modo in cui l'ho capito io stesso. Abbiamo letto gli incroci dei lembi. Più precisamente, tre candele rialziste o ribassiste dopo l'attraversamento in qualsiasi momento. Quando la condizione è soddisfatta, entriamo nel mercato. Ma a giudicare dalla descrizione verbale, questi tre o più candelabri che arrivano in fila appartengono al bordo destro della finestra. Secondo il vostro codice, possono riferirsi al centro della finestra. Pertanto, l'Expert Advisor è entrato nel mercato quando la condizione (tre candele) è stata raggiunta, mentre l'ultima candela può non essere l'ultima.
 
gyfto:

Come l'ho capito io stesso. Abbiamo letto l'incrocio degli orsi. Per essere più precisi, tre candele rialziste o ribassiste dopo l'attraversamento in qualsiasi momento. Quando la condizione è soddisfatta, entriamo nel mercato. Ma a giudicare dalla descrizione verbale, questi tre o più candelabri che arrivano in fila appartengono al bordo destro della finestra. Secondo il vostro codice, possono riferirsi al centro della finestra. Pertanto, l'EA entrerà nel mercato quando la condizione (tre candele) sarà raggiunta, ma l'ultima candela potrebbe non essere l'ultima.


La conclusione è la seguente: conoscendo la sintassi, dobbiamo anche guardare la logica. Questo è molto importante. Ho avuto solo un errore logico lì.

Sembra semplice, ma mi sono bloccato su qualcosa e non l'ho capito subito. Accidenti. Succede... :(

 

Buon pomeriggio!

La mia domanda sarà un po' fuori tema.

Potete dirmi se è possibile trovare da qualche parte l'affettamento delle forme TA come file CSV? Posso usare txt, xls o qualsiasi altro formato che possa essere elaborato programmaticamente.

Ci sono esempi di figure di AT in vari articoli di AT, libri di testo, ma naturalmente come immagini ordinarie. Qualcuno ha una serie più o meno grande di simboli TA salvati come una fetta di storia di qualche coppia di valute sui periodi H1-H4, diciamo?

Ho cercato su Google e non ne ho trovati. Naturalmente, possiamo passare manualmente attraverso la storia, marcare le forme, esportare questo pezzo di storia come .csv; ripetere il numero necessario di volte, raccogliere la base delle forme alla fine. Ma se qualcuno l'ha già fatto, vorrei risparmiare tempo.

Grazie in anticipo :)

1...316317318319320321322323324325326327328329330...432
Nuovo commento
Motivazione: