Problemi di chiusura, per favore aiutatemi - pagina 5
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
Ciao Ais
La tua risposta mi fa piacere. Sentirti dire che mi avresti aiutato a capire la complessità e poi a ridurre la complessità, era più di quanto potessi chiedere. Mi umilio davanti alla tua generosità. Grazie.
Ho una domanda sulla struttura dei commenti nei vostri programmi. Non che io voglia uscire dal treno di pensieri che è progredito, ma una domanda su come appare il formato non mi è familiare.
Esempio:
// < Struttura 17 elementi in 4 domini > //< >
// < 1. Dati 8 elementi in 2 domini /> //< >
// < 2. Codice 9 elementi in 2 domini /> //< >
// </Structure> 17 elementi in 4 domini > //< >
// //< >
// < 1. Dati 8 = 5 i 3 d - s > //< >
// < 1.1. Ingresso 7 = 4 i 3 d - s /> //< >
// < 1.2. Buffer 1 = 1 i - d - s /> //< >
// </1. Dati 8 = 5 i 3 d - s > //< >
// //< >
I commenti sono strutturati in modo percettivo. Con titoli e sotto commenti, sarebbe il modo migliore per me di descrivere ciò che leggo. Come se i commenti fossero sviluppati e formati o strutturati da una macchina da codice? È impressionante. Non che io capisca tutto ciò che è commentato. La vostra abilità nell'organizzazione la trovo rinfrescante.
Grazie ancora. Studierò il programma e avrò altre domande in un futuro molto prossimo.
Saluti
Ciao Huckleberry
Mi fa piacere sentirti.
1. La struttura
La struttura è sviluppata e formattata da me stesso.
// //< > // < Structure 16 elements in 4 domains > //< > // < 1. Data 7 elements in 2 domains /> //< > // < 2. Code 9 elements in 2 domains /> //< > // </Structure 16 elements in 4 domains > //< > // //< >La prima intenzione è di separare rigorosamente i dati globali e il codice.
Il programma per computer per me è un modello del mondo reale.
I dati globali sono le cose di questo mondo.
Il codice è l'insieme delle azioni.
Separandoli sottolineo che capisco la differenza tra loro.
Contare il numero di elementi mi aiuta a verificare e controllare tutto all'interno del programma.
2. La formattazione
La formattazione è un semplice HTML.
Il tag seguente apre la parte di programma:
// < > //< >Il tag seguente chiude la parte di programma:
// </ > //< >Il tag seguente è usato per parti di programma in una sola riga:
// < /> //< >La parte finale del tag ora è usata per il conteggio delle pagine.
In futuro l'uso di questa parte di tag può essere esteso.
//< >La struttura delle pagine aiuta a navigare facilmente nel programma.
Usando <Page Up> e <Page Down> vedo sempre gli stessi tipi di tag negli stessi posti.
3. Gli elementi
L'elemento dei dati è una singola variabile globale.
Anche io vedo l'array come elemento singolo.
Le variabili locali sono solo entità temporanee di elementi di codice.
L'elemento di codice è una singola funzione.
Posso anche usare la parola "metodo".
Uso la parola "interfaccia" per un insieme unito di funzioni.
Per ridurre la complessità, divido dati e codice in domini logici.
Il numero di domini dipende dalla struttura del programma.
Domini usuali per i dati: "input", "settings", "control", "buffer" ...
Domini usuali per il codice: "special" per l'insieme di funzioni speciali, "interface" per l'insieme di altre funzioni.
Nel caso di grandi programmi posso creare "oggetti" con diverse "interfacce".
Per controllare l'integrità degli elementi di dati e di codice si usa il conteggio.
// //< > // < 1. Data 7 = 4 i 3 d - s > //< > // < 1.1. Input 7 = 4 i 3 d - s /> //< > // < 1.2. Buffer - = - i - d - s /> //< > // </1. Data 7 = 4 i 3 d - s > //< > // //< > // < 2. Code 9 / - i 82 l 4 o > //< > // < 2.1. Interface 6 / - i 71 l 4 o /> //< > // < 2.2. Special 3 / - i 11 l - o /> //< > // </2. Code 9 / - i 82 l 4 o > //< > // //< >I tag di apertura e di chiusura contengono le stesse somme.
Di solito conto la somma nel tag di apertura.
Poi semplicemente copio e inserisco il tag di apertura al posto di quello di chiusura e poi aggiungo la barra di chiusura "/".
Per controllare l'integrità dei dati si usa la seguente notazione.
Il numero di elementi di dati di "integer" è annotato come "i".
Il numero di elementi di dati di "double" è indicato con "d".
Il numero di elementi di dati di "stringa" è indicato con "s".
La colonna di sinistra contiene la somma della linea "i" + "d" + "s".
Per controllare l'integrità del codice si usa la seguente notazione.
Il numero di ingressi di funzione, cioè il numero di argomenti di funzione, è annotato come "i".
Il numero di linee di codice aperte è indicato con "l".
Il numero di uscite della funzione è indicato con "o".
Sempre "1" per singola funzione che restituisce qualsiasi valore e "-" in tutti gli altri casi.
La colonna di sinistra contiene il numero di funzioni nel dominio.
4. I domini
Queste sono le intestazioni dei domini.
////////////////////////////////////////////////////////////////////< 2> // < 1.1. Data : Input > //< > // //< > // < 1.1. Input 7 = 4 i 3 d - s > //< > // < 1. Strategy 4 = 2 i 2 d - s /> //< > // < 2. Trading 3 = 2 i 1 d - s /> //< > // </1.1. Input 7 = 4 i 3 d - s > //< > // //< >////////////////////////////////////////////////////////////////////< 3> // < 1.2. Data : Buffer > //< > // //< > // < 1.2. Buffer - = - i - d - s > //< > // </1.2. Buffer - = - i - d - s > //< > // //< >////////////////////////////////////////////////////////////////////< 4> // < 2.1. Code : Interface > //< > // //< > // < 2.1. Interface 6 / - i 71 l 4 o > //< > // < 1. iNewBar - i 4 l 1 o /> //< > // < 2. iSignalOpen - i 15 l 1 o /> //< > // < 3. iSignalClose - i 15 l 1 o /> //< > // < 4. iGetTicket - i 7 l 1 o /> //< > // < 5. iTryOpen - i 15 l - o /> //< > // < 6. iTryClose - i 15 l - o /> //< > // </2.1. Interface 6 / - i 71 l 4 o > //< > // //< >////////////////////////////////////////////////////////////////////< 11> // < 2.2. Code : Special > //< > // //< > // < 2.2. Special 3 / - i 11 l - o > //< > // < 1. init - i 1 l - o /> //< > // < 2. deinit - i 1 l - o /> //< > // < 3. start - i 9 l - o /> //< > // </2.2. Special 3 / - i 11 l - o > //< > // //< >Le regole e le notazioni per il conteggio sono le stesse dell'intestazione del programma.
Copio semplicemente i tag di apertura delle intestazioni dei domini nell'intestazione del programma.
Ogni pagina nel dominio ha dei tag di apertura e di chiusura.
Per esempio:
////////////////////////////////////////////////////////////////////< 12> // < 2.2.1. Code : Special : Init > //< > .. // </2.2.1. Code : Special : Init > //< >I numeri iniziali sono usati per il conteggio e la navigazione delle parti della struttura.
Poi segue la notazione per la parte di programma "Dati" o "Codice".
Poi segue il nome del dominio.
Poi segue il nome dell'elemento del dominio.
Spero che questo possa aiutare.
Ciao per ora e in attesa della tua risposta
Ciao Ais
Il tuo senso di organizzazione è ...... come si può dire ..... pratico e sensato.
L'integrazione dell'HTML facilita la navigazione, anche se per il momento non sono in grado di capirlo.
Molto bene.
In questo momento, sto analizzando il programma che mi hai mandato, un'affermazione alla volta. I concetti
I concetti che hai sulle variabili sono comprensibili. Grazie ancora.
Ti risponderò con domande, ne sono sicuro.
Ciao
Ciao Ais,,,<questo è stato modificato>
Il programma non è stato ancora assorbito. Mi dispiace che ti stia prendendo così tanto tempo. C'è una zona che mi deve essere sfuggita,
perché ho un errore con cui fare i conti.
Devo andare per ora, ma tornerò domani.
Arrivederci per ora
Ciao Huckleberry
Alcune caratteristiche sono state aggiunte per esempio e possono essere facilmente cambiate o rimosse.
Il miglioramento del programma è un processo continuo.
Ciao per ora
:)
Ciao Huckleberry
Alcune caratteristiche sono state aggiunte per esempio e possono essere facilmente cambiate o rimosse.
Il miglioramento del programma è un processo continuo.
Ciao per ora
:)
Ciao AisGrazie per tutto quello che hai fatto.
Ieri sera ho finalmente trovato il mio errore mentre stavo copiando il tuo programma.
In questo momento sto cercando di capire a cosa servono alcune delle variabili e come funzionerebbero.
L'iSignalClose è dove sto inserendo parte del mio altro programma per stabilire l'OrderClosePrice. Con
vostro suggerimento:
dDelta = OrderOpenPrice () - OrderClosePrice
il programma è più flessibile.
Tornerò con altre domande. E commenti.
Saluti
Ciao Ais
Le domande si sono verificate. Il tuo programma afferma in ..... iTryOpen ()
Per mia curiosità, dovrebbe esserci
Ecco un'altra domanda per capire meglio Se iNewBar è TRUE, il controllo viene passato a iSignalOpen. Se iNewBar è TRUE (uguale alla barra corrente??), OPPURE iFirstRun ==1, allora iFirstBar = 0. Questo mi confonde solo perché non capisco la definizione di iNewBar () e/o di iFirstRun. Posso vedere dove iFirstRun è decaduto e inizializzato, ma cosa significa.Mi dispiace di opprimervi con domande così semplici. Non posso calcolare o vedere come i due lavorano all'interno della funzione. Quando hai tempo, potresti chiarire questo punto per favore.
Grazie ancora per i vostri sforzi : )
Saluti
Ciao Huckleberry
Entrambe le domande sono importanti!
Risposta 1.
Entrambe le condizioni sono vere, ma se:
1.1. sappiamo che
int iCommand = iSignalOpen () ; //< >1.2. sappiamo che "iSignalOpen ()" può restituire solo 3 possibili valori: "EMPTY", "OP_BUY" e "OP_SELL";
1.3. il primo valore è già controllato
if ( iCommand == EMPTY ) return ; //< >1.4. anche il secondo valore è controllato
if ( iCommand == OP_BUY ) //< >allora è possibile omettere l'ultimo controllo "if" per velocizzare leggermente i calcoli.
else if ( iCommand == OP_SELL ) //< >Risposta 2.
2.1. Riconosciamo che la barra numero 0 è cambiata confrontando il tempo di apertura della barra numero 0 con l'ultimo tempo di apertura memorizzato della barra numero 0.
"iTime ( 0, 0, 0 )" restituisce il tempo di apertura della barra corrente incompleta.
L'indice della barra corrente è sempre 0, è il terzo valore in "iTime ( 0, 0, 0 )".
Dichiarare la variabile "int iTime_0" come "static" significa che il valore di questa variabile viene salvato tra le invocazioni della funzione.
Ogni volta che il tempo di apertura viene cambiato, noi:
2.1.1. assegniamo "iTime_0 = iTime ( 0, 0, 0 ) ;" per memorizzare il tempo di apertura della barra corrente;
2.1.2. restituiamo "TRUE" che significa che la barra corrente è una nuova barra, l'ultima barra numero 0 è diventata la barra numero 1.
////////////////////////////////////////////////////////////////////< 5> // < 2.1.1. Code : Interface : iNewBar > //< > int iNewBar () // - i 4 l 1 o //< > { //< > static int iTime_0 = 0 ; //< > // //< > if ( iTime_0 < iTime ( 0 , 0 , 0 ) ) //< > { iTime_0 = iTime ( 0 , 0 , 0 ) ; return ( TRUE ) ; } //< > else { return ( EMPTY ) ; } //< > } //< > // </2.1.1. Code : Interface : iNewBar > //< >2.2. La nostra barra di partenza per i calcoli di "dHigh" e "dLow" in "iSignalOpen ()", e "dATR" in "iSignalClose ()", è "iBaseBar=1".
Mentre la barra numero 1 è la stessa, questi valori sono gli stessi.
È un motivo per calcolare questi valori solo sulle nuove barre.
Questo velocizza il programma.
La variabile "static int iFirstRun" è un semplice trigger.
Il valore iniziale "1" forza il calcolo di "dHigh", "dLow" e "dATR" alla prima esecuzione del programma, indipendentemente da qualsiasi condizione.
Questo migliora l'affidabilità del programma.
<aggiunto dopo>
Esattamente, alla prima esecuzione del programma "iNewBar ()" in "iSignalOpen ()" ritorna "TRUE", e in "iSignalClose" ritorna "EMPTY"!
Questo perché alla prima invocazione di "iNewBar ()", cioè all'interno della prima esecuzione di "iSignalOpen ()", il valore di "iTime_0 = 0", e sulla seconda invocazione di "iNewBar ()", cioè all'interno della prima esecuzione di "iSignalClose ()", "iTime_0 = iTime ( 0, 0, 0 )"!
Come risultato senza controllo della prima esecuzione può essere "dATR = 0".
Tale è la prima esecuzione.
</Aggiunto dopo>.
Subito dopo assegniamo "iFirstRun = 0" e la seguente condizione sarà vera solo sulle nuove barre:
if ( ( iNewBar () == TRUE ) || ( iFirstRun == 1 ) ) //< >Ma!
Resto del codice di "iSignalOpen ()" e "iSignalClose ()" eseguito su ogni tick!
Solo i calcoli dei valori invariati sono saltati.
////////////////////////////////////////////////////////////////////< 6> // < 2.1.2. Code : Interface : iSignalOpen > //< > int iSignalOpen () // - i 15 l 1 o //< > { //< > static int iFirstRun = 1 ; //< > if ( ( iNewBar () == TRUE ) || ( iFirstRun == 1 ) ) //< > { iFirstRun = 0 ; //< > int iIndexH = iHighest ( 0 , 0 , MODE_HIGH , //< > iBaseLag , iBaseBar ) ; //< > int iIndexL = iLowest ( 0 , 0 , MODE_LOW , //< > iBaseLag , iBaseBar ) ; //< > static double dHigh ; dHigh = High [ iIndexH ] ; //< > static double dLow ; dLow = Low [ iIndexL ] ; //< > } // if //< > // //< > double dAsk = MarketInfo ( Symbol () , MODE_ASK ) ; //< > if ( dAsk > dHigh ) return ( OP_BUY ) ; //< > // //< > double dBid = MarketInfo ( Symbol () , MODE_BID ) ; //< > if ( dBid < dLow ) return ( OP_SELL ) ; //< > // //< > return ( EMPTY ) ; //< > } //< > // </2.1.2. Code : Interface : iSignalOpen > //< >Spero che questo possa aiutare.
Grazie!
:)
P.S. Alcune osservazioni aggiunte in seguito.
E, guardando queste osservazioni, è ovvio che "iNewBar ()" deve essere corretto.
Questo perché questa funzione invocata due volte per controllare un singolo evento.
Ora, per lo stesso evento sulla prima invocazione "iNewBar ()" restituisce un valore corretto, e sulla seconda restituisce un valore sbagliato.
Sarà corretto.
Ciao Ais
Grazie per il chiarimento. Seguirò con altre letture. Non ho ancora una conoscenza completa del codice.
Ma hai detto che c'era qualcosa che doveva essere corretto per quanto riguarda la iNewBar? Non sono sicuro che la iNewBar sia responsabile del problema che il backtest ha rivelato. Possibili due problemi?
Ecco cosa ho visto quando ho aperto il grafico dopo un backtest. Sappiamo che c'è un'entrata Buy quando l'Ask è sopra il massimo più alto delle ultime venti barre. Il Sell è esattamente l'opposto. Eppure le entrate non sono coerenti. È questa l'area che hai visto?
Ho trovato un'altra cosa. L'Hard Stop è calcolato Atr*2. Questo è corretto, ma non vedo dove viene calcolato. Ma il vero problema è che il TakeProfit ha lo stesso calcolo Atr*2. Se sapessi dove viene calcolato l'Hard Stop, potrei eventualmente correggere il TakeProfit. Il TakeProfit in questo caso dovrebbe essere solo Atr*1.
Abbiate cura di voi e tornerò domani.
Saluti
Ciao Huckleberry
La condizione TakeProfit è stata inventata da me per scopi di test.
Ora è cambiata.
Invece di "Atr*2" e "Atr*1" uso "dATR * dFactorTP" e "dATR * dFactorSL".
I valori iniziali "dFactorTP = 1.0" e "dFactorSL = 2.0" sono nella pagina 2 "Data :
Tale soluzione permette di ottimizzare facilmente questi valori.
Ho cambiato le funzioni "iSignalOpen ()" e "iSignalClose ()".
Il controllo della nuova barra è ora implementato in queste funzioni.
Le condizioni per "Buy" e "Sell" in "iSignalOpen ()" sembrano probabilmente corrette.
Il programma completo è nel file allegato nella prossima pagina.
Salute