Il mercato e la fisica dei suoi modelli globali
588
0
Introduzione
In questo articolo cercheremo di capire come la fisica del mercato possa essere utilizzata per il trading automatico. Il linguaggio della matematica implica il passaggio dall'astrattezza e dall'incertezza alla previsione. Ciò consente di operare con formule o criteri chiari, piuttosto che con valori approssimativi e vaghi, nel tentativo di migliorare la qualità dei sistemi creati. Non inventerò teorie o modelli, ma utilizzerò solo fatti noti, traducendoli gradualmente nel linguaggio dell'analisi matematica. La fisica del mercato è impossibile senza la matematica, perché i segnali che generiamo sono sostanza matematica. Molte persone cercano di creare varie teorie e formule senza alcuna analisi statistica o utilizzando statistiche molto limitate, che spesso non sono sufficienti per conclusioni così audaci. Solo la pratica è il criterio della verità. Prima cercherò di riflettere un po' e poi, sulla base di queste riflessioni, creerò un Expert Advisor (EA). Seguirà il test dell’EA.
Prezzo e caratteristiche
Qualsiasi contesto di mercato implica l'esistenza di diversi prodotti. Nel mercato valutario, il prodotto è la valuta. Per valuta si intende il diritto di possedere un determinato prodotto o informazione, che viene impostato come punto di riferimento in tutto il mondo. Consideriamo ad esempio la coppia EURUSD e il valore attuale del suo grafico. Il valore attuale del grafico significherà USD/EUR = PrezzoCorrente. Oppure: USD = EUR*PrezzoCorrente, ovvero la quantità di dollari contenuta in un euro. In altre parole, il valore mostra il rapporto tra il peso di ciascuna valuta, mentre, ovviamente, si presuppone che esista un equivalente comune di scambio per ciascuna valuta, ossia una merce comune o qualcos'altro. Il prezzo si forma nell’order book e le dinamiche dell’order book determina il movimento del prezzo. Va sempre ricordato che non saremo mai in grado di prendere in considerazione tutti i fattori di formazione dei prezzi. Ad esempio, il FORTS è collegato al FOREX ed entrambi i mercati si influenzano a vicenda. Non sono un esperto di questa varietà, ma sono in grado di capire che tutto è legato e che più canali di dati ci sono, meglio è. Mi sembra che sia meglio non scendere nei dettagli, ma concentrarsi sulle cose semplici che muovono il prezzo.
Qualsiasi dipendenza può essere rappresentata come una funzione di molte variabili, come qualsiasi quotazione. Inizialmente il prezzo è:
- P=P(t)
In altre parole, il prezzo è una funzione del tempo. La forma della funzione non può essere stabilita in modo affidabile per ogni coppia di valute o per qualsiasi altro strumento, poiché richiederebbe un tempo infinito. Ma questa presentazione non ci dà nulla. Tuttavia, il prezzo ha una doppia natura, in quanto presenta sia una componente prevedibile che una casuale. La parte prevedibile non è la funzione in sé, ma la sua prima derivata. Non ha senso rappresentare questa funzione come alcuni termini, poiché non ha alcuno scopo per il trading. Ma se consideriamo la sua prima derivata, si verifica quanto segue:
- P'(t)=Pa'(t)+Pu'(t)
In questo caso, il primo termine riflette la parte che può essere analizzata in qualche modo con l'analisi matematica, mentre il secondo è una parte imprevedibile. Sulla base di questa formula, possiamo dire che non è possibile prevedere l’ampiezza e la direzione del movimento con una precisione del 100%. Non è necessario pensare a quale sarà l'ultimo termine, poiché non possiamo determinarlo. Ma possiamo determinare il primo. Si può ipotizzare che questo termine possa essere rappresentato in una forma diversa, tenendo conto che la funzione valore è discreta e non si possono applicare operazioni differenziali. Possiamo invece prendere la derivata media nel tempo "st". Se applicato al prezzo, sarà la durata di una barra; se applicato ai tick, sarà il tempo minimo tra due tick.
- PaM(t)=(Pa(t)-Pa(t-st))/st - il movimento medio del prezzo (derivato temporale) in un periodo di tempo fisso
- Ma(t)=Ma(P(t),P(t-st) + ... + P(t-N*st), D(t),D(t-st) + ... + D(t-N*st),U[1](),U[2](t) + ... + U[N](t) )
- P(t[i]) - vecchi valori di prezzo (dati di barra o tick)
- D(t[i]) - vecchi valori di prezzo su altre coppie di valute
- U[i](t) - altri valori sconosciuti o noti che influenzano il mercato
- Ma(t) - aspettativa matematica del valore PaM(t) in un determinato momento
In altre parole, assumiamo che la parte prevedibile del prezzo possa dipendere dalle barre o dai tick precedenti, nonché dai dati di prezzo di altre coppie di valute, dai dati di altri mercati e dagli eventi mondiali. Tuttavia, si dovrebbe comprendere che anche questa parte del prezzo non può essere prevista con una precisione del 100%, ma possiamo solo calcolare alcune delle sue caratteristiche. Tale caratteristica può essere solo una probabilità o i parametri di una variabile casuale, come l'aspettativa matematica, la varianza, la deviazione standard e altre grandezze della teoria della probabilità. Operare con aspettative matematiche può essere sufficiente per rendere il trading profittevole. Dopo aver preso tempo e riflettuto attentamente, possiamo giungere alla conclusione che il mercato può essere analizzato non solo utilizzando questa logica. Il fatto è che la parte prevedibile del prezzo si sviluppa sulla base dell'attività degli operatori di mercato. Possiamo scartare diversi parametri di mercato, ad eccezione dei fattori creati dagli stessi operatori del mercato. Naturalmente, tutto ciò porta ad una diminuzione dell'affidabilità del nostro metodo di analisi, ma semplifica notevolmente il modello. In questo caso, più piccolo è il valore di "st", più accuratamente le nostre formule descrivono il mercato.
- VMa(t)=VMa(P(t),P(t-st) + ... + P(t-N*st))
- VMa(t)=VBuy(t)-VSell(t)
- VMa(t) - volumi totali
- VBuy(t) - volumi degli ordini Buy aperti
- VSell(t) - volumi degli ordini Sell aperti
La funzione sopra descrive la differenza dei volumi di tutte le posizioni Buy e Sell attualmente aperte. Una parte di queste posizioni si compensano a vicenda, mentre le altre sono indipendenti. Poiché le posizioni sono aperte, simboleggiano una promessa di chiusura dopo un po' di tempo. Sappiamo tutti che comprare fa salire il prezzo e vendere lo fa scendere. L'unico modo per sapere dove andrà il prezzo è misurare i volumi delle posizioni aperte e stimare la direzione di queste posizioni, tenendo in considerazione solo gli ordini di mercato aperti.
La natura ondulatoria del mercato è in realtà legata a questo semplice fatto. Questo è solo un caso particolare di un processo più generale di fluttuazione dei volumi delle posizioni, o delle azioni di tori e orsi.
Quando si opera con le barre, è anche possibile tenere conto del fatto che ci sono 4 prezzi all'interno di una barra, il che può fornire formule migliori. Più dati significano un'analisi più accurata, ed è per questo che è importante considerare tutti i dati relativi ai prezzi. Tuttavia, non mi piace contare ogni tick, perché questo rallenterebbe gli algoritmi di dieci volte. Inoltre, i dati dei tick possono essere differenti con i vari broker. Al contrario, i prezzi di apertura e chiusura delle barre sono quasi identici per la maggior parte dei broker. Modifichiamo la funzione dei volumi per tenere conto di tutti i dati di prezzo:
- VMa(t)=VMa(O(t),O(t-st) +...+ O(t-N*st) + C(t),C(t-st) + C(t-N*st),H(t),H(t-st)...H(t-N*st),L(t),L(t-st)...L(t-N*st))
Potremmo aggiungere altre variabili a questa funzione, come l'ora, i giorni della settimana, i mesi e le settimane, ma questo produrrebbe molte funzioni legate a specifiche aree di mercato, mentre il nostro scopo è quello di determinare la fisica generale del mercato. Sapremo che non può essere infranto e quindi può essere utilizzato finché il mercato esiste. Un altro vantaggio della formula è la sua natura multivaluta.
In termini pratici, l'uso di questo tipo di rappresentazione non ha senso, poiché è necessario sapere esattamente come e sulla base di quali dati costruire questa funzione. Non possiamo limitarci a scrivere la forma di questa funzione e determinare le dipendenze. Ma queste espressioni possono aiutarci a comprendere inizialmente come analizzare e come passare alle ipotesi successive. Qualsiasi insieme di condizioni logiche può essere rappresentato come tale funzione. Al contrario, la funzione stessa può essere trasformata in un insieme di condizioni. Non importa quale forma usiamo. È importante solo capirlo. Qualsiasi algoritmo può essere ridotto a una singola formula. A volte è più facile descrivere i segnali come condizioni o un sistema di condizioni che costruire una funzione super complessa. Un'altra grande domanda è come costruire una funzione di questo tipo.
In un sistema di trading reale, non possiamo analizzare l'intera storia in una sola volta, ma possiamo analizzare solo un periodo di tempo prestabilito. Esistono 4 possibili approcci a tale analisi. Creerò dei nomi per loro e li spiegherò:
- Formule (indicatori o loro funzioni)
- Simulazione
- Matematica generale
- Tipi di apprendimento automatico
La prima opzione presuppone l'utilizzo di un determinato valore o di un insieme di valori. Un esempio è rappresentato da un indicatore o dalla nostra stessa formula. Il vantaggio di questo approccio è la disponibilità di un ampio kit di strumenti nei terminali MetaTrader 4/5. Inoltre, esistono numerosi indicatori basati sulle teorie di mercato più diffuse, disponibili sul Market e sul web. Lo svantaggio di questo approccio è che nella maggior parte dei casi non riusciremo a capire in base a cosa funziona l'indicatore. Anche se lo comprendessimo, tale comprensione può essere di nessun valore.
Nella seconda opzione, non utilizziamo i dati che non comprendiamo o che possono essere inutili. Possiamo invece provare a simulare gli ordini sul mercato e così sapremo che il nostro sistema sarà in grado di descrivere in qualche misura quante posizioni sono aperte in una direzione e quante nell'altra. Queste informazioni possono produrre le previsioni necessarie, consentendo una descrizione accurata del mercato in una prospettiva globale. Questa è l'unica alternativa all'apprendimento automatico.
Per matematica si intende la comprensione di alcune leggi fondamentali o la conoscenza di alcuni principi matematici che consentono di sfruttare qualsiasi quotazione, a prescindere dall'attuale situazione di mercato. Il fatto è che tutte le funzioni, comprese quelle discrete, hanno alcune caratteristiche che possono essere sfruttate. Naturalmente, qui si assume che la dipendenza non sia caotica (nel nostro caso, il forex non è caotico, quindi è possibile sfruttare qualsiasi quotazione). Nel prossimo articolo analizzeremo uno di questi principi, che quasi tutti conoscono. Ma conoscere e saper usare sono due cose diverse. Il vantaggio di questo approccio è che se riusciamo a costruire un sistema efficace, non dovremo preoccuparci di come si comporterà in futuro.
Il quarto approccio è quello più avanzato, in quanto l'apprendimento automatico può sfruttare al meglio qualsiasi dato. Maggiore è la potenza di calcolo, più alta è la qualità dell'analisi. L'aspetto negativo di questo approccio è che non aiuta a comprendere la fisica del mercato. Il vantaggio è la semplicità dell'approccio, la massima qualità dei risultati con il minimo dispendio di tempo. Ma questo approccio non è applicabile in questo articolo.
Informazioni sui modelli
Il trading quotidiano implica una pletora di termini, ognuno dei quali ha un livello di importanza diverso. Alcuni termini vengono utilizzati molto spesso, anche se non tutti i trader ne comprendono il vero scopo. Uno di questi termini è Pattern (Modello). Cercherò di spiegarlo con il linguaggio della matematica. Un pattern è sempre legato ad uno specifico periodo di tempo, e ad una specifica coppia di valute e periodo grafico. Alcuni pattern sono forti. Tali pattern possono essere di natura multivaluta o globale. Un pattern ideale è il Graal. Ci sono alcune affermazioni che possono essere applicate a qualsiasi pattern:
- L'esistenza di una formula o di un insieme di condizioni che simboleggiano il pattern
- Valori minimi di test nel tester della strategia o valori di performance su un conto demo o reale
- Classificazione di un pattern in termini di prestazione per tutte le coppie di valute e i periodi del grafico
- Il periodo storico in cui è stato individuato il pattern
- L'intervallo di tempo futuro, durante il quale il pattern rimane operativo.
- Il secondo periodo di tempo nel futuro, successivo al primo, durante il quale il pattern originale mantiene alcuni parametri o li inverte.
Leggendo attentamente ogni proprietà, si può capire che un pattern è una formula o un insieme di condizioni che descrivono con precisione il movimento dei prezzi a intervalli selezionati. Un pattern può risultare casuale, soprattutto se trovato su un periodo troppo piccolo o se il sistema in questione produce valori troppo ottimistici. È molto importante capire che quando si testa un sistema su periodi brevi, le possibilità di trovare modelli globali tendono a zero. Ciò è legato alla dimensione del campione. Più piccolo è il campione, maggiore è la casualità dei risultati.
Abbiamo determinato cosa sia un pattern. Ma come utilizzare effettivamente i pattern? Tutto dipende da come è stato trovato questo pattern e dalla sua qualità. Se non prendiamo in considerazione i metodi di analisi che utilizzano la potenza di calcolo, arriviamo agli analitici. A mio avviso, gli analitici non possono competere con nessun tipo di analisi automatica - anche un buon team di analisti non può elaborare i dati che possono essere elaborati da una sola macchina. In ogni caso, il processo di ricerca di modelli globali richiede potenza di calcolo. A parte il caso in cui avete visto cose ovvie con i vostri occhi e ne avete compreso la fisica.
Scrivere il più Semplice Simulatore di Posizione
Per cercare di individuare modelli globali, sarebbe interessante sviluppare un Expert Advisor in grado di descrivere l'umore degli operatori di mercato. Per questo ho deciso di provare a creare un simulatore di posizioni di mercato. Le posizioni saranno simulate all'interno delle barre vicine al bordo del mercato. Sarà necessario ipotizzare che gli operatori del mercato siano diversi e che anche il peso dei loro ordini sia differente. Allo stesso tempo, questo dovrebbe essere presentato in forma semplice. Se un semplice prototipo dimostra di essere redditizio, i suoi principi possono essere utilizzati ulteriormente.
La logica sarà suddivisa condizionatamente in 3 simulazioni separate e in ogni possibile combinazione mixata di esse:
- Simulazione degli ordini Stop
- Simulazione degli ordini Limit
- Simulazione degli ordini di mercato
- Qualsiasi combinazione possibile
Per l'inoltro degli ordini viene utilizzata la seguente logica:
Queste griglie vengono posizionate ad ogni nuova barra, nel tentativo di simulare l'umore di una parte dei partecipanti al mercato. Lo stato delle griglie dei vecchi ordini viene aggiornato in base alla nuova barra visualizzata sul grafico. Questo approccio non è molto preciso, ma la simulazione tick-by-tick porterebbe a calcoli infiniti. Inoltre, non confido molto nei tick.
Esistono due tipi di distribuzione dei volumi relativi, con attenuazione e costanti, ma solo per gli ordini Stop e Limit. Gli ordini di mercato hanno una distribuzione uniforme. Sarà anche possibile ampliare i tipi di distribuzione, se questo sarà visto in prospettiva. Ecco l'illustrazione:
In questo caso, la lunghezza della linea che simboleggia l'ordine è proporzionale al volume dell'ordine stesso. Penso che tali illustrazioni siano semplici e comprensibili per tutti.
In questo caso, tutto può essere fatto utilizzando un approccio orientato agli oggetti. Iniziamo con la descrizione degli elenchi numerati:
enum CLOSE_MODE// how to close orders { CLOSE_FAST,// fast CLOSE_QUALITY// wait for an opposite signal }; enum WORK_MODE// operation mode { MODE_SIMPLE,// slow mode MODE_FAST// fast mode }; enum ENUM_GRID_WEIGHT//weight fill type for limit and stop orders { WEIGHT_DECREASE,// with attenuation if moving from the price WEIGHT_SAME// the same for the entire grid }; enum ENUM_STATUS_ORDER// statuses of orders or positions { STATUS_VIRTUAL,// stop or limit order STATUS_MARKET,// market order STATUS_ABORTED// canceled stop or limit order };
Il simulatore funzionerà in due modi, lento e veloce. La modalità lenta è necessaria principalmente per l'avvio dell'analisi. Nell'analisi iniziale, il calcolo viene eseguito nelle prime "n" candele più vicine al mercato. Nella modalità veloce, il calcolo viene eseguito solo sulla candela appena apparsa. Ma il semplice approccio si è rivelato insufficiente. È stata richiesta una funzionalità aggiuntiva per aumentare la velocità dell'algoritmo. All'inizializzazione dell'Expert Advisor vengono eseguiti numerosi calcoli. Ma in questo modo è sufficiente aggiornare la simulazione per una nuova candela ad ogni candela. Ci saranno due tipi di distribuzione del volume, per gli ordini limit e stop, a seconda della distanza dal prezzo di mercato corrente, che è Open[i] per ogni barra. Questo perché ad ogni barra viene aperta una griglia di ordini stop e limit, con distribuzioni e pesi diversi. Dopo un certo periodo di tempo, gli ordini stop e limit si trasformano in ordini di mercato. Se il prezzo non raggiunge il prezzo richiesto durante il tempo specificato, gli ordini stop e limit vengono cancellati.
Cominciamo a costruire questa simulazione da semplice a complessa, mettendo gradualmente tutto insieme. Innanzitutto, bisogna definire cosa sia un ordine:
struct Order// structure symbolizing a player's order { public: double WantedPrice;// desired open price int BarsExpirationOpen;// If the order remains for certain number of bars, the player can't wait any more and cancels the order int BarsExpirationClose;//If this is a market order and the player does not want to wait, he closes the position double UpPriceToClose;//The total upward price movement at which the player closes the order (points) double LowPriceToClose;//The total downward price movement at which the player closes the order double VolumeAlpha;// current volume equivalent [0...1] double VolumeStart;// starting volume equivalent [0...1] int IndexMarket;// the index of the bar on which the virtual market turned into market ENUM_STATUS_ORDER Status;// order status Order(ENUM_STATUS_ORDER S)// constructor that creates a certain order { Status=S; } };
I parametri non sono molti e ogni parametro è importante per l'algoritmo generale. Molti dei campi sono applicabili a qualsiasi ordine, mentre altri si applicano solo agli ordini Limit o Stop. Ad esempio, il prezzo desiderato è il prezzo di apertura per un ordine di mercato, mentre è esattamente il prezzo desiderato per gli ordini Limit e Stop.
I prezzi di chiusura superiore e inferiore fungono da livelli di stop. Allo stesso tempo, ipotizziamo che l'ordine a griglia non sia un vero e proprio ordine, e che questo ordine contenga un intero gruppo di ordini, che si fondono in un unico ordine, aperto con un certo volume a un certo prezzo. Le variabili del volume iniziale e del volume corrente ci dicono quanto siano importanti gli ordini a un livello specifico di una determinata barra.
Il volume iniziale è il volume al momento dell'ordine. Il volume attuale è il volume che si svilupperà con l'evolversi degli eventi. Ciò che conta è il rapporto tra i volumi degli ordini Buy e Sell piuttosto che i profitti derivanti da determinati ordini. I segnali di trading saranno generati sulla base di queste considerazioni. Naturalmente, potremmo trovare altri segnali, ma questo richiede altre considerazioni. Notate inoltre che gli ordini non verranno chiusi quando raggiungono determinati livelli, ma la chiusura avverrà gradualmente ad ogni barra, nel tentativo di simulare il più possibile lo sviluppo reale degli eventi.
Successivamente, è necessario definire la memorizzazione per ogni barra. La barra memorizza gli ordini che si aprono in questa barra:
class OrderBox// Order box of a specific bar { public: Order BuyStopOrders[]; Order BuyLimitOrders[]; Order BuyMarketOrders[]; Order SellStopOrders[]; Order SellLimitOrders[]; Order SellMarketOrders[]; OrderBox(int OrdersToOneBar) { ArrayResize(BuyStopOrders,OrdersToOneBar); ArrayResize(BuyLimitOrders,OrdersToOneBar); ArrayResize(BuyMarketOrders,OrdersToOneBar); ArrayResize(SellStopOrders,OrdersToOneBar); ArrayResize(SellLimitOrders,OrdersToOneBar); ArrayResize(SellMarketOrders,OrdersToOneBar); for ( int i=0; i<ArraySize(BuyStopOrders); i++ )// Set types for all orders { BuyStopOrders[i]=Order(STATUS_VIRTUAL); BuyLimitOrders[i]=Order(STATUS_VIRTUAL); BuyMarketOrders[i]=Order(STATUS_MARKET); SellStopOrders[i]=Order(STATUS_VIRTUAL); SellLimitOrders[i]=Order(STATUS_VIRTUAL); SellMarketOrders[i]=Order(STATUS_MARKET); } } };
Tutto è abbastanza semplice e chiaro. Sei tipi di ordini, descritti tramite array. Questo per evitare confusione. La classe non sarà utilizzata nella sua forma pura, sarà solo un mattone della costruzione.
Quindi, si definisce la memoria comune di tutte le barre come un unico oggetto, dal quale verrà poi eseguita l'ereditarietà. Le tecniche qui sono piuttosto semplici.
class BarBox// Storage for all orders { protected: OrderBox BarOrders[]; BarBox(int OrdersToOneBar,int BarsTotal) { ArrayResize(BarOrders,BarsTotal); for ( int i=0; i<ArraySize(BarOrders); i++ )// Set types for all orders { BarOrders[i]=OrderBox(OrdersToOneBar); } } };
Si tratta solo di una memoria con i dati delle barre (ordini) e nulla più. Per ora, tutto è abbastanza semplice. Più avanti, le cose si complicano.
Dopo aver determinato una comoda archiviazione dei dati per gli ordini, dobbiamo stabilire come e secondo quali regole vengono creati gli ordini, qual è l'importanza di determinati tipi di ordini, ecc. A tale scopo ho creato la seguente classe:
class PositionGenerator:public BarBox// Inherit class from the box to avoid the need to include it as an internal member and to avoid multiple references { protected: double VolumeAlphaStop;// importance of volumes of STOP orders double VolumeAlphaLimit;// importance of volumes of LIMIT orders double VolumeAlphaMarket;// importance of volumes of MARKET orders double HalfCorridorLimitStop;// step of the corridor of Limit and Stop orders in points int ExpirationOpenLimit;// after how many bars the volumes of the grid of limit orders for opening will completely attenuate int ExpirationOpenStop;// after how many bars the volumes of the grid of stop orders for opening will completely attenuate int ExpirationClose;// after how many bars the volumes of orders for closing will completely attenuate int ProfitPointsCorridorPart;// half corridor size for the profit of all orders int LossPointsCorridorPart;// half corridor size for the loss of all orders int OrdersToOneBar;// orders of one type per 1 bar ENUM_GRID_WEIGHT WeightStopLimitFillingType; PositionGenerator( ENUM_GRID_WEIGHT WeightStopLimitFillingType0 ,int HalfCorridorLimitStop0,int OrdersToOneBar0,int BarsTotal0 ,int ExpirationOpenLimit0,int ExpirationOpenStop0 ,int ExpirationClose0 ,int ProfitPointsCorridorPart0,int LossPointsCorridorPart0 ,double VolumeAlphaStop0,double VolumeAlphaLimit0,double VolumeAlphaMarket0) : BarBox(OrdersToOneBar0,BarsTotal0) { VolumeAlphaStop=VolumeAlphaStop0; VolumeAlphaLimit=VolumeAlphaLimit0; VolumeAlphaMarket=VolumeAlphaMarket0; OrdersToOneBar=OrdersToOneBar0; HalfCorridorLimitStop=double(HalfCorridorLimitStop0)/double(OrdersToOneBar); ExpirationOpenLimit=ExpirationOpenLimit0; ExpirationOpenStop=ExpirationOpenStop0; ExpirationClose=ExpirationClose0; ProfitPointsCorridorPart=ProfitPointsCorridorPart0; LossPointsCorridorPart=LossPointsCorridorPart0; OrdersToOneBar=OrdersToOneBar0; WeightStopLimitFillingType=WeightStopLimitFillingType0; } private: double CalcVolumeDecrease(double TypeWeight,int i,int size)// attenuation volume { if ( size > 1 ) { double K=1.0/(1.0-size); double C=1.0; return TypeWeight*K*i+C; } else return 0.0; } double CalcVolumeSimple(double TypeWeight)// equal volume { return TypeWeight; } void RebuildStops()// rebuild stop orders { int size=ArraySize(BarOrders[0].BuyStopOrders); for ( int j=ArraySize(BarOrders)-1; j>=0; j-- ) { for ( int i=0; i<size; i++ )// reset all { BarOrders[j].BuyStopOrders[i].Status=STATUS_VIRTUAL;// reset status to initial BarOrders[j].BuyStopOrders[i].WantedPrice=Open[j+1]+HalfCorridorLimitStop*(i+1)*Point;// prices of the order grid if ( WeightStopLimitFillingType == WEIGHT_DECREASE ) BarOrders[j].BuyStopOrders[i].VolumeAlpha=CalcVolumeDecrease(VolumeAlphaStop,i,size);// weight of each element of the grid if ( WeightStopLimitFillingType == WEIGHT_SAME ) BarOrders[j].BuyStopOrders[i].VolumeAlpha=CalcVolumeSimple(VolumeAlphaStop);// current weight of each element of the grid BarOrders[j].BuyStopOrders[i].VolumeStart=BarOrders[j].BuyStopOrders[i].VolumeAlpha;// starting weight of each element of the grid BarOrders[j].BuyStopOrders[i].UpPriceToClose=BarOrders[j].BuyStopOrders[i].WantedPrice+ProfitPointsCorridorPart*Point;// upper border to close BarOrders[j].BuyStopOrders[i].LowPriceToClose=BarOrders[j].BuyStopOrders[i].WantedPrice-LossPointsCorridorPart*Point;// lower border to close BarOrders[j].BuyStopOrders[i].BarsExpirationOpen=ExpirationOpenStop; BarOrders[j].BuyStopOrders[i].BarsExpirationClose=ExpirationClose; BarOrders[j].SellStopOrders[i].Status=STATUS_VIRTUAL; BarOrders[j].SellStopOrders[i].WantedPrice=Open[j+1]-HalfCorridorLimitStop*(i+1)*Point;// prices of the order grid if ( WeightStopLimitFillingType == WEIGHT_DECREASE ) BarOrders[j].SellStopOrders[i].VolumeAlpha=CalcVolumeDecrease(VolumeAlphaStop,i,size);// weight of each element of the grid if ( WeightStopLimitFillingType == WEIGHT_SAME ) BarOrders[j].SellStopOrders[i].VolumeAlpha=CalcVolumeSimple(VolumeAlphaStop);// current weight of each element of the grid BarOrders[j].SellStopOrders[i].VolumeStart=BarOrders[j].SellStopOrders[i].VolumeAlpha;// starting weight of each element of the grid BarOrders[j].SellStopOrders[i].UpPriceToClose=BarOrders[j].SellStopOrders[i].WantedPrice+LossPointsCorridorPart*Point;// upper border to close BarOrders[j].SellStopOrders[i].LowPriceToClose=BarOrders[j].SellStopOrders[i].WantedPrice-ProfitPointsCorridorPart*Point;// lower border to close BarOrders[j].SellStopOrders[i].BarsExpirationOpen=ExpirationOpenStop; BarOrders[j].SellStopOrders[i].BarsExpirationClose=ExpirationClose; } } } void RebuildLimits()// rebuild limit orders { int size=ArraySize(BarOrders[0].BuyLimitOrders); for ( int j=ArraySize(BarOrders)-1; j>=0; j-- ) { for ( int i=0; i<size; i++ )// reset all { BarOrders[j].BuyLimitOrders[i].Status=STATUS_VIRTUAL;// reset status to initial BarOrders[j].BuyLimitOrders[i].WantedPrice=Open[j+1]-HalfCorridorLimitStop*(i+1)*Point;// prices of the order grid if ( WeightStopLimitFillingType == WEIGHT_DECREASE ) BarOrders[j].BuyLimitOrders[i].VolumeAlpha=CalcVolumeDecrease(VolumeAlphaLimit,i,size);// weight of each element of the grid if ( WeightStopLimitFillingType == WEIGHT_SAME ) BarOrders[j].BuyLimitOrders[i].VolumeAlpha=CalcVolumeSimple(VolumeAlphaLimit);// current weight of each element of the grid BarOrders[j].BuyLimitOrders[i].VolumeStart=BarOrders[j].BuyLimitOrders[i].VolumeAlpha;// starting weight of each element of the grid BarOrders[j].BuyLimitOrders[i].UpPriceToClose=BarOrders[j].BuyLimitOrders[i].WantedPrice+ProfitPointsCorridorPart*Point;// upper border to close BarOrders[j].BuyLimitOrders[i].LowPriceToClose=BarOrders[j].BuyLimitOrders[i].WantedPrice-LossPointsCorridorPart*Point;// lower border to close BarOrders[j].BuyLimitOrders[i].BarsExpirationOpen=ExpirationOpenLimit; BarOrders[j].BuyLimitOrders[i].BarsExpirationClose=ExpirationClose; BarOrders[j].SellLimitOrders[i].Status=STATUS_VIRTUAL; BarOrders[j].SellLimitOrders[i].WantedPrice=Open[j+1]+HalfCorridorLimitStop*(i+1)*Point;// prices of the order grid if ( WeightStopLimitFillingType == WEIGHT_DECREASE ) BarOrders[j].SellLimitOrders[i].VolumeAlpha=CalcVolumeDecrease(VolumeAlphaLimit,i,size);// weight of each element of the grid if ( WeightStopLimitFillingType == WEIGHT_SAME ) BarOrders[j].SellLimitOrders[i].VolumeAlpha=CalcVolumeSimple(VolumeAlphaLimit);// current weight of each element of the grid BarOrders[j].SellLimitOrders[i].VolumeStart=BarOrders[j].SellLimitOrders[i].VolumeAlpha;// starting weight of each element of the grid BarOrders[j].SellLimitOrders[i].UpPriceToClose=BarOrders[j].SellLimitOrders[i].WantedPrice+LossPointsCorridorPart*Point;// upper border to close BarOrders[j].SellLimitOrders[i].LowPriceToClose=BarOrders[j].SellLimitOrders[i].WantedPrice-ProfitPointsCorridorPart*Point;// lower border to close BarOrders[j].SellLimitOrders[i].BarsExpirationOpen=ExpirationOpenLimit; BarOrders[j].SellLimitOrders[i].BarsExpirationClose=ExpirationClose; } } } void RebuildMarkets()// rebuild market orders { int size=ArraySize(BarOrders[0].BuyMarketOrders); double MarketStep; for ( int j=ArraySize(BarOrders)-1; j>0; j-- ) { MarketStep=(High[j+1]-Low[j+1])/double(OrdersToOneBar); for ( int i=0; i<size; i++ )// reset all { BarOrders[j].BuyMarketOrders[i].Status=STATUS_MARKET;// reset status to initial BarOrders[j].BuyMarketOrders[i].WantedPrice=Low[j+1]+MarketStep*i;// prices of the order grid BarOrders[j].BuyMarketOrders[i].VolumeAlpha=CalcVolumeSimple(VolumeAlphaMarket);// current weight of each element of the grid BarOrders[j].BuyMarketOrders[i].VolumeStart=BarOrders[j].BuyMarketOrders[i].VolumeAlpha;// starting weight of each element of the grid BarOrders[j].BuyMarketOrders[i].UpPriceToClose=BarOrders[j].BuyMarketOrders[i].WantedPrice+ProfitPointsCorridorPart*Point;// upper border to close BarOrders[j].BuyMarketOrders[i].LowPriceToClose=BarOrders[j].BuyMarketOrders[i].WantedPrice-LossPointsCorridorPart*Point;// lower border to close BarOrders[j].BuyMarketOrders[i].BarsExpirationClose=ExpirationClose; BarOrders[j].SellMarketOrders[i].Status=STATUS_MARKET; BarOrders[j].SellMarketOrders[i].WantedPrice=High[j+1]-MarketStep*i;// prices of the order grid BarOrders[j].SellMarketOrders[i].VolumeAlpha=CalcVolumeSimple(VolumeAlphaMarket);// current weight of each element of the grid BarOrders[j].SellMarketOrders[i].VolumeStart=BarOrders[j].SellMarketOrders[i].VolumeAlpha;// starting weight of each element of the grid BarOrders[j].SellMarketOrders[i].UpPriceToClose=BarOrders[j].SellMarketOrders[i].WantedPrice+LossPointsCorridorPart*Point;// upper border to close BarOrders[j].SellMarketOrders[i].LowPriceToClose=BarOrders[j].SellMarketOrders[i].WantedPrice-ProfitPointsCorridorPart*Point;// lower border to close BarOrders[j].SellMarketOrders[i].BarsExpirationClose=ExpirationClose; } } } ///// Fast methods void RebuildStopsFast()// rebuild stop orders { int size=ArraySize(BarOrders[0].BuyStopOrders); for ( int j=ArraySize(BarOrders)-1; j>0; j-- ) { for ( int i=0; i<size; i++ )// shift orders { BarOrders[j].BuyStopOrders[i]=BarOrders[j-1].BuyStopOrders[i]; BarOrders[j].SellStopOrders[i]=BarOrders[j-1].SellStopOrders[i]; BarOrders[j].SellStopOrders[i].IndexMarket++; } } for ( int i=0; i<size; i++ )// create a new grid at a new bar { BarOrders[0].BuyStopOrders[i].Status=STATUS_VIRTUAL;// reset status to initial BarOrders[0].BuyStopOrders[i].WantedPrice=Close[1]+HalfCorridorLimitStop*(i+1)*Point;// prices of the order grid if ( WeightStopLimitFillingType == WEIGHT_DECREASE ) BarOrders[0].BuyStopOrders[i].VolumeAlpha=CalcVolumeDecrease(VolumeAlphaStop,i,size);// weight of each element of the grid if ( WeightStopLimitFillingType == WEIGHT_SAME ) BarOrders[0].BuyStopOrders[i].VolumeAlpha=CalcVolumeSimple(VolumeAlphaStop);// current weight of each element of the grid BarOrders[0].BuyStopOrders[i].VolumeStart=BarOrders[0].BuyStopOrders[i].VolumeAlpha;// starting weight of each element of the grid BarOrders[0].BuyStopOrders[i].UpPriceToClose=BarOrders[0].BuyStopOrders[i].WantedPrice+ProfitPointsCorridorPart*Point;//upper border to close BarOrders[0].BuyStopOrders[i].LowPriceToClose=BarOrders[0].BuyStopOrders[i].WantedPrice-LossPointsCorridorPart*Point;// lower border to close BarOrders[0].BuyStopOrders[i].BarsExpirationOpen=ExpirationOpenStop; BarOrders[0].BuyStopOrders[i].BarsExpirationClose=ExpirationClose; BarOrders[0].SellStopOrders[i].Status=STATUS_VIRTUAL; BarOrders[0].SellStopOrders[i].WantedPrice=Close[1]-HalfCorridorLimitStop*(i+1)*Point;// prices of the order grid if ( WeightStopLimitFillingType == WEIGHT_DECREASE ) BarOrders[0].SellStopOrders[i].VolumeAlpha=CalcVolumeDecrease(VolumeAlphaStop,i,size);// weight of each element of the grid if ( WeightStopLimitFillingType == WEIGHT_SAME ) BarOrders[0].SellStopOrders[i].VolumeAlpha=CalcVolumeSimple(VolumeAlphaStop);// current weight of each element of the grid BarOrders[0].SellStopOrders[i].VolumeStart=BarOrders[0].SellStopOrders[i].VolumeAlpha;// starting weight of each element of the grid BarOrders[0].SellStopOrders[i].UpPriceToClose=BarOrders[0].SellStopOrders[i].WantedPrice+LossPointsCorridorPart*Point;// upper border to close BarOrders[0].SellStopOrders[i].LowPriceToClose=BarOrders[0].SellStopOrders[i].WantedPrice-ProfitPointsCorridorPart*Point;// lower border to close BarOrders[0].SellStopOrders[i].BarsExpirationOpen=ExpirationOpenStop; BarOrders[0].SellStopOrders[i].BarsExpirationClose=ExpirationClose; } } void RebuildLimitsFast()// rebuild limit orders { int size=ArraySize(BarOrders[0].BuyLimitOrders); for ( int j=ArraySize(BarOrders)-1; j>0; j-- ) { for ( int i=0; i<size; i++ )// shift orders { BarOrders[j].BuyLimitOrders[i]=BarOrders[j-1].BuyLimitOrders[i]; BarOrders[j].SellLimitOrders[i]=BarOrders[j-1].SellLimitOrders[i]; BarOrders[j].SellLimitOrders[i].IndexMarket++; } } for ( int i=0; i<size; i++ )// create a new grid at a new bar { BarOrders[0].BuyLimitOrders[i].Status=STATUS_VIRTUAL;// reset status to initial BarOrders[0].BuyLimitOrders[i].WantedPrice=Open[1]-HalfCorridorLimitStop*(i+1)*Point;// prices of the order grid if ( WeightStopLimitFillingType == WEIGHT_DECREASE ) BarOrders[0].BuyLimitOrders[i].VolumeAlpha=CalcVolumeDecrease(VolumeAlphaLimit,i,size);// weight of each element of the grid if ( WeightStopLimitFillingType == WEIGHT_SAME ) BarOrders[0].BuyLimitOrders[i].VolumeAlpha=CalcVolumeSimple(VolumeAlphaLimit);// current weight of each element of the grid BarOrders[0].BuyLimitOrders[i].VolumeStart=BarOrders[0].BuyLimitOrders[i].VolumeAlpha;// starting weight of each element of the grid BarOrders[0].BuyLimitOrders[i].UpPriceToClose=BarOrders[0].BuyLimitOrders[i].WantedPrice+ProfitPointsCorridorPart*Point;// upper border to close BarOrders[0].BuyLimitOrders[i].LowPriceToClose=BarOrders[0].BuyLimitOrders[i].WantedPrice-LossPointsCorridorPart*Point;// lower border to close BarOrders[0].BuyLimitOrders[i].BarsExpirationOpen=ExpirationOpenLimit; BarOrders[0].BuyLimitOrders[i].BarsExpirationClose=ExpirationClose; BarOrders[0].SellLimitOrders[i].Status=STATUS_VIRTUAL; BarOrders[0].SellLimitOrders[i].WantedPrice=Open[1]+HalfCorridorLimitStop*(i+1)*Point;// prices of the order grid if ( WeightStopLimitFillingType == WEIGHT_DECREASE ) BarOrders[0].SellLimitOrders[i].VolumeAlpha=CalcVolumeDecrease(VolumeAlphaLimit,i,size);// weight of each element of the grid if ( WeightStopLimitFillingType == WEIGHT_SAME ) BarOrders[0].SellLimitOrders[i].VolumeAlpha=CalcVolumeSimple(VolumeAlphaLimit);// current weight of each element of the grid BarOrders[0].SellLimitOrders[i].VolumeStart=BarOrders[0].SellLimitOrders[i].VolumeAlpha;// starting weight of each element of the grid BarOrders[0].SellLimitOrders[i].UpPriceToClose=BarOrders[0].SellLimitOrders[i].WantedPrice+LossPointsCorridorPart*Point;// upper border to close BarOrders[0].SellLimitOrders[i].LowPriceToClose=BarOrders[0].SellLimitOrders[i].WantedPrice-ProfitPointsCorridorPart*Point;// lower order to close BarOrders[0].SellLimitOrders[i].BarsExpirationOpen=ExpirationOpenLimit; BarOrders[0].SellLimitOrders[i].BarsExpirationClose=ExpirationClose; } } void RebuildMarketsFast()// rebuild market orders { int size=ArraySize(BarOrders[0].BuyMarketOrders); double MarketStep; for ( int j=ArraySize(BarOrders)-1; j>0; j-- ) { for ( int i=0; i<size; i++ )// shift orders { BarOrders[j].BuyMarketOrders[i]=BarOrders[j-1].BuyMarketOrders[i]; BarOrders[j].SellMarketOrders[i]=BarOrders[j-1].SellMarketOrders[i]; } } MarketStep=(High[1]-Low[1])/double(OrdersToOneBar); for ( int i=0; i<size; i++ )// create a new grid at a new bar { BarOrders[0].BuyMarketOrders[i].Status=STATUS_MARKET;// reset status to initial BarOrders[0].BuyMarketOrders[i].WantedPrice=Low[1]+MarketStep*i;// prices of the order grid BarOrders[0].BuyMarketOrders[i].VolumeAlpha=CalcVolumeSimple(VolumeAlphaMarket);// current weight of each element of the grid BarOrders[0].BuyMarketOrders[i].VolumeStart=BarOrders[0].BuyMarketOrders[i].VolumeAlpha;// starting weight of each element of the grid BarOrders[0].BuyMarketOrders[i].UpPriceToClose=BarOrders[0].BuyMarketOrders[i].WantedPrice+ProfitPointsCorridorPart*Point;// upper border to close BarOrders[0].BuyMarketOrders[i].LowPriceToClose=BarOrders[0].BuyMarketOrders[i].WantedPrice-LossPointsCorridorPart*Point;// lower border to close BarOrders[0].BuyMarketOrders[i].BarsExpirationClose=ExpirationClose; BarOrders[0].SellMarketOrders[i].Status=STATUS_MARKET; BarOrders[0].SellMarketOrders[i].WantedPrice=High[1]-MarketStep*i;// prices of the order grid BarOrders[0].SellMarketOrders[i].VolumeAlpha=CalcVolumeSimple(VolumeAlphaMarket);// current weight of each element of the grid BarOrders[0].SellMarketOrders[i].VolumeStart=BarOrders[0].SellMarketOrders[i].VolumeAlpha;// starting weight of each element of the grid BarOrders[0].SellMarketOrders[i].UpPriceToClose=BarOrders[0].SellMarketOrders[i].WantedPrice+LossPointsCorridorPart*Point;// upper border to close BarOrders[0].SellMarketOrders[i].LowPriceToClose=BarOrders[0].SellMarketOrders[i].WantedPrice-ProfitPointsCorridorPart*Point;// lower border to close BarOrders[0].SellMarketOrders[i].BarsExpirationClose=ExpirationClose; } } protected: void CreateNewOrders()// create new orders at each candlestick { if ( VolumeAlphaStop != 0.0 ) RebuildStops(); if ( VolumeAlphaLimit != 0.0 ) RebuildLimits(); if ( VolumeAlphaMarket != 0.0 ) RebuildMarkets(); } void CreateNewOrdersFast()// { if ( VolumeAlphaStop != 0.0 ) RebuildStopsFast(); if ( VolumeAlphaLimit != 0.0 ) RebuildLimitsFast(); if ( VolumeAlphaMarket != 0.0 ) RebuildMarketsFast(); } public: virtual void Update()// state updating function (will be expanded in child classes) { CreateNewOrders(); } virtual void UpdateFast()// fast state update { CreateNewOrdersFast(); } };
In realtà, questa classe crea solo un'implementazione dei metodi Update() e UpdateFast(), che sono simili, con l'unica differenza che il secondo è molto più veloce. Questi metodi creano nuovi ordini ad ogni barra e cancellano quelli vecchi, preparando così i dati per la classe successiva che simulerà il ciclo di vita degli ordini. In questa classe vengono assegnati tutti i parametri richiesti per gli ordini, tra cui il tipo, i prezzi di apertura, i volumi e altri parametri importanti necessari per le operazioni successive.
La classe successiva implementa il processo di simulazione degli ordini e i calcoli dei parametri necessari per il trading, sulla base dei quali vengono generati i segnali:
class Simulation:public PositionGenerator // then assemble a simulator of positions (inherited from the position generator) {// market parameter calculations will also performed in this class protected: double BuyPercent;// percent of open Buy positions double SellPercent;// percent of open Sell positions double StartVolume;// starting total volume of open Buy positions (the same for Buys and Sells) double RelativeVolume;// relative volume double SummVolumeBuy;// total volume for Buys double SummVolumeSell;// total volume for Sells public: Simulation( ENUM_GRID_WEIGHT WeightStopLimitFillingType0 ,int HalfCorridorLimitStop0,int OrdersToOneBar0,int BarsTotal0 ,int ExpirationOpenLimit0,int ExpirationOpenStop0 ,int ExpirationClose0 ,int ProfitPointsCorridorPart0,int LossPointsCorridorPart0 ,double VolumeAlphaStop0,double VolumeAlphaLimit0,double VolumeAlphaMarket0) :PositionGenerator(WeightStopLimitFillingType0 ,HalfCorridorLimitStop0,OrdersToOneBar0,BarsTotal0 ,ExpirationOpenLimit0,ExpirationOpenStop0 ,ExpirationClose0 ,ProfitPointsCorridorPart0,LossPointsCorridorPart0 ,VolumeAlphaStop0,VolumeAlphaLimit0,VolumeAlphaMarket0) { CreateNewOrders(); CalculateStartVolume();// calculate starting volumes UpdateVirtual();// first update virtual orders to process part of them as market orders in the next function UpdateMarket();// now update the state of all market orders CalculateCurrentVolume();// calculate current volumes of all open orders CalculatePercent();// calculate the percentage of positions CalculateRelativeVolume();// calculate relative volume } double GetBuyPercent()// get the percentage of open Buy deals { return BuyPercent; } double GetSellPercent()// get the percentage of open Sell deals { return SellPercent; } double GetRelativeVolume()// get relative volume { return RelativeVolume; } virtual void Update() override { PositionGenerator::Update();// call everything that was before UpdateVirtual();// first update virtual orders to process part of them as market orders in the next function UpdateMarket();// now update the state of all market orders CalculateCurrentVolume();// calculate current volumes of all open orders CalculatePercent();// calculate the percentage of positions CalculateRelativeVolume();// calculate relative volume } virtual void UpdateFast() override { PositionGenerator::UpdateFast();// call everything that was before UpdateVirtualFast();// first update virtual orders to process part of them as market orders in the next function UpdateMarketFast();// now update the state of all market orders CalculateCurrentVolume();// calculate current volumes of all open orders CalculatePercent();// calculate the percentage of positions CalculateRelativeVolume();// calculate relative volume } private: void UpdateVirtual()// update the status of virtual orders { int size=ArraySize(BarOrders[0].BuyLimitOrders); int SizeBarOrders=ArraySize(BarOrders); if ( VolumeAlphaLimit != 0.0 ) { for ( int i=SizeBarOrders; i>0; i-- )// update the state of limit orders simulating each candlestick { for ( int j=SizeBarOrders-1; j>i; j-- )// update the state of all candlesticks preceding this one { for ( int k=0; k<size; k++ )// update the state inside each preceding candlestick { if ( BarOrders[j].BuyLimitOrders[k].Status == STATUS_VIRTUAL && BarOrders[j].BuyLimitOrders[k].WantedPrice <= High[i] && BarOrders[j].BuyLimitOrders[k].WantedPrice >= Low[i] )// if the order is virtual and is inside a candlestick, then it turns into a market one { BarOrders[j].BuyLimitOrders[k].Status = STATUS_MARKET; BarOrders[j].BuyLimitOrders[k].IndexMarket = i; } if ( BarOrders[j].SellLimitOrders[k].Status == STATUS_VIRTUAL && BarOrders[j].SellLimitOrders[k].WantedPrice <= High[i] && BarOrders[j].SellLimitOrders[k].WantedPrice >= Low[i] )// the same { BarOrders[j].SellLimitOrders[k].Status = STATUS_MARKET; BarOrders[j].SellLimitOrders[k].IndexMarket = i; } /////// Check for interest expiration of limit players if ( BarOrders[j].BuyLimitOrders[k].Status == STATUS_VIRTUAL )// { if ( BarOrders[j].BuyLimitOrders[k].IndexMarket - 1 >= BarOrders[j].BuyLimitOrders[k].BarsExpirationOpen ) BarOrders[j].BuyLimitOrders[k].Status=STATUS_ABORTED; else { if ( BarOrders[j].BuyLimitOrders[k].VolumeAlpha > 0.0 ) BarOrders[j].BuyLimitOrders[k].VolumeAlpha-=BarOrders[j].BuyLimitOrders[k].VolumeStart/double(BarOrders[j].BuyLimitOrders[k].BarsExpirationOpen); if ( BarOrders[j].BuyLimitOrders[k].VolumeAlpha < 0.0 ) BarOrders[j].BuyLimitOrders[k].VolumeAlpha=0.0; } } if ( BarOrders[j].SellLimitOrders[k].Status == STATUS_VIRTUAL )// { if ( BarOrders[j].SellLimitOrders[k].IndexMarket - 1 >= BarOrders[j].SellLimitOrders[k].BarsExpirationOpen ) BarOrders[j].SellLimitOrders[k].Status=STATUS_ABORTED; else { if ( BarOrders[j].SellLimitOrders[k].VolumeAlpha > 0.0 ) BarOrders[j].SellLimitOrders[k].VolumeAlpha-=BarOrders[j].SellLimitOrders[k].VolumeStart/double(BarOrders[j].SellLimitOrders[k].BarsExpirationOpen); if ( BarOrders[j].SellLimitOrders[k].VolumeAlpha < 0.0 ) BarOrders[j].SellLimitOrders[k].VolumeAlpha=0.0; } } } } } } if ( VolumeAlphaStop != 0.0 ) { for ( int i=SizeBarOrders; i>0; i-- )// update the state of limit orders simulating each candlestick { for ( int j=SizeBarOrders-1; j>i; j-- )// update the state of all candlesticks preceding this one { for ( int k=0; k<size; k++ )// update the state inside each preceding candlestick { if ( BarOrders[j].SellStopOrders[k].Status == STATUS_VIRTUAL && BarOrders[j].SellStopOrders[k].WantedPrice <= High[i] && BarOrders[j].SellStopOrders[k].WantedPrice >= Low[i] )// the same { BarOrders[j].SellStopOrders[k].Status = STATUS_MARKET; BarOrders[j].SellStopOrders[k].IndexMarket = i; } if ( BarOrders[j].BuyStopOrders[k].Status == STATUS_VIRTUAL && BarOrders[j].BuyStopOrders[k].WantedPrice <= High[i] && BarOrders[j].BuyStopOrders[k].WantedPrice >= Low[i] )// the same { BarOrders[j].BuyStopOrders[k].Status = STATUS_MARKET; BarOrders[j].BuyStopOrders[k].IndexMarket = i; } /////// Check for interest expiration of stop and limit players if ( BarOrders[j].BuyStopOrders[k].Status == STATUS_VIRTUAL )// { if ( BarOrders[j].BuyStopOrders[k].IndexMarket - 1 >= BarOrders[j].BuyStopOrders[k].BarsExpirationOpen ) BarOrders[j].BuyStopOrders[k].Status=STATUS_ABORTED; else { if ( BarOrders[j].BuyStopOrders[k].VolumeAlpha > 0.0 ) BarOrders[j].BuyStopOrders[k].VolumeAlpha-=BarOrders[j].BuyStopOrders[k].VolumeStart/double(BarOrders[j].BuyStopOrders[k].BarsExpirationOpen); if ( BarOrders[j].BuyStopOrders[k].VolumeAlpha < 0.0 ) BarOrders[j].BuyStopOrders[k].VolumeAlpha=0.0; } } if ( BarOrders[j].SellStopOrders[k].Status == STATUS_VIRTUAL )// { if ( BarOrders[j].SellStopOrders[k].IndexMarket - 1 >= BarOrders[j].SellStopOrders[k].BarsExpirationOpen ) BarOrders[j].SellStopOrders[k].Status=STATUS_ABORTED; else { if ( BarOrders[j].SellStopOrders[k].VolumeAlpha > 0.0 ) BarOrders[j].SellStopOrders[k].VolumeAlpha-=BarOrders[j].SellStopOrders[k].VolumeStart/double(BarOrders[j].SellStopOrders[k].BarsExpirationOpen); if ( BarOrders[j].SellStopOrders[k].VolumeAlpha < 0.0 ) BarOrders[j].SellStopOrders[k].VolumeAlpha=0.0; } } } } } } } void UpdateMarket()// update the status of market orders { int size=ArraySize(BarOrders[0].BuyLimitOrders); int SizeBarOrders=ArraySize(BarOrders); if ( VolumeAlphaLimit != 0.0 ) { for ( int i=SizeBarOrders; i>1; i-- )// update the state of orders simulating each candlestick { for ( int j=SizeBarOrders-1; j>i; j-- )// update the state of all candlesticks preceding this one { for ( int k=0; k<size; k++ )// update the state inside each preceding candlestick { // Block for closing when prices change if ( BarOrders[j].BuyLimitOrders[k].Status == STATUS_MARKET )// { if ( BarOrders[j].BuyLimitOrders[k].VolumeAlpha > 0.0 ) { BarOrders[j].BuyLimitOrders[k].VolumeAlpha-=BarOrders[j].BuyLimitOrders[k].VolumeStart*(High[i]-Open[i])/(BarOrders[j].BuyLimitOrders[k].UpPriceToClose-BarOrders[j].BuyLimitOrders[k].WantedPrice);// with profit BarOrders[j].BuyLimitOrders[k].VolumeAlpha-=BarOrders[j].BuyLimitOrders[k].VolumeStart*(Open[i]-Low[i])/(BarOrders[j].BuyLimitOrders[k].WantedPrice-BarOrders[j].BuyLimitOrders[k].LowPriceToClose);// with loss } if ( BarOrders[j].BuyLimitOrders[k].VolumeAlpha < 0.0 ) BarOrders[j].BuyLimitOrders[k].VolumeAlpha=0.0; } if ( BarOrders[j].SellLimitOrders[k].Status == STATUS_MARKET )// { if ( BarOrders[j].SellLimitOrders[k].VolumeAlpha > 0.0 ) { BarOrders[j].SellLimitOrders[k].VolumeAlpha-=BarOrders[j].SellLimitOrders[k].VolumeStart*(Open[i]-Low[i])/(BarOrders[j].SellLimitOrders[k].WantedPrice-BarOrders[j].SellLimitOrders[k].LowPriceToClose);//with profit BarOrders[j].SellLimitOrders[k].VolumeAlpha-=BarOrders[j].SellLimitOrders[k].VolumeStart*(High[i]-Open[i])/(BarOrders[j].SellLimitOrders[k].UpPriceToClose-BarOrders[j].SellLimitOrders[k].WantedPrice);//with loss } if ( BarOrders[j].SellLimitOrders[k].VolumeAlpha < 0.0 ) BarOrders[j].SellLimitOrders[k].VolumeAlpha=0.0; } // End of lock for closing when prices change // Block for closing when time changes****************************************************** if ( BarOrders[j].BuyLimitOrders[k].Status == STATUS_MARKET )// { if ( BarOrders[j].BuyLimitOrders[k].VolumeAlpha > 0.0 ) BarOrders[j].BuyLimitOrders[k].VolumeAlpha-=BarOrders[j].BuyLimitOrders[k].VolumeStart/double(BarOrders[j].BuyLimitOrders[k].BarsExpirationClose); if ( BarOrders[j].BuyLimitOrders[k].VolumeAlpha < 0.0 ) BarOrders[j].BuyLimitOrders[k].VolumeAlpha=0.0; } if ( BarOrders[j].SellLimitOrders[k].Status == STATUS_MARKET )// { if ( BarOrders[j].SellLimitOrders[k].VolumeAlpha > 0.0 ) BarOrders[j].SellLimitOrders[k].VolumeAlpha-=BarOrders[j].SellLimitOrders[k].VolumeStart/double(BarOrders[j].SellLimitOrders[k].BarsExpirationClose); if ( BarOrders[j].SellLimitOrders[k].VolumeAlpha < 0.0 ) BarOrders[j].SellLimitOrders[k].VolumeAlpha=0.0; } } } } } if ( VolumeAlphaStop != 0.0 ) { for ( int i=SizeBarOrders; i>1; i-- )// update the state of orders simulating each candlestick { for ( int j=SizeBarOrders-1; j>i; j-- )// update the state of all candlesticks preceding this one { for ( int k=0; k<size; k++ )// update the state inside each preceding candlestick { // Block for closing when prices change if ( BarOrders[j].BuyStopOrders[k].Status == STATUS_MARKET )// { if ( BarOrders[j].BuyStopOrders[k].VolumeAlpha > 0.0 ) { BarOrders[j].BuyStopOrders[k].VolumeAlpha-=BarOrders[j].BuyStopOrders[k].VolumeStart*(High[i]-Open[i])/(BarOrders[j].BuyStopOrders[k].UpPriceToClose-BarOrders[j].BuyStopOrders[k].WantedPrice);// with profit BarOrders[j].BuyStopOrders[k].VolumeAlpha-=BarOrders[j].BuyStopOrders[k].VolumeStart*(Open[i]-Low[i])/(BarOrders[j].BuyStopOrders[k].WantedPrice-BarOrders[j].BuyStopOrders[k].LowPriceToClose);// with loss } if ( BarOrders[j].BuyStopOrders[k].VolumeAlpha < 0.0 ) BarOrders[j].BuyStopOrders[k].VolumeAlpha=0.0; } if ( BarOrders[j].SellStopOrders[k].Status == STATUS_MARKET )// { if ( BarOrders[j].SellStopOrders[k].VolumeAlpha > 0.0 ) { BarOrders[j].SellStopOrders[k].VolumeAlpha-=BarOrders[j].SellStopOrders[k].VolumeStart*(Open[i]-Low[i])/(BarOrders[j].SellStopOrders[k].WantedPrice-BarOrders[j].SellStopOrders[k].LowPriceToClose);//with profit BarOrders[j].SellStopOrders[k].VolumeAlpha-=BarOrders[j].SellStopOrders[k].VolumeStart*(High[i]-Open[i])/(BarOrders[j].SellStopOrders[k].UpPriceToClose-BarOrders[j].SellStopOrders[k].WantedPrice);//with loss } if ( BarOrders[j].SellStopOrders[k].VolumeAlpha < 0.0 ) BarOrders[j].SellStopOrders[k].VolumeAlpha=0.0; } // End of lock for closing when prices change // Block for closing when time changes****************************************************** if ( BarOrders[j].BuyStopOrders[k].Status == STATUS_MARKET )// { if ( BarOrders[j].BuyStopOrders[k].VolumeAlpha > 0.0 ) BarOrders[j].BuyStopOrders[k].VolumeAlpha-=BarOrders[j].BuyStopOrders[k].VolumeStart/double(BarOrders[j].BuyStopOrders[k].BarsExpirationClose); if ( BarOrders[j].BuyStopOrders[k].VolumeAlpha < 0.0 ) BarOrders[j].BuyStopOrders[k].VolumeAlpha=0.0; } if ( BarOrders[j].SellStopOrders[k].Status == STATUS_MARKET )// { if ( BarOrders[j].SellStopOrders[k].VolumeAlpha > 0.0 ) BarOrders[j].SellStopOrders[k].VolumeAlpha-=BarOrders[j].SellStopOrders[k].VolumeStart/double(BarOrders[j].SellStopOrders[k].BarsExpirationClose); if ( BarOrders[j].SellStopOrders[k].VolumeAlpha < 0.0 ) BarOrders[j].SellStopOrders[k].VolumeAlpha=0.0; } } } } } if ( VolumeAlphaMarket != 0.0 ) { for ( int i=SizeBarOrders; i>1; i-- )// update the state of orders simulating each candlestick { for ( int j=SizeBarOrders-1; j>i; j-- )// update the state of all candlesticks preceding this one { for ( int k=0; k<size; k++ )// update the state inside each preceding candlestick { // Block for closing when prices change /// For obviously market positions if ( BarOrders[j].BuyMarketOrders[k].VolumeAlpha > 0.0 ) { BarOrders[j].BuyMarketOrders[k].VolumeAlpha-=BarOrders[j].BuyMarketOrders[k].VolumeStart*(High[i]-Open[i])/(BarOrders[j].BuyMarketOrders[k].UpPriceToClose-BarOrders[j].BuyMarketOrders[k].WantedPrice);// with profit BarOrders[j].BuyMarketOrders[k].VolumeAlpha-=BarOrders[j].BuyMarketOrders[k].VolumeStart*(Open[i]-Low[i])/(BarOrders[j].BuyMarketOrders[k].WantedPrice-BarOrders[j].BuyMarketOrders[k].LowPriceToClose);// with loss } if ( BarOrders[j].BuyMarketOrders[k].VolumeAlpha < 0.0 ) BarOrders[j].BuyMarketOrders[k].VolumeAlpha=0.0; if ( BarOrders[j].SellMarketOrders[k].VolumeAlpha > 0.0 ) { BarOrders[j].SellMarketOrders[k].VolumeAlpha-=BarOrders[j].SellMarketOrders[k].VolumeStart*(Open[i]-Low[i])/(BarOrders[j].SellMarketOrders[k].WantedPrice-BarOrders[j].SellMarketOrders[k].LowPriceToClose);// with profit BarOrders[j].SellMarketOrders[k].VolumeAlpha-=BarOrders[j].SellMarketOrders[k].VolumeStart*(High[i]-Open[i])/(BarOrders[j].SellMarketOrders[k].UpPriceToClose-BarOrders[j].SellMarketOrders[k].WantedPrice);// with loss } if ( BarOrders[j].SellMarketOrders[k].VolumeAlpha < 0.0 ) BarOrders[j].SellMarketOrders[k].VolumeAlpha=0.0; // End of lock for closing when prices change // Block for closing when time changes****************************************************** /// For obviously market positions if ( BarOrders[j].BuyMarketOrders[k].VolumeAlpha > 0.0 ) BarOrders[j].BuyMarketOrders[k].VolumeAlpha-=BarOrders[j].BuyMarketOrders[k].VolumeStart/double(BarOrders[j].BuyMarketOrders[k].BarsExpirationClose); if ( BarOrders[j].BuyMarketOrders[k].VolumeAlpha < 0.0 ) BarOrders[j].BuyMarketOrders[k].VolumeAlpha=0.0; if ( BarOrders[j].SellMarketOrders[k].VolumeAlpha > 0.0 ) BarOrders[j].SellMarketOrders[k].VolumeAlpha-=BarOrders[j].SellMarketOrders[k].VolumeStart/double(BarOrders[j].SellMarketOrders[k].BarsExpirationClose); if ( BarOrders[j].SellMarketOrders[k].VolumeAlpha < 0.0 ) BarOrders[j].SellMarketOrders[k].VolumeAlpha=0.0; // } } } } } /// fast methods**** void UpdateVirtualFast()// update the status of virtual orders { int SizeBarOrders=ArraySize(BarOrders); int size=ArraySize(BarOrders[0].BuyLimitOrders); if ( VolumeAlphaLimit != 0.0 ) { for ( int j=SizeBarOrders-1; j>0; j-- )// update the state of all candlesticks preceding this one { for ( int k=0; k<size; k++ )// update the state inside each preceding candlestick { if ( BarOrders[j].BuyLimitOrders[k].Status == STATUS_VIRTUAL && BarOrders[j].BuyLimitOrders[k].WantedPrice <= High[1] && BarOrders[j].BuyLimitOrders[k].WantedPrice >= Low[1] )// if the order is virtual and is inside a candlestick, then it turns into a market one { BarOrders[j].BuyLimitOrders[k].Status = STATUS_MARKET; BarOrders[j].BuyLimitOrders[k].IndexMarket = 1; } if ( BarOrders[j].SellLimitOrders[k].Status == STATUS_VIRTUAL && BarOrders[j].SellLimitOrders[k].WantedPrice <= High[1] && BarOrders[j].SellLimitOrders[k].WantedPrice >= Low[1] )// the same { BarOrders[j].SellLimitOrders[k].Status = STATUS_MARKET; BarOrders[j].SellLimitOrders[k].IndexMarket = 1; } /////// Check for interest expiration of limit players if ( BarOrders[j].BuyLimitOrders[k].Status == STATUS_VIRTUAL )// { if ( BarOrders[j].BuyLimitOrders[k].IndexMarket - 1 >= BarOrders[j].BuyLimitOrders[k].BarsExpirationOpen ) BarOrders[j].BuyLimitOrders[k].Status=STATUS_ABORTED; else { if ( BarOrders[j].BuyLimitOrders[k].VolumeAlpha > 0.0 ) BarOrders[j].BuyLimitOrders[k].VolumeAlpha-=BarOrders[j].BuyLimitOrders[k].VolumeStart/double(BarOrders[j].BuyLimitOrders[k].BarsExpirationOpen); if ( BarOrders[j].BuyLimitOrders[k].VolumeAlpha < 0.0 ) BarOrders[j].BuyLimitOrders[k].VolumeAlpha=0.0; } } if ( BarOrders[j].SellLimitOrders[k].Status == STATUS_VIRTUAL )// { if ( BarOrders[j].SellLimitOrders[k].IndexMarket - 1 >= BarOrders[j].SellLimitOrders[k].BarsExpirationOpen ) BarOrders[j].SellLimitOrders[k].Status=STATUS_ABORTED; else { if ( BarOrders[j].SellLimitOrders[k].VolumeAlpha > 0.0 ) BarOrders[j].SellLimitOrders[k].VolumeAlpha-=BarOrders[j].SellLimitOrders[k].VolumeStart/double(BarOrders[j].SellLimitOrders[k].BarsExpirationOpen); if ( BarOrders[j].SellLimitOrders[k].VolumeAlpha < 0.0 ) BarOrders[j].SellLimitOrders[k].VolumeAlpha=0.0; } } } } } if ( VolumeAlphaStop != 0.0 ) { for ( int j=SizeBarOrders-1; j>0; j-- )// update the state of all candlesticks preceding this one { for ( int k=0; k<size; k++ )// update the state inside each preceding candlestick { if ( BarOrders[j].SellStopOrders[k].Status == STATUS_VIRTUAL && BarOrders[j].SellStopOrders[k].WantedPrice <= High[1] && BarOrders[j].SellStopOrders[k].WantedPrice >= Low[1] )// the same { BarOrders[j].SellStopOrders[k].Status = STATUS_MARKET; BarOrders[j].SellStopOrders[k].IndexMarket = 1; } if ( BarOrders[j].BuyStopOrders[k].Status == STATUS_VIRTUAL && BarOrders[j].BuyStopOrders[k].WantedPrice <= High[1] && BarOrders[j].BuyStopOrders[k].WantedPrice >= Low[1] )// the same { BarOrders[j].BuyStopOrders[k].Status = STATUS_MARKET; BarOrders[j].BuyStopOrders[k].IndexMarket = 1; } /////// Check for interest expiration of stop players if ( BarOrders[j].BuyStopOrders[k].Status == STATUS_VIRTUAL )// { if ( BarOrders[j].BuyStopOrders[k].IndexMarket - 1 >= BarOrders[j].BuyStopOrders[k].BarsExpirationOpen ) BarOrders[j].BuyStopOrders[k].Status=STATUS_ABORTED; else { if ( BarOrders[j].BuyStopOrders[k].VolumeAlpha > 0.0 ) BarOrders[j].BuyStopOrders[k].VolumeAlpha-=BarOrders[j].BuyStopOrders[k].VolumeStart/double(BarOrders[j].BuyStopOrders[k].BarsExpirationOpen); if ( BarOrders[j].BuyStopOrders[k].VolumeAlpha < 0.0 ) BarOrders[j].BuyStopOrders[k].VolumeAlpha=0.0; } } if ( BarOrders[j].SellStopOrders[k].Status == STATUS_VIRTUAL )// { if ( BarOrders[j].SellStopOrders[k].IndexMarket - 1 >= BarOrders[j].SellStopOrders[k].BarsExpirationOpen ) BarOrders[j].SellStopOrders[k].Status=STATUS_ABORTED; else { if ( BarOrders[j].SellStopOrders[k].VolumeAlpha > 0.0 ) BarOrders[j].SellStopOrders[k].VolumeAlpha-=BarOrders[j].SellStopOrders[k].VolumeStart/double(BarOrders[j].SellStopOrders[k].BarsExpirationOpen); if ( BarOrders[j].SellStopOrders[k].VolumeAlpha < 0.0 ) BarOrders[j].SellStopOrders[k].VolumeAlpha=0.0; } } } } } } void UpdateMarketFast()// update the status of market orders { int size=ArraySize(BarOrders[0].BuyLimitOrders); int SizeBarOrders=ArraySize(BarOrders); if ( VolumeAlphaLimit != 0.0 ) { for ( int j=SizeBarOrders-1; j>0; j-- )// update the state of all candlesticks preceding this one { for ( int k=0; k<size; k++ )// update the state inside each preceding candlestick { // Block for closing when prices change if ( BarOrders[j].BuyLimitOrders[k].Status == STATUS_MARKET )// { if ( BarOrders[j].BuyLimitOrders[k].VolumeAlpha > 0.0 ) { BarOrders[j].BuyLimitOrders[k].VolumeAlpha-=BarOrders[j].BuyLimitOrders[k].VolumeStart*(High[1]-Open[1])/(BarOrders[j].BuyLimitOrders[k].UpPriceToClose-BarOrders[j].BuyLimitOrders[k].WantedPrice);// with profit BarOrders[j].BuyLimitOrders[k].VolumeAlpha-=BarOrders[j].BuyLimitOrders[k].VolumeStart*(Open[1]-Low[1])/(BarOrders[j].BuyLimitOrders[k].WantedPrice-BarOrders[j].BuyLimitOrders[k].LowPriceToClose);// with loss } if ( BarOrders[j].BuyLimitOrders[k].VolumeAlpha < 0.0 ) BarOrders[j].BuyLimitOrders[k].VolumeAlpha=0.0; } if ( BarOrders[j].SellLimitOrders[k].Status == STATUS_MARKET )// { if ( BarOrders[j].SellLimitOrders[k].VolumeAlpha > 0.0 ) { BarOrders[j].SellLimitOrders[k].VolumeAlpha-=BarOrders[j].SellLimitOrders[k].VolumeStart*(Open[1]-Low[1])/(BarOrders[j].SellLimitOrders[k].WantedPrice-BarOrders[j].SellLimitOrders[k].LowPriceToClose);// with profit BarOrders[j].SellLimitOrders[k].VolumeAlpha-=BarOrders[j].SellLimitOrders[k].VolumeStart*(High[1]-Open[1])/(BarOrders[j].SellLimitOrders[k].UpPriceToClose-BarOrders[j].SellLimitOrders[k].WantedPrice);// with loss } if ( BarOrders[j].SellLimitOrders[k].VolumeAlpha < 0.0 ) BarOrders[j].SellLimitOrders[k].VolumeAlpha=0.0; } // End of lock for closing when prices change // Block for closing when time changes****************************************************** if ( BarOrders[j].BuyLimitOrders[k].Status == STATUS_MARKET )// { if ( BarOrders[j].BuyLimitOrders[k].VolumeAlpha > 0.0 ) BarOrders[j].BuyLimitOrders[k].VolumeAlpha-=BarOrders[j].BuyLimitOrders[k].VolumeStart/double(BarOrders[j].BuyLimitOrders[k].BarsExpirationClose); if ( BarOrders[j].BuyLimitOrders[k].VolumeAlpha < 0.0 ) BarOrders[j].BuyLimitOrders[k].VolumeAlpha=0.0; } if ( BarOrders[j].SellLimitOrders[k].Status == STATUS_MARKET )// { if ( BarOrders[j].SellLimitOrders[k].VolumeAlpha > 0.0 ) BarOrders[j].SellLimitOrders[k].VolumeAlpha-=BarOrders[j].SellLimitOrders[k].VolumeStart/double(BarOrders[j].SellLimitOrders[k].BarsExpirationClose); if ( BarOrders[j].SellLimitOrders[k].VolumeAlpha < 0.0 ) BarOrders[j].SellLimitOrders[k].VolumeAlpha=0.0; } // } } } if ( VolumeAlphaStop != 0.0 ) { for ( int j=SizeBarOrders-1; j>0; j-- )// update the state of all candlesticks preceding this one { for ( int k=0; k<size; k++ )// update the state inside each preceding candlestick { // Block for closing when prices change if ( BarOrders[j].BuyStopOrders[k].Status == STATUS_MARKET )// { if ( BarOrders[j].BuyStopOrders[k].VolumeAlpha > 0.0 ) { BarOrders[j].BuyStopOrders[k].VolumeAlpha-=BarOrders[j].BuyStopOrders[k].VolumeStart*(High[1]-Open[1])/(BarOrders[j].BuyStopOrders[k].UpPriceToClose-BarOrders[j].BuyStopOrders[k].WantedPrice);// with profit BarOrders[j].BuyStopOrders[k].VolumeAlpha-=BarOrders[j].BuyStopOrders[k].VolumeStart*(Open[1]-Low[1])/(BarOrders[j].BuyStopOrders[k].WantedPrice-BarOrders[j].BuyStopOrders[k].LowPriceToClose);// with loss } if ( BarOrders[j].BuyStopOrders[k].VolumeAlpha < 0.0 ) BarOrders[j].BuyStopOrders[k].VolumeAlpha=0.0; } if ( BarOrders[j].SellStopOrders[k].Status == STATUS_MARKET )// { if ( BarOrders[j].SellStopOrders[k].VolumeAlpha > 0.0 ) { BarOrders[j].SellStopOrders[k].VolumeAlpha-=BarOrders[j].SellStopOrders[k].VolumeStart*(Open[1]-Low[1])/(BarOrders[j].SellStopOrders[k].WantedPrice-BarOrders[j].SellStopOrders[k].LowPriceToClose);// with profit BarOrders[j].SellStopOrders[k].VolumeAlpha-=BarOrders[j].SellStopOrders[k].VolumeStart*(High[1]-Open[1])/(BarOrders[j].SellStopOrders[k].UpPriceToClose-BarOrders[j].SellStopOrders[k].WantedPrice);// with loss } if ( BarOrders[j].SellStopOrders[k].VolumeAlpha < 0.0 ) BarOrders[j].SellStopOrders[k].VolumeAlpha=0.0; } // End of lock for closing when prices change // Block for closing when time changes****************************************************** if ( BarOrders[j].BuyStopOrders[k].Status == STATUS_MARKET )// { if ( BarOrders[j].BuyStopOrders[k].VolumeAlpha > 0.0 ) BarOrders[j].BuyStopOrders[k].VolumeAlpha-=BarOrders[j].BuyStopOrders[k].VolumeStart/double(BarOrders[j].BuyStopOrders[k].BarsExpirationClose); if ( BarOrders[j].BuyStopOrders[k].VolumeAlpha < 0.0 ) BarOrders[j].BuyStopOrders[k].VolumeAlpha=0.0; } if ( BarOrders[j].SellStopOrders[k].Status == STATUS_MARKET )// { if ( BarOrders[j].SellStopOrders[k].VolumeAlpha > 0.0 ) BarOrders[j].SellStopOrders[k].VolumeAlpha-=BarOrders[j].SellStopOrders[k].VolumeStart/double(BarOrders[j].SellStopOrders[k].BarsExpirationClose); if ( BarOrders[j].SellStopOrders[k].VolumeAlpha < 0.0 ) BarOrders[j].SellStopOrders[k].VolumeAlpha=0.0; } // } } } if ( VolumeAlphaMarket != 0.0 ) { for ( int j=SizeBarOrders-1; j>0; j-- )// update the state of all candlesticks preceding this one { for ( int k=0; k<size; k++ )// update the state inside each preceding candlestick { /// For obviously market positions if ( BarOrders[j].BuyMarketOrders[k].VolumeAlpha > 0.0 ) { BarOrders[j].BuyMarketOrders[k].VolumeAlpha-=BarOrders[j].BuyMarketOrders[k].VolumeStart*(High[1]-Open[1])/(BarOrders[j].BuyMarketOrders[k].UpPriceToClose-BarOrders[j].BuyMarketOrders[k].WantedPrice);// with profit BarOrders[j].BuyMarketOrders[k].VolumeAlpha-=BarOrders[j].BuyMarketOrders[k].VolumeStart*(Open[1]-Low[1])/(BarOrders[j].BuyMarketOrders[k].WantedPrice-BarOrders[j].BuyMarketOrders[k].LowPriceToClose);// with loss } if ( BarOrders[j].BuyMarketOrders[k].VolumeAlpha < 0.0 ) BarOrders[j].BuyMarketOrders[k].VolumeAlpha=0.0; if ( BarOrders[j].SellMarketOrders[k].VolumeAlpha > 0.0 ) { BarOrders[j].SellMarketOrders[k].VolumeAlpha-=BarOrders[j].SellMarketOrders[k].VolumeStart*(Open[1]-Low[1])/(BarOrders[j].SellMarketOrders[k].WantedPrice-BarOrders[j].SellMarketOrders[k].LowPriceToClose);// with profit BarOrders[j].SellMarketOrders[k].VolumeAlpha-=BarOrders[j].SellMarketOrders[k].VolumeStart*(High[1]-Open[1])/(BarOrders[j].SellMarketOrders[k].UpPriceToClose-BarOrders[j].SellMarketOrders[k].WantedPrice);// with loss } if ( BarOrders[j].SellMarketOrders[k].VolumeAlpha < 0.0 ) BarOrders[j].SellMarketOrders[k].VolumeAlpha=0.0; // End of lock for closing when prices change // Block for closing when time changes****************************************************** /// For obviously market positions if ( BarOrders[j].BuyMarketOrders[k].VolumeAlpha > 0.0 ) BarOrders[j].BuyMarketOrders[k].VolumeAlpha-=BarOrders[j].BuyMarketOrders[k].VolumeStart/double(BarOrders[j].BuyMarketOrders[k].BarsExpirationClose); if ( BarOrders[j].BuyMarketOrders[k].VolumeAlpha < 0.0 ) BarOrders[j].BuyMarketOrders[k].VolumeAlpha=0.0; if ( BarOrders[j].SellMarketOrders[k].VolumeAlpha > 0.0 ) BarOrders[j].SellMarketOrders[k].VolumeAlpha-=BarOrders[j].SellMarketOrders[k].VolumeStart/double(BarOrders[j].SellMarketOrders[k].BarsExpirationClose); if ( BarOrders[j].SellMarketOrders[k].VolumeAlpha < 0.0 ) BarOrders[j].SellMarketOrders[k].VolumeAlpha=0.0; // } } } } ///****** void CalculateStartVolume()// calculate the starting total volume of all positions (relative to it we will estimate market fullness) { StartVolume=0; int size=ArraySize(BarOrders[0].BuyStopOrders); if ( VolumeAlphaStop != 0.0 ) { for ( int j=ArraySize(BarOrders)-1; j>=0; j-- ) { for ( int i=0; i<size; i++ ) { StartVolume+=BarOrders[j].BuyStopOrders[i].VolumeStart; } } } if ( VolumeAlphaLimit != 0.0 ) { size=ArraySize(BarOrders[0].BuyLimitOrders); for ( int j=ArraySize(BarOrders)-1; j>=0; j-- ) { for ( int i=0; i<size; i++ ) { StartVolume+=BarOrders[j].BuyLimitOrders[i].VolumeStart; } } } if ( VolumeAlphaMarket != 0.0 ) { size=ArraySize(BarOrders[0].BuyMarketOrders); for ( int j=ArraySize(BarOrders)-1; j>=0; j-- ) { for ( int i=0; i<size; i++ ) { StartVolume+=BarOrders[j].BuyMarketOrders[i].VolumeStart; } } } } void CalculateCurrentVolume()// calculate the current total volume of all positions { SummVolumeBuy=0; SummVolumeSell=0; int size=ArraySize(BarOrders[0].BuyStopOrders); if ( VolumeAlphaStop != 0.0 ) { for ( int j=ArraySize(BarOrders)-1; j>=0; j-- ) { for ( int i=0; i<size; i++ ) { if ( BarOrders[j].BuyStopOrders[i].Status == STATUS_MARKET ) SummVolumeBuy+=BarOrders[j].BuyStopOrders[i].VolumeAlpha; if ( BarOrders[j].SellStopOrders[i].Status == STATUS_MARKET ) SummVolumeSell+=BarOrders[j].SellStopOrders[i].VolumeAlpha; } } } if ( VolumeAlphaLimit != 0.0 ) { size=ArraySize(BarOrders[0].BuyLimitOrders); for ( int j=ArraySize(BarOrders)-1; j>=0; j-- ) { for ( int i=0; i<size; i++ ) { if ( BarOrders[j].BuyLimitOrders[i].Status == STATUS_MARKET ) SummVolumeBuy+=BarOrders[j].BuyLimitOrders[i].VolumeAlpha; if ( BarOrders[j].SellLimitOrders[i].Status == STATUS_MARKET ) SummVolumeSell+=BarOrders[j].SellLimitOrders[i].VolumeAlpha; } } } if ( VolumeAlphaMarket != 0.0 ) { size=ArraySize(BarOrders[0].BuyMarketOrders); for ( int j=ArraySize(BarOrders)-1; j>=0; j-- ) { for ( int i=0; i<size; i++ ) { SummVolumeBuy+=BarOrders[j].BuyMarketOrders[i].VolumeAlpha; SummVolumeSell+=BarOrders[j].SellMarketOrders[i].VolumeAlpha; } } } } void CalculatePercent()// calculate the percentage of Buys and Sells relative to all positions { if ( (SummVolumeBuy+SummVolumeSell) != 0.0 ) BuyPercent=100.0*SummVolumeBuy/(SummVolumeBuy+SummVolumeSell); else BuyPercent=50; if ( (SummVolumeBuy+SummVolumeSell) != 0.0 ) SellPercent=100.0*SummVolumeSell/(SummVolumeBuy+SummVolumeSell); else SellPercent=50; } void CalculateRelativeVolume()// calculate relative volumes of Buys and Sells (calculate only uncovered part of positions) { if ( SummVolumeBuy >= SummVolumeSell ) RelativeVolume=(SummVolumeBuy-SummVolumeSell)/StartVolume; else RelativeVolume=(SummVolumeSell-SummVolumeBuy)/StartVolume; } };
L'intero codice è valido sia per la MetaTrader 4 che per la MetaTrader 5. Queste classi possono essere compilate su entrambe le piattaforme. Naturalmente in MetaTrader 5 è necessario implementare in anticipo gli array predefiniti, come in MQL4. Non fornirò questo codice qui. È possibile verificarlo nel codice sorgente allegato. Il mio codice non è molto originale. Tutto quello che dobbiamo fare ora è implementare le variabili responsabili del trading e le relative funzionalità. Gli Expert Advisor per entrambi i terminali sono allegati di seguito.
Il codice richiede molte risorse, per questo ho organizzato un'implementazione lenta della logica per l'avvio dell'analisi e un'implementazione veloce per lavorare sulle barre. Tutti i miei Expert Advisor lavorano per barre per evitare la dipendenza dalla generazione artificiale di tick e altre conseguenze indesiderate dei test ad ogni tick. Naturalmente, potremmo evitare completamente le funzioni lente. Ma in questo caso non ci sarebbe stata alcuna analisi di partenza. Inoltre, non mi piace implementare funzionalità al di fuori del corpo della classe, perché questo rovina l'integrità dell'immagine, a mio parere.
Il costruttore dell'ultima classe accetterà i seguenti parametri, che saranno gli input. Se lo desideri, puoi fare molte simulazioni di questo tipo, perché si tratta solo di un'istanza di classe:
input bool bPrintE=false;// print market parameters input CLOSE_MODE CloseModeE=CLOSE_FAST;// order closing mode input WORK_MODE ModeE=MODE_SIMPLE;// simulation mode input ENUM_GRID_WEIGHT WeightFillingE=WEIGHT_SAME;// weight distribution type input double LimitVolumeE=0.5;// significance of limit orders input double StopVolumeE=0.5;// significance of stop orders input double MarketVolume=0.5;// significance of market orders input int ExpirationBars=100;// bars for full expiration of open orders input int ExpirationOpenStopBars=1000;// patience of a stop player in bars, after which the order is canceled input int ExpirationOpenLimitBars=1000;// patience of a limit player in bars, after which the order is canceled input int ProfitPointsCloseE=200;// points to close with profit input int LossPointsCloseE=400;// points to close with loss input int HalfCorridorE=500;// half-corridor for limit and stop orders input int OrdersToOneBarE=50;// orders for half-grid per 1 bar input int BarsE=250;// bars for analysis input double MinPercentE=60;// minimum superiority of one trading side in percentage input double MaxPercentE=80;// maximum percentage input double MinRelativeVolumeE=0.0001;// minimum market filling [0...1] input double MaxRelativeVolumeE=1.00;// maximum market filling [0...1]
Non fornirò qui le variabili relative al trading, poiché tutto è semplice e chiaro.
Ecco la mia funzione in cui viene implementato il trading:
void Trade() { if ( Area0 == NULL ) { CalcAllMQL5Values(); Area0 = new Simulation(WeightFillingE,HalfCorridorE,OrdersToOneBarE,BarsE ,ExpirationOpenLimitBars,ExpirationOpenStopBars,ExpirationBars,ProfitPointsCloseE,LossPointsCloseE ,StopVolumeE,LimitVolumeE,MarketVolume); } switch(ModeE) { case MODE_SIMPLE: Area0.Update();// update simulation case MODE_FAST: Area0.UpdateFast();// fast update simulation } if (bPrintE) { Print("BuyPercent= ",Area0.GetBuyPercent()); Print("SellPercent= ",Area0.GetSellPercent()); Print("RelativeVolume= ",Area0.GetRelativeVolume()); } if ( CloseModeE == CLOSE_FAST && Area0.GetBuyPercent() > 50.0 ) { if ( !bInvert ) CloseBuyF(); else CloseSellF(); } if ( CloseModeE == CLOSE_FAST && Area0.GetSellPercent() > 50.0 ) { if ( !bInvert ) CloseSellF(); else CloseBuyF(); } if ( Area0.GetBuyPercent() > MinPercentE && Area0.GetBuyPercent() < MaxPercentE && Area0.GetRelativeVolume() >= MinRelativeVolumeE && Area0.GetRelativeVolume() <= MaxRelativeVolumeE ) { if ( !bInvert ) { CloseBuyF(); SellF(); } else { CloseSellF(); BuyF(); } } if ( Area0.GetSellPercent() > MinPercentE && Area0.GetSellPercent() < MaxPercentE && Area0.GetRelativeVolume() >= MinRelativeVolumeE && Area0.GetRelativeVolume() <= MaxRelativeVolumeE ) { if ( !bInvert ) { CloseSellF(); BuyF(); } else { CloseBuyF(); SellF(); } } }
Se lo si desidera, è possibile creare condizioni di trading migliori e una funzione più complessa, ma per ora non ne vedo l'utilità. Cerco sempre di separare il trading dalla parte logica. La logica è implementata nell'oggetto. L'oggetto di simulazione viene creato dinamicamente nella funzione di trading alla prima attivazione; viene cancellato durante la deinizializzazione. Ciò è dovuto alla mancata disponibilità di array predefiniti in MQL5, che devono essere creati artificialmente per garantire il funzionamento della classe simile a quello di MQL4.
Come trovare le impostazioni di lavoro?
In base alla mia esperienza, posso dire che è meglio selezionare le impostazioni manualmente. Inoltre, suggerisco di ignorare lo spread nella prima fase per gli Expert Advisor che operano su timeframe bassi e hanno una piccola aspettativa matematica - questo ti aiuterà a non perdere prestazioni all'inizio. MetaTrader 4 è ottimo per questo scopo. Una ricerca di successo è sempre seguita da revisioni, modifiche e così via, nel tentativo di aumentare l'aspettativa matematica finale e il fattore di profitto (forza del segnale). Inoltre, la struttura dei dati di ingresso, idealmente, dovrebbe consentire modalità di funzionamento indipendenti. In altre parole, un'impostazione dovrebbe avere un effetto più indipendente sulle prestazioni del sistema, nonostante il valore delle altre impostazioni. Questo approccio può migliorare il segnale complessivo impostando impostazioni bilanciate che combineranno insieme tutti i segnali trovati. Tale implementazione non è sempre possibile, ma nel nostro caso è applicabile in quanto analizziamo ogni tipo di ordine separatamente.
Test dell'Expert Advisor
Questo Expert Advisor è stato scritto senza alcuna preparazione, da zero. Quindi questo codice dell’EA è nuovo per me. Avevo un EA simile, ma molto più semplice e con una logica completamente diversa. Voglio sottolineare questo aspetto, perché lo scopo dell'articolo era quello di dimostrare che qualsiasi idea che abbia delle basi corrette, anche se non descrive completamente la fisica del mercato, ha un'altissima possibilità di mostrare una certa performance. Se il sistema mostra capacità di performance di base, possiamo testarlo, scoprire cosa funziona in questo sistema e passare al livello successivo nella comprensione del mercato. Il livello successivo presuppone Expert Advisor di migliore qualità che potrete generare voi stessi.
Quando ho testato l'Expert Advisor, ho dovuto passare diversi giorni a selezionare pazientemente i parametri di trading. Tutto è stato noioso e lungo, ma sono riuscito a trovare delle impostazioni funzionanti. Naturalmente, queste impostazioni sono molto deboli e la simulazione viene eseguita utilizzando solo un tipo di ordine, ma questo è stato fatto di proposito. Perché è meglio analizzare separatamente il modo in cui uno specifico tipo di ordine influisce su un segnale, e poi cercare di simulare altri tipi di ordini. Ecco il mio risultato in MetaTrader 4:
Ho prima creato una versione per MetaTrader 4 e l'ho testata con lo spread più basso possibile. Il fatto è che abbiamo bisogno di vedere ogni tick per cercare i pattern, soprattutto sui timeframe più bassi. Durante il test della versione MetaTrader 5, non è possibile vedere questo a causa degli spread, che MetaTester 5 può regolare a sua discrezione.
Si tratta di uno strumento perfetto per gli stress test e per la valutazione delle prestazioni reali del sistema. Dovrebbe essere utilizzato nell'ultima fase per testare il sistema su tick reali. Nel nostro caso, è meglio iniziare a testare il sistema su MetaTrader 4. Consiglio a tutti di usare questo approccio, perché se si inizia immediatamente a testare nella quinta versione, si possono perdere molte opzioni di impostazione eccellenti, che possono servire come base per impostazioni di qualità migliore.
Sconsiglio l'uso dell'ottimizzazione per molte ragioni, ma la principale è che si tratta di una semplice iterazione di parametri. Non è possibile capire come funziona, se non si provano i parametri manualmente. Se si prende una vecchia radio, si collegano dei motori elettrici alle sue maniglie e li si avvia, molto probabilmente non si troverà una stazione radio. Lo stesso accade qui. Anche se si riesce a catturare qualcosa, sarà difficile capire di cosa si tratta.
Un altro aspetto molto importante è il numero di ordini. Più ordini vengono aperti rispetto al numero di barre, più la fisica è forte e non ci si deve preoccupare delle sue prestazioni in futuro. Ricordate anche che i pattern trovati possono trovarsi all'interno dello spread, il che può rendere il sistema inutile se questi momenti sono lasciati senza controllo!
A questo punto abbiamo bisogno del tester MetaTrader 5. MetaTrader 5 consente di testare una strategia utilizzando tick reali. Purtroppo, i tick reali esistono per un periodo relativamente recente per tutte le coppie di valute e gli strumenti. Testiamo la versione del sistema per MetaTrader 5 utilizzando tick reali e requisiti di spread molto severi per vedere se il sistema funziona nel 2020. Ma prima, testerò il sistema in modalità "Ogni tick" sul periodo precedentemente utilizzato:
Questa modalità di test non è altrettanto valida di quella che utilizza tick reali. Tuttavia, è evidente che qui è rimasta solo una minima parte dei segnali del risultato iniziale. Tuttavia, ci sono segnali che coprono lo spread e danno persino un piccolo profitto. Inoltre, non sono sicuro degli spread che il tester prende dallo storico. In questo test, il lotto era di 0,01, il che significa che l'aspettativa matematica è di 5 punti, un valore ancora più alto di quello del test originale, anche se il grafico non sembra molto buono. Questi dati possono ancora essere attendibili perché dietro c'è un enorme campione di 100.000 operazioni nel test iniziale.
Diamo ora uno sguardo all'ultimo anno:
In questo test, ho impostato il lotto a 0,1, quindi l'aspettativa matematica è di 23,4 punti, che è abbastanza buona, considerando che il test iniziale su MetaTrader 4 aveva un'aspettativa di soli 3 punti. L'aspettativa potrebbe scendere in futuro, ma non di molti punti. Quindi sarà ancora sufficiente per un trading in pareggio.
L'Expert Advisor per entrambi i terminali è disponibile nell'allegato qui sotto. È possibile modificare le impostazioni e cercare di trovare i parametri di lavoro per gli ordini limit e a mercato. poi è possibile combinare le impostazioni e impostare alcuni parametri medi. Purtroppo non ho avuto abbastanza tempo per sfruttarlo al meglio, quindi c'è spazio per ulteriori azioni.
Naturalmente, notate che non si tratta di un EA pronto all'uso, che si può semplicemente lanciare su un grafico e divertirsi. Testate la simulazione utilizzando altri tipi di ordini, quindi combinate le impostazioni e ripetete questi due cicli di test finché l'EA non mostra risultati di trading affidabili. È possibile introdurre alcuni filtri o regolare gli algoritmi stessi. Come si evince dai test, sono possibili ulteriori miglioramenti. È quindi possibile utilizzare il programma allegato e perfezionarlo nel tentativo di ottenere risultati stabili. Inoltre, non sono riuscito a trovare impostazioni adeguate per i timeframe più alti. L'EA funziona meglio su M5, ma forse è possibile trovare altri timeframe. Inoltre, non ho avuto il tempo di verificare le prestazioni delle impostazioni su altre coppie di valute. Tuttavia, di solito tali linee piatte significano che l'EA dovrebbe funzionare anche su altre coppie di valute. Cercherò di continuare a perfezionare l'EA se avrò tempo. Durante la stesura di questo articolo, ho trovato alcuni difetti ed errori nell'EA, quindi c'è ancora molto da fare.
Conclusioni
Il simulatore ha dimostrato buone aspettative riguardo a questo metodo di analisi. Dopo aver ottenuto i primi risultati, è il momento di pensare a come migliorarli, come modernizzare l'algoritmo e renderlo migliore, più veloce e più variabile. Il vantaggio principale di questo approccio è la sua massima semplicità. Non sto parlando dell'implementazione della logica, ma della logica sottostante a questo metodo da un punto di vista fisico.
Non possiamo prendere in considerazione tutti i fattori che influenzano il movimento dei prezzi. Ma anche se esiste almeno un fattore di questo tipo (anche se non possiamo descriverlo in modo affidabile), allora anche una descrizione imprecisa del suo codice produrrà determinati segnali. Questi segnali potrebbero non essere di qualità molto elevata, ma saranno sufficienti per generare un certo profitto da questa idea. Non cercate di trovare una formula ideale, perché è impossibile, perché non si può mai tenere conto di tutti i fattori che influenzano il mercato.
Inoltre, non è necessario utilizzare esattamente il mio approccio. Lo scopo di questo articolo è stato quello di utilizzare una certa fisica del mercato che, a mio avviso, descrive almeno in parte il mercato, e scrivere un Expert Advisor che possa dimostrare l'idea. Di conseguenza, ho sviluppato un Expert Advisor che ha dimostrato che tali ipotesi possono servire come base per un sistema funzionante.
Tenete anche conto del fatto che il codice presenta difetti e bug minori e maggiori. Anche in questa forma l'EA funziona. Dovreste solo perfezionarlo. Nel prossimo articolo presenterò un altro tipo di analisi di mercato multi-asset, più semplice, più efficace e noto a tutti. Anche in questo caso creeremo un Expert Advisor.
Tradotto dal russo da MetaQuotes Ltd.
Articolo originale: https://www.mql5.com/ru/articles/8411
Combinatoria e probabilità per il trading (Parte IV): Logica di Bernoulli
Sviluppare un Expert Advisor per il trading da zero (Parte 28): Verso il futuro (III)
Combinatoria e probabilità per il trading (Parte V): Analisi della curva
Sviluppare un Expert Advisor per il trading da zero (Parte 27): Verso il futuro (II)
- App di trading gratuite
- Oltre 8.000 segnali per il copy trading
- Notizie economiche per esplorare i mercati finanziari
Accetti la politica del sito e le condizioni d’uso