Domande dai principianti MQL5 MT5 MetaTrader 5 - pagina 574
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
L'idea di aprire ordini su un segnale di acquisto o di presa dell'orso, come fare in modo che ci sia solo un trade di acquisto/vendita e un trade di ordine pendente, ne ho uno aperto su ogni tick del trade. Aiuta a risolvere il problema.
Bene, ecco un altro modo per farlo: le partite sono scritte per ogni candela nel range. Nella versione precedente, le corrispondenze venivano scritte solo per una candela - cioè non veniva scritta nessuna corrispondenza per quella che corrispondeva a questa.
Artem, grazie. Ci darò un'occhiata.
I valori alti possono essere arrotondati, per esempio possiamo arrotondare il valore 1,23456 a 1,2346.
Ho capito cosa voglio dire. Aggiungo anche una variabile nelle impostazioni in cui è possibile prescrivere la deviazione entro la quale i valori di alto essere considerati uguali. È necessario perché per le citazioni a 4 cifre spesso non c'è questo problema, ma per le citazioni a cinque cifre cercare le corrispondenze esatte è infinitamente possibile.
Artem, grazie. Ci darò un'occhiata.
L'arrotondamento è chiaro. Ho anche messo una variabile nelle impostazioni, in cui potrò prescrivere il valore di deviazione entro il quale i valori alti sono considerati uguali. È necessario, perché per le citazioni a 4 cifre spesso non c'è questo problema, ma per le citazioni a cinque cifre la ricerca di corrispondenze esatte è infinita.
Non c'è di che. Ho fatto un'imprecisione nella seconda versione. Poiché nella prima versione stavamo cercando le corrispondenze a partire dalla prossima candela dall'indice del ciclo, il passaggio del ciclo principale era per il numero di candele meno una per confrontare le due candele più esterne. Ora, nella seconda versione, per ciascuno dei candelieri cerchiamo le corrispondenze su tutto l'intervallo, quindi nella linea
dovreste cambiare il numero di barre in
Controlla il numero di ordini impostati e il numero di posizioni aperte prima di aprire una nuova posizione o piazzare un nuovo ordine pendente.
cioè è necessario aggiungere una condizione per controllare il numero di ordini e posizioni nelle condizioni per un trade?
if (o4>c4&&o3>c3&&l2>l1&&c2<c1&&o2>c2&&o1<c1&&c1>o2&&h1>h2||o2>c1&h2>h1&h1<o2&o1<c1&&l2>l1&&o3>c3&&o4>c4){ //first condition
if (OrdersTotal()==0) //seconda condizione
OrderSend(Symbol(), OP_BUY,Lot,o,10,l1,0); } ................................... e così per ogni scambio?
E quale funzione conta il numero di posizioni aperte?
Credo di aver risolto il problema:
se (Ora()>=0&Ora()<23){
if (o4>c4&&o3>c3&&l2>l1&&c2<c1&&o2>c2&&o1<c1&&c1>o2&&h1>h2||o2>c1&&h2>h1&&h1<o2&&o1<c1&&l2>l1&&o3>c3&&o4>c4){
se (PositionsTotal()<=1)
OrderSend(Symbol(), OP_BUY,Lot,o,10,l1,0); } //opera Acquista
if (o4>c4&&o3>c3&&l2>l1&&c2<c1&&o2>c2&&o1<c1&&c1>o2&&h1>h2||o2>c1&&h2>h1&&h1<o2&&o1<c1&&l2>l1&&o3>c3&&o4>c4){
se (PositionsTotal()==1&OrderType()==0)
OrderSend(Symbol(), OP_SELLSTOP,Lot,l2,10,h2,0);} /Ordine SellStop posticipato
if (o4<c4&&o3<c3&&h2<h1&&c2>c1&&o2<c2&&o1>c1&&c1<o2&&l1<l2||o2<c1&&l2<l1&&l1>o2&&o1>c1&&h2<h1&&o3<c3&&o4<c4){
se (PositionsTotal()<=1)
OrderSend(Symbol(),OP_SELL,Lot,o,10,h1,0); } //apre la vendita
if (o4<c4&&o3<c3&&h2<h1&&c2>c1&&o2<c2&&o1>c1&&c1<o2&&l1<l2||o2<c1&&l2<l1&&l1>o2&&o1>c1&&h2<h1&&o3<c3&&o4<c4){
se (PositionsTotal()==1&OrderType()==1)
OrderSend(Symbol(), OP_BUYSTOP,Lot,h2,10,l2,0);} /Ordine BuyStop posticipato
}
//+------------------------------------------------------------------+
/Funzione che restituisce il totale delle posizioni aperte |
// |
//+------------------------------------------------------------------+
int PositionsTotal() {
int pos = 0;
per (int i=0; i<OrdersTotal(); i++) {
OrderSelect(i, SELECT_BY_POS, MODE_TRADES);
if (OrderType() == OP_BUY || OrderType() == OP_SELL)
pos++;
}
ritorno(pos);
}
//+------------------------------------------------------------------+
Bene, ecco un altro modo per farlo: le partite sono scritte per ogni candela nel range. Nella versione precedente, le corrispondenze venivano scritte solo per una candela - cioè non veniva scritta nessuna corrispondenza per quella che corrispondeva a questa.
Bene. Ma per come la vedo io, se il massimo della candela 2 coincide con il minimo della candela 7, allora si troveranno due corrispondenze: 2 <=> 7, 7 <=>2. E che dire della contabilizzazione delle coppie inverse, ma senza il ciclo extra?
Non puoi risolvere il problema in un solo passaggio, senza usare cicli for annidati:)))?
Gud. Tuttavia, da quanto ho capito, se il massimo della candela 2 coincide con il massimo della candela 7, allora si troveranno due corrispondenze: 2 <=> 7, 7 <=>2. E che dire della contabilizzazione delle coppie inverse, ma senza il ciclo extra?
Che ne dite di risolvere il problema in una volta sola, senza usare cicli for annidati:)))?
:) Non cercare di farmi passare perdebole;) Naturalmente, penso che si possa risolvere il problema con un solo ciclo, ma ero troppo pigro per pensare più a lungo e ho fatto come ho pensato subito.
Naturalmente, qui tutte le candele accoppiate o più sono registrate nei dati di corrispondenza di ogni candela. Ecco perché si incrociano. Sto solo suggerendo delle varianti, senza sapere a cosa servono.
E inoltre è possibile risolvere il compito di ottimizzazione dei calcoli, ma non ne ho bisogno.
E cosa succede se avete bisogno esattamente dei dati per ogni candela e tutte le partite, e cosa succede se, improvvisamente, improvvisamente ... c'è solo ....
Quindi non ho né tempo né voglia. Ho sprecato il mio tempo invece di scrivere i miei codici.
SZY, forse dovresti anche collegare i metodi Kohonen conoscendo il parametro di input richiesto.
In generale - senza tempo e senza voglia. E così ho perso tempo invece di scrivere i miei codici.
È un peccato, è un peccato.
Non c'è di che. Ho fatto un'imprecisione nella seconda versione. Poiché la prima versione cercava le corrispondenze a partire dalla prossima candela dall'indice del ciclo, il ciclo principale veniva passato dal numero di candele meno una per confrontare le due candele più esterne. Ora, nella seconda versione, per ciascuno dei candelieri cerchiamo le corrispondenze su tutto l'intervallo, quindi nella linea
dovreste cambiare il numero di barre in
Per favore, dicci il significato di queste righe:
input int Search_Period=10; // Numero di candele da copiare
int searchPeriod=(Search_Period<1)?1:Search_Period; // cosa significano i simboli "?", ":"?
input int Delta=2; // Numero di punti di ammissione
int delta=(Delta<0)?0:Delta; // cosa significano i simboli "?", ":"?
Per favore, ditemi il significato di queste righe:
input Search_Period=10; // Numero di candele da copiare
int searchPeriod=(Search_Period<1)?1:Search_Period; // cosa significano i caratteri "?", ":"?
input int Delta=2; // Numero di punti di ammissione
int delta=(Delta<0)?0:Delta; // cosa significano i simboli "?", ":"?
Da riferimento:
Operatore condizionale ?
La forma generale di un operatore ternario si presenta così:
espressione1? espressione2: espressione3
Come primo operando, "expression1" può essere qualsiasi espressione che risulti in un valore di tipo bool. Se il risultato è vero, viene eseguito l'operatore specificato dal secondo operando, "expression2" .
Se il primo operando èfalso, il terzo operando, "espressioneZ", viene eseguito. Il secondo e il terzo operando, cioè "espressione2" e "espressioneZ", devono restituire valori dello stesso tipo e non devono essere di tipo nullo. Il risultato dell'esecuzione dell'operatore condizionale è il risultato di "espressione2" o il risultato di "espressione3", a seconda del risultato di "espressione1".
//--- rinormalizzare la differenza tra i prezzi di apertura e di chiusura per l'intervallo giornaliero
double true_range = (High==Low)?0:(Close-Open)/(High-Low);
Questa voce è equivalente alla seguente
doppio_range;
if(High==Low)true_range=0;// se High e Low sono uguali
else true_range=(Close-Open)/(High-Low);// se High non è zero