una strategia di trading basata sulla teoria dell'onda di Elliott - pagina 19

 
Beh, non credo proprio ;). La deviazione standard è la RMS (root-mean-square deviation) del prezzo osservato dalla previsione. Cioè, si calcola la previsione, si vede quello che si ottiene, lo si confronta con quello che doveva essere la previsione e poi si traggono le conclusioni. Questa è una delle ragioni per cui il processo è iterativo.
Usando l'indicatore incorporato in MT4 significa automaticamente che si seleziona la media mobile come prezzo di previsione. Puoi selezionare qualcos'altro. L'algoritmo per calcolare l'RMS stesso è corretto: la radice quadrata della somma dei quadrati divisa per il numero di gradi di libertà.

Buona fortuna e in bocca al lupo per le tendenze.
 
Vladislav, a giudicare dalle mie ipotesi enunciate nella pagina precedente, e che non sono state ancora confutate da te, per trovare la parabola ottimale si cercano le distanze più brevi dai punti della serie dei prezzi a questa stessa parabola (le lunghezze delle perpendicolari tracciate dai punti della serie alla parabola) considerando che il campo dei prezzi è potenzialmente relativo alla parabola. Questo complica comprensibilmente i calcoli, perché dobbiamo risolvere l'equazione cubica. Voglio solo capire ancora una volta quanto è giustificato questo metodo di trovare la parabola ottimale rispetto al trovare la parabola ottimale con il metodo della regressione, quando si calcola la somma dei quadrati delle differenze tra i punti della serie dei prezzi e la parabola allo stesso punto nel tempo? Potresti dare una stima in termini di praticità del metodo di regressione per trovare la parabola ottimale? Questo metodo è stato rifiutato da voi come risultato di alcune indagini sperimentali per alcune ragioni (poi quali ragioni?), o siete giunti alla conclusione che il metodo più complesso di trovare la parabola ottimale produce conclusioni più accurate sulle aree di inversione, mentre non c'è una differenza fondamentale tra i metodi? Dopo tutto, a prima vista è difficile determinare quanta differenza l'utilizzo di metodi diversi per determinare la parabola ottimale influirà sul risultato finale. Naturalmente capisco che i coefficienti delle parabole trovate con metodi diversi saranno diversi, ma vorrei capire quanto, e ancora più importante, quanto differiranno i risultati finali?
 
Per quanto riguarda la convergenza - non dimenticate che ci sono termini della serie per stimare l'errore di approssimazione - quindi non avete bisogno di un numero infinito di termini.

Vladislav, vorrei anche chiarire se ho capito bene la tua raccomandazione.
Diamo la formula di Taylor:

Consideriamo le derivate della parabola f(x)=Ax^2+B
f'(x)=2Ax,
f''(x)=2A,
f''(x)=0, tutte le derivate dalla terza in su diventano 0.
Allora secondo la formula di Taylor abbiamo serie composta solo dai primi tre termini. In questo caso, l'espansione in serie di Taylor della funzione f(x)=Ax^2+B sarà esatta (cioè l'ultimo termine dell'errore di espansione diventa zero). Successivamente, dobbiamo valutare la qualità dell'approssimazione della serie dei prezzi da parte della parabola ottimale. Cioè, il nostro requisito principale è che la serie di errori di approssimazione deve essere convergente (cioè la somma degli errori converge a un numero finito). E possiamo determinarlo semplicemente confrontando l'errore di approssimazione calcolato con il terzo termine dell'espansione. Ho ragione o no? Quindi, quando si sceglie una parabola e il campione stesso, si usa il criterio che l'RMS degli errori di approssimazione non deve superare il valore del terzo termine della serie, per un campione di valori che giace nell'intervallo da a a x? Segui lo stesso principio nella tua strategia o no?
A proposito, c'è qualche incongruenza in questo. Ottimizziamo la parabola usando la proprietà della potenzialità del prezzo (attraverso la perpendicolare alla parabola) e stimiamo gli errori di approssimazione nel modo usuale.
Cosa c'è di sbagliato qui? Come possiamo conciliare la ricerca della parabola ottimale e la stima dell'errore di approssimazione?
 
Ripetiamo: ti stai allontanando dalla soluzione integrale. Che la traiettoria sia una parabola segue dalla potenzialità del campo, ma dove hai preso l'idea che sto risolvendo un'equazione cubica? Ho scritto - uso metodi integrali, le cui stime tengono conto delle peculiarità del campo potenziale - in realtà semplifica solo l'approccio. Ora vi farò un paio di domande alle quali dovrete trovare una risposta da soli. Cosa stai cercando e in che forma vuoi ottenere il risultato? Mi sono prefissato il compito di trovare la proiezione del promontorio. Di conseguenza, era necessario scegliere un metodo di approssimazione (da scegliere ragionevolmente) e un metodo di stima dell'errore di questa approssimazione. Questi metodi sono legati l'uno all'altro. Per favore perdonatemi, ma non descriverò l'algoritmo che ho sviluppato e su cui si basa il mio sistema, ma i principi di base, per favore. Quindi qui sui principi - la costruzione di una proiezione (in realtà è un'estrapolazione, che a sua volta si basa sull'approssimazione corrente) sostanzia solo un ordine di funzioni approssimative, e questo a sua volta è un modo per determinare gli errori. Da considerazioni sulla potenzialità del campo, deduciamo l'ordine di approssimazione e le leggi fondamentali che la nostra approssimazione deve soddisfare, stimando anche il massimo errore ammissibile al quale la nostra approssimazione può ancora essere considerata adeguata. Quando si iniziano le indagini, si affronta una situazione di una certa incertezza - il fatto è che la base per le approssimazioni può non essere selezionata nell'unico modo (penso che rifletta la realtà che una tendenza di ordine superiore può essere scomposta in tendenze di ordine inferiore, e viceversa - tendenze di ordine inferiore possono diventare una tendenza di ordine superiore) - qui è necessario un criterio di qualità, in base al quale si può scegliere la migliore approssimazione in senso estrapolativo (ci possono essere diverse approssimazioni, ugualmente buone in senso estrapolativo). Ho scelto come criterio il minimo dell'energia potenziale funzionale (e questo è anche una conseguenza della potenzialità del campo del prezzo). Come costruire approssimazioni - hai già capito che è una forma quadratica - puoi cercare una parabola, o puoi cercare un altro modo - pensaci. Se cercate una parabola (io non lo faccio), potete usare l'algoritmo della deviazione standard dell'offerta standard - poi dovete sottrarre i prezzi reali dai valori della parabola. E poi, hai bisogno di tre punti per costruire la parabola - e probabilmente dovrai usare un'approssimazione spline con funzioni quadratiche - perché non è certo che tutti i tuoi prezzi si troveranno sulla stessa parabola per tutto il tempo del campione. Si potrebbe anche approssimare con un muvin - è necessario stimare, potrebbe essere meglio. E poi stimare l'intervallo di confidenza. Penso che le linee di Bolinger possano essere prese come intervallo di confidenza qui. In generale ci sono molte domande. Anche se questo approccio vi darà l'opportunità di utilizzare alcuni degli algoritmi che sono già disponibili. Inoltre - una volta scelta un'approssimazione, si può continuare nel futuro questa traiettoria (più si va avanti, meno affidabile è il risultato). Faccio anche quello che faccio io - scelgo il periodo di approssimazione (non tutto il campione, ma circa 2/3, estrapolo l'ultimo terzo e lo confronto con i prezzi reali ottenuti, se non cade fuori dall'intervallo di confidenza, allora uso questa approssimazione per ulteriori estrapolazioni, ma questo è legato all'implementazione e ai metodi per aumentare la stabilità degli algoritmi iterativi).


Buona fortuna e in bocca al lupo per le tendenze.
 
buon post :)
 
Privet vsem,

A mozet sdelajem v all vmeste konstruktivnuju rabotu?
Dite, napisat' sovmestno indikator, katoryj beget 4erez vs vs istoriju do teku4ej ceny i s4ityvajet Elliot waves :)))
Sviluppare MT4 tol'ko pablogodorit za takoje.

Neskol'ko moix idej dlia na4ala:

1) All'inizio istoriji opredelit' v kakuju toru cena ili FLAT
2) se FLAT, zdiom poka probivajutsia granitsia flata, tokda smotrim v kakuju storonu dvigajetsia cena, tak opredelajem na4alo ods4iota, s4itajem tol'ko 1-2-3 i A-B-C volny
3) is4em tol'ko "base" Elliot Wave patterns 1-2-3 i 1-2-3-4-5 + A-B-C volny dopo okon4anija dvizenija ceny (tendenza)
4) Jesli imejem "failed Elliot Wave", zna4it ploxoj ods4iot i tot kusok istroriji nada jes4io raz peresmatret' nas4iot v kakuju storonu dvigajetsia cena intervale pabolshe teku4evo.
5) K etim grafikam xorosho godosho cifra Fibonacci, sami lookotrite s indikator MT4 in istoriji da Elliot Wave 1 na4ala a na4ala Elliot Wave 4 - http://www.market-harmonics.com/elliott_wave2.htm

Dopolnitel'no doli poniatija o 4iom re4' pro4itaite http://www.elliottician.com/showpage.asp?p=47 i postaraites' ponat' kak kotritsia "bassic Elliot Wave pattern". Polnoje opisanije na ruskom ses' : http://www.alpari-idc.ru/ru/textbook/tech_an/ew/

Per quanto riguarda l'indikatora patom mozno podkrutit' k novojiji versi MT4 kak standartnyj indikator :)
 
Quindi sui principi - costruire una proiezione (in realtà è un'estrapolazione, che a sua volta si basa sull'approssimazione corrente) è esattamente il ragionamento dietro l'ordine delle funzioni approssimate, e questo a sua volta è il modo di determinare gli errori.

Quindi probabilmente si procede come segue.
Passo 1. Prendere un campione
Passo 2. Approssimarlo con un canale di regressione lineare
Passo 3. Trova gli errori di approssimazione.
Passo 4. Analizzare il grafico degli errori. Si suppone che l'ordine della funzione di approssimazione debba essere più alto o che il campione dato non possa essere approssimato da nessuna funzione continua se la serie di errori diverge o ha delle forti deviazioni visibili a occhio che cadono fuori dall'intervallo di confidenza accettabile (l'algoritmo di automazione del calcolo non è ancora completamente chiaro).
Passo 5. Ripetere i passi 1-4 per l'approssimazione con una parabola (o qualcos'altro)
Passo 6. Valutate gli errori; se gli errori superano un limite ragionevole, scartate semplicemente questo campione. Se il grafico degli errori ha una struttura ragionevole, allora memorizziamo le informazioni sul campionamento, il metodo di approssimazione e le informazioni aggiuntive sulle funzioni approssimate in qualche array.
Passo 7. Poi, avendo provato ripetutamente tutti i campioni possibili e avendo cercato le varianti ottimali delle funzioni approssimative per ogni campione, ci fermiamo a quei campioni che soddisfano i nostri requisiti in modo estremo. È anche naturalmente auspicabile utilizzare il metodo da voi raccomandato di approssimare le funzioni non per tutto il campione, ma solo per 2/3, lasciando l'ultimo terzo per testare i risultati dell'approssimazione (questo è un suggerimento molto prezioso!).
Passo 8. Disegna approssimazioni di estremi sul grafico del prezzo con continuazione nel futuro. È naturale che un intervallo di confidenza sia tracciato per ogni approssimazione.
Passo 9. Così vediamo dove si intersecano i limiti degli intervalli. Poi definiamo le date approssimative.
Passo 10. Durante l'avvicinamento del prezzo ai punti di svolta, calcoliamo la probabilità di inversione di tendenza utilizzando il metodo di stima dell'errore integrale. Sarà probabilmente necessario fare la media delle stime dei pivot per tutti i canali di approssimazione. Per il canale di regressione lineare sarà anche necessario calcolare il coefficiente di Hearst per averlo come parametro supplementare. È anche bene guardare i livelli di Murray. Così, abbiamo un'alta probabilità di prendere una decisione sul posizionamento degli ordini in sospeso e sulla determinazione degli stop con un rischio minimo.
Naturalmente, l'Expert Advisor che calcolerà tutto ciò sarà molto esteso (hai detto che contiene 6000 linee)! E finora non tutto è chiaro in termini di decisione automatica per ciascuno dei campioni. Beh, penso che tu debba solo iniziare a provare a programmare questo algoritmo, e poi, sperimentando, puoi capire qualcosa che è difficile da capire anche a livello teorico, ma che diventerà chiaro da solo durante l'esperimento. E in effetti il tempo di calcolo sarà abbastanza significativo. Hai detto che le prime varianti hanno funzionato per 30-40 minuti su una macchina debole. Quindi su un P4 2.4 GHz dovreste aspettarvi circa 10 minuti di tempo di calcolo.

Sul tema dei metodi di approssimazione ho trovato il seguente interessante tutorial.
 
Corretto. Penso che capirete il resto nel processo di implementazione dell'algoritmo.

Dato che non hai bisogno della parabola stessa, puoi approssimare le derivate subito. Il coefficiente di regressione è quello che ti serve (da qui la serie di Taylor ;) ). Allora non vi importerà quale sia la forma della traiettoria - la cosa principale è stimare correttamente l'intervallo di confidenza. Si prega di leggere attentamente la letteratura raccomandata, contiene abbastanza informazioni.

Buona fortuna e buone tendenze.
 
Corretto.....

Capito... :)
 
solandr, kak-to dumaju 4to ninado nikakix tam neuironnyx setej, skol'ko ja programiroval, vsio bylo pros4e :)

Vot odin iz moix staryx mql3:

/*[[
Name := Elliot wave recognization 
Author := Copyright © 2004, T-1000, Lithuania
Notes := Searches for Elliot wave patterns and places markers on chart
Link := irc://irc.omnitel.net/forex
Update on every tick := Yes 
Enable Alerts := Yes 
Disable alert once hit := Yes 
Lots := 0.1
Stop Loss := 70
Take Profit := 150
Trailing Stop := 35
]]*/


/*

An Impulse pattern moves in the direction of the underlying trend and is made up of five waves, or moves. 
Each wave is labeled at its endpoint. The Elliott Wave Principle identifies an Impulse wave when:

   1. Wave 2 does not fall below the starting price of wave 1.
   2. Wave 3 is not the shortest wave by price movement when comparing to wave 1 and wave 5.
   3. Wave 4 does not overlap the range of wave 1. 

*/

Defines: MaxBars(200),RetracementBars(100),EWPeriod(10),NoisePips(30),MinTakeProfit(50),SARstep(0.0015),SARmax(0.0100);
Defines: MaxTrades(1),AntiStopLoss(0),Slippage(5),DelayedBidsTimeout(172800),BidStopPoints(60),BidLimitPoints(50),TrailingStep(10),IncrementLots(1),MinMoney(0),MiniForexMode(1);
vars: counter(0),counter2(0),ComputedPricesCount(0),StartMoney(0);
vars: EW1(0),EW2(0),EW3(0),EW4(0),EW5(0);
vars: LastEW1(0),LastEW2(0),LastEW3(0),LastEW4(0),LastEW5(0);
vars: EW0MARK(0),EW1MARK(0),EW2MARK(0),EW3MARK(0),EW4MARK(0),EW5MARK(0),EW3ORDERMARK(0),ORDERMARK(0),ORDERANGLE(0),ORDERSKIP(0),ORDERPRICE(0),ORDERCOUNT(0),MinTakeProfitPtS(0);
vars: MaxPrice(0),MinPrice(0),WaveAngle(0),tempval(0),tempval2("");
vars: EW1MARKTIME(0),EW2MARKTIME(0),EW3MARKTIME(0),EW4MARKTIME(0),EW5MARKTIME(0),EW5PRICE(0),ENTRYPRICE(0),LASTENTRYPRICE(0);
vars: EW1MARKARROW(0),EW2MARKARROW(0),EW3MARKARROW(0),EW4MARKARROW(0),EW5MARKARROW(0);
vars: EW1MARKBAR(0),EW2MARKBAR(0),EW3MARKBAR(0),EW4MARKBAR(0),EW5MARKBAR(0);
vars: MaxPriceBar(0),MinPriceBar(0),BarsShift(0),BarsCount(0),init(0),prevbars(0),CalcBarDiff(0);
vars: ParabolicSAR(0),SARAngle(0),MA(0),MA2(0),ShortMA(0),LongMA(0),TrailingStopPoint(0),Trace(0),MACD(0),ShortMACD(0),MACDAngle(0),ShortMACDAngle(0);
vars: TradingPrice(0),TotalLots(0),TradesCount(0),StartDeposit(0),BuyStopLoss(0),SellStopLoss(0),BuyBidStopLoss(0),SellBidStopLoss(0);
vars: BuyLimitStopLoss(0),SellLimitStopLoss(0),TrailingStopLoss(0),BidStopPts(0),BidLimitPts(0),OrderType(0),LastBidTime(0),BadOrder(0),CloseBadOrder(0);
vars: LastBadTime(0),OrderRecovery(0),LastOp(0),LastOldOp(0),BuyOp(0),SellOp(0),EntryTrail(0),StopLossTrail(0);
vars: Bears(0),Bulls(0),BearsAngle(0),BullsAngle(0);
vars: Pivot(0),SupportLevel1(0),SupportLevel2(0),ResistanceLevel1(0),ResistanceLevel2(0);
vars: tmpPivot(0),tmpSupportLevel1(0),tmpSupportLevel2(0),tmpResistanceLevel1(0),tmpResistanceLevel2(0);
vars: RSI(0),CCI(0),ShortRSI(0),PriceLevel(0),LastPriceLevel(0),FiboLevel(0);
vars: EWOscillator(0),EWLevel(0),ShortPeriod(0),LongPeriod(0),LastEW(0);

if  Bars < MaxBars * 2 + RetracementBars + 1
then
exit;


if init = 0
then
{
EW0MARK = 0;
EW1MARK = 0;
EW2MARK = 0;
EW3MARK = 0;
EW4MARK = 0;
EW5MARK = 0;
ORDERMARK = 0;
TotalLots = Lots;
prevbars = 0;
if BidStopPts < BidStopPoints then BidStopPts = BidStopPoints;
if BidLimitPts < BidLimitPoints then BidLimitPts = BidLimitPoints;
BidStopPts = BidStopPts * Point;
BidLimitPts = BidLimitPts * Point;
StartDeposit = MinMoney;
if StartDeposit = 0 then StartMoney=Balance
else StartMoney = StartDeposit;
Print(AccountName,"(#",AccountNumber,") ",Symbol," Elliot Wave Retracement analizer loaded.");
init = 1;
}

if StopLoss > 0 then
{
BuyStopLoss=PriceAsk- StopLoss * Point;
SellStopLoss=PriceBid + StopLoss * Point;  
BuyBidStopLoss = BuyStopLoss + BidstopPts;
SellBidStopLoss = SellStopLoss - BidstopPts;
BuyLimitStopLoss=PriceAsk - StopLoss * Point - BidLimitPts;
SellLimitStopLoss=PriceBid + StopLoss * Point + BidLimitPts;  
}

// Adjust remaining money in loss
if Balance < StartMoney then 
{
//StartMoney=Balance;
TotalLots = Lots;
}

// Check if we have automated incremental Lots calculation
if IncrementLots > 0 and (FreeMargin / StartMoney > 2) then 
{
if MiniForexMode = 1 then TotalLots = Normalize(FreeMargin / StartMoney * Lots - 0.1,1);
if MiniForexMode = 0 then TotalLots = Normalize(FreeMargin / StartMoney * Lots - 1,0); // forex type account cannot have part of lots
if TotalLots < Lots then TotalLots = Lots;
}

/**************************************************** Indicators ********************************************************/
if Bars != prevbars 
// Save extra CPU when making signals because we do not have new price in chart in test mode
then 
{

Bears=iBearsPower(RetracementBars,MODE_HIGH,0);
Bulls=iBullsPower(RetracementBars,MODE_LOW,0);
RSI=iRSI(RetracementBars,0);
CCI=iCCI(MaxBars,0);
ShortRSI=iRSI(RetracementBars/5,0);
ParabolicSAR=iSAR(SARstep,SARmax,0);
MA=iMA(MaxBars,MODE_EMA,0);
MA2=iMA(MaxBars,MODE_SMA,0);
ShortMA=iMA(RetracementBars,MODE_EMA,0);
LongMA=iMA(MaxBars*2,MODE_LWMA,0);
MACD=iMACD(RetracementBars,MaxBars,RetracementBars,MODE_EMA,0);
ShortMACD=iMACD(RetracementBars/5,RetracementBars,RetracementBars/5,MODE_EMA,0);

MaxPriceBar = Highest (MODE_CLOSE,MaxBars+1, MaxBars*2);
MinPriceBar = Lowest (MODE_CLOSE, MaxBars+1, MaxBars*2);


if MaxPriceBar < MinPriceBar 
//and EW0MARK = 0
// first Elliot Wave would be UP
then
WaveAngle = 1; 

if MinPriceBar < MaxPriceBar 
//and EW0MARK = 0
// first Elliot Wave would be DOWN
then
WaveAngle = 2; 

MaxPrice = Close[MaxPriceBar];
MinPrice = Close[MinPriceBar];
if WaveAngle = 1 then FiboLevel = (MaxPrice - MinPrice) / (Open - MinPrice)  * 100
else FiboLevel = (MaxPrice - MinPrice) / (MaxPrice - Open ) * 100;

//LastPriceLevel=0;

if Bars > prevbars
then
{
ORDERANGLE = 0; 
Pivot=0;
SupportLevel1=0;
SupportLevel2=0;
ResistanceLevel1=0;
ResistanceLevel2=0;
LastPriceLevel=PriceLevel;

for counter=RetracementBars downto 0
Begin
MaxPriceBar = Highest (MODE_CLOSE,MaxBars+1+counter, MaxBars);
MinPriceBar = Lowest (MODE_CLOSE, MaxBars+1+counter, MaxBars);
MaxPrice = Close[MaxPriceBar];
MinPrice = Close[MinPriceBar];
/*
Pivot point (Pivot) = (H + L + C) / 3
First resistance level (R1) = (2 * P) - L
First support level (S1) = (2 * P) - H
Second resistance level (R2) = P + (R1 - S1)
Second support level (S2) = P - (R1 - S1)

H, L, C are the previous High, Low and Close.


*/

tmpPivot=(MaxPrice+MinPrice+Open[counter+MaxBars]) / 3;
tmpResistanceLevel1=(2 * tmpPivot) - MinPrice;
tmpSupportLevel1=(2 * tmpPivot) - MaxPrice;
tmpResistanceLevel2=tmpPivot + (tmpResistanceLevel1 - tmpSupportLevel1);
tmpSupportLevel2=tmpPivot - (tmpResistanceLevel1 - tmpSupportLevel1);

Pivot=Pivot + tmpPivot;
ResistanceLevel1=ResistanceLevel1 + tmpResistanceLevel1;
SupportLevel1=SupportLevel1 + tmpSupportLevel1;
ResistanceLevel2=ResistanceLevel2 + tmpResistanceLevel2;
SupportLevel2=SupportLevel2 + tmpSupportLevel2;
if counter < MaxBars
then
{
Pivot=Pivot / 2;
ResistanceLevel1=ResistanceLevel1 / 2;
SupportLevel1=SupportLevel1 / 2;
ResistanceLevel2=ResistanceLevel2 / 2;
SupportLevel2=SupportLevel2 / 2;
}
End;


if WaveAngle = 1 
then
PriceLevel = (Open / Point - SupportLevel2 / Point) / (ResistanceLevel2 / Point - SupportLevel2 / Point) * 100;

if WaveAngle = 2 
then
PriceLevel = -(ResistanceLevel2 / Point - Open / Point) / (ResistanceLevel2 / Point - SupportLevel2 / Point) * 100 ;


if PriceLevel >151
or PriceLevel < -151
then
{
ComputedPricesCount=Normalize(PriceLevel / 100,0);
if ComputedPricesCount < 0 then ComputedPricesCount = -ComputedPricesCount;
ComputedPricesCount=(2 + ComputedPricesCount) * MaxBars;
//Print(TimeToStr(time[shift]),": ",Symbol," Price Level is over limit:",PriceLevel," Increasing Prices Count to:",ComputedPricesCount);
if Bars <= ComputedPricesCount + MaxBars + 1
then  exit;//Avoid out of range computing
 
ORDERANGLE = 0; 
Pivot=0;
SupportLevel1=0;
SupportLevel2=0;
ResistanceLevel1=0;
ResistanceLevel2=0;

for counter=RetracementBars downto 0
Begin
MaxPriceBar = Highest (MODE_CLOSE,ComputedPricesCount+1+counter, ComputedPricesCount);
MinPriceBar = Lowest (MODE_CLOSE, ComputedPricesCount+1+counter, ComputedPricesCount);
MaxPrice = Close[MaxPriceBar];
MinPrice = Close[MinPriceBar];
/*
Pivot point (Pivot) = (H + L + C) / 3
First resistance level (R1) = (2 * P) - L
First support level (S1) = (2 * P) - H
Second resistance level (R2) = P + (R1 - S1)
Second support level (S2) = P - (R1 - S1)

H, L, C are the previous High, Low and Close.
*/

tmpPivot=(MaxPrice+MinPrice+Open[counter+ComputedPricesCount]) / 3;
tmpResistanceLevel1=(2 * tmpPivot) - MinPrice;
tmpSupportLevel1=(2 * tmpPivot) - MaxPrice;
tmpResistanceLevel2=tmpPivot + (tmpResistanceLevel1 - tmpSupportLevel1);
tmpSupportLevel2=tmpPivot - (tmpResistanceLevel1 - tmpSupportLevel1);

Pivot=Pivot + tmpPivot;
ResistanceLevel1=ResistanceLevel1 + tmpResistanceLevel1;
SupportLevel1=SupportLevel1 + tmpSupportLevel1;
ResistanceLevel2=ResistanceLevel2 + tmpResistanceLevel2;
SupportLevel2=SupportLevel2 + tmpSupportLevel2;
if counter < MaxBars
then
{
Pivot=Pivot / 2;
ResistanceLevel1=ResistanceLevel1 / 2;
SupportLevel1=SupportLevel1 / 2;
ResistanceLevel2=ResistanceLevel2 / 2;
SupportLevel2=SupportLevel2 / 2;
}
End;


if WaveAngle = 1 
then
PriceLevel = (Open / Point - SupportLevel2 / Point) / (ResistanceLevel2 / Point - SupportLevel2 / Point) * 100;

if WaveAngle = 2 
then
PriceLevel = -(ResistanceLevel2 / Point - Open / Point) / (ResistanceLevel2 / Point - SupportLevel2 / Point) * 100 ;

}


MoveObject("Pivot",OBJ_HLINE,Time,Pivot,Time[MaxBars],Pivot,White,1,STYLE_SOLID);
MoveObject(" ResistanceLevel2",OBJ_HLINE,Time,ResistanceLevel2,Time[MaxBars],ResistanceLevel2,Blue,1,STYLE_SOLID);
MoveObject(" SupportLevel2",OBJ_HLINE,Time,SupportLevel2,Time[MaxBars],SupportLevel2,Blue,1,STYLE_SOLID);
MoveObject(" ResistanceLevel1",OBJ_HLINE,Time,ResistanceLevel1,Time[MaxBars],ResistanceLevel1,Red,1,STYLE_SOLID);
MoveObject(" SupportLevel1",OBJ_HLINE,Time,SupportLevel1,Time[MaxBars],SupportLevel1,Red,1,STYLE_SOLID);

if MaxPriceBar < MinPriceBar
then
MoveObject("Fibo",OBJ_FIBO,Time,ResistanceLevel2,Time[MaxBars],SupportLevel2,Green,1,STYLE_DOT)
else
MoveObject("Fibo",OBJ_FIBO,Time,SupportLevel2,Time[MaxBars],ResistanceLevel2,Green,1,STYLE_DOT);

}
/*
if WaveAngle = 1 
and PriceLevel > 0
and PriceLevel < 50
then
WaveAngle = 2;

if WaveAngle = 2 
and PriceLevel < 0
and PriceLevel > -50
then
WaveAngle = 1;

*/
/*
if EW3MARK = 1 then 
{
//Print("EW0MARK:",EW0MARK," EW1MARK:",EW1MARK," EW2MARK:",EW2MARK," EW3MARK:",EW3MARK," EW3MARKBAR=",EW3MARKBAR," EW4MARK:",EW4MARK," EW0:",EW5PRICE," EW1:",EW1," EW2:",EW2," EW3:",EW3);
//Print("EW1MARKBAR:",EW1MARKBAR," EW2MARKBAR:",EW2MARKBAR," EW3MARKBAR:",EW3MARKBAR," EW3MARKBAR=",EW3MARKBAR," EW4MARK:",EW4MARK," EW0:",EW5PRICE," EW1:",EW1," EW2:",EW2," EW3:",EW3);
Print(TimeToStr(time),  
": EW0=",TimeToStr(EW5MARKTIME),
" ",EW5,
" EW1=",TimeToStr(EW1MARKTIME),
" ",EW1,
" EW2=",TimeToStr(EW2MARKTIME),
" ",EW2,
" EW3=",TimeToStr(EW3MARKTIME),
" ",EW3
);
}
*/

// Reallign Elliot Wave marked bars
if EW0MARK > 0 then EW5MARKBAR = 0;
if EW1MARK > 0 then EW1MARKBAR = 0;
if EW2MARK > 0 then EW2MARKBAR = 0;
if EW3MARK > 0 then EW3MARKBAR = 0;
if EW4MARK > 0 then EW4MARKBAR = 0;
if EW5MARK > 0 then EW5MARKBAR = 0;
if EW0MARK > 0 or EW5MARK > 0 then 
for counter = 0 to Bars -1
{
if EW5MARKBAR > 0 then break; // reallign finished
tempval = time[counter];

if EW5MARK = 0 and tempval = EW5MARKTIME then EW5MARKBAR = counter;
if EW1MARK > 0 and tempval = EW1MARKTIME then EW1MARKBAR = counter;
if EW2MARK > 0 and tempval = EW2MARKTIME then EW2MARKBAR = counter;
if EW3MARK > 0 and tempval = EW3MARKTIME then EW3MARKBAR = counter;
if EW4MARK > 0 and tempval = EW4MARKTIME then EW4MARKBAR = counter;
if EW5MARK > 0 and tempval = EW5MARKTIME then EW5MARKBAR = counter;
}
CalcBarDiff=(time[0]-time[Bars-1])/60/Period - Bars + 1;

if Bars < MaxBars+2
or (EW1MARK = 1 and EW1MARKBAR = 0)
or (EW2MARK = 1 and EW2MARKBAR = 0)
or (EW3MARK = 1 and EW3MARKBAR = 0)
or (EW4MARK = 1 and EW4MARKBAR = 0)
or (EW0MARK = 1 and EW5MARKBAR = 0)
or (EW5MARK = 1 and EW5MARKBAR = 0)
or EW1MARKBAR > Bars - 1
or EW2MARKBAR > Bars - 1
or EW3MARKBAR > Bars - 1
or EW4MARKBAR > Bars - 1
or EW5MARKBAR > Bars - 1 
then
{
if Bars > MaxBars+2
and prevbars < Bars
then
{
//prevbars=Bars;
/*
Print("Bars:",Bars," EW1MARKBAR:",EW1MARKBAR," EW2MARKBAR:",EW2MARKBAR," EW3MARKBAR:",EW3MARKBAR," EW3MARKBAR=",EW3MARKBAR," EW4MARKBAR:",EW4MARKBAR," EW5MARKBAR:",EW5MARKBAR);
Print(TimeToStr(time),  
": EW0=",TimeToStr(EW5MARKTIME),
" ",EW5,
" EW1=",TimeToStr(EW1MARKTIME),
" ",EW1,
" EW2=",TimeToStr(EW2MARKTIME),
" ",EW2,
" EW3=",TimeToStr(EW3MARKTIME),
" ",EW3
);
//print(time[1]," ",time[Bars-1]," ",time[100]," ",time[1]-time[Bars-1]," ",(time[1]-time[Bars-1])/60/Period, " ", time[0] - EW5MARKTIME);
*/
if EW0MARK = 1 and EW1MARK = 0 then print("ERROR: Bars:",Bars-1," EW0 Bar:", EW5MARKBAR, " EW0 Time:",TimeToStr(EW5MARKTIME), " Calculated EW0 Time:",TimeToStr(time[EW5MARKBAR])," EW0 Bars Diff:",(EW5MARKTIME-time[EW5MARKBAR])/60/Period);
if EW1MARK = 1 and EW2MARK = 0 then print("ERROR: Bars:",Bars-1," EW1 Bar:", EW1MARKBAR, " EW1 Time:",TimeToStr(EW1MARKTIME), " Calculated EW1 Time:",TimeToStr(time[EW1MARKBAR])," EW1 Bars Diff:",(EW1MARKTIME-time[EW1MARKBAR])/60/Period);
if EW2MARK = 1 and EW3MARK = 0 then print("ERROR: Bars:",Bars-1," EW2 Bar:", EW2MARKBAR, " EW2 Time:",TimeToStr(EW2MARKTIME), " Calculated EW2 Time:",TimeToStr(time[EW2MARKBAR])," EW2 Bars Diff:",(EW2MARKTIME-time[EW2MARKBAR])/60/Period);
if EW3MARK = 1 and EW4MARK = 0 then print("ERROR: Bars:",Bars-1," EW3 Bar:", EW3MARKBAR, " EW3 Time:",TimeToStr(EW3MARKTIME), " Calculated EW3 Time:",TimeToStr(time[EW3MARKBAR])," EW3 Bars Diff:",(EW3MARKTIME-time[EW3MARKBAR])/60/Period);
if EW4MARK = 1 and EW5MARK = 0 then print("ERROR: Bars:",Bars-1," EW4 Bar:", EW4MARKBAR, " EW4 Time:",TimeToStr(EW4MARKTIME), " Calculated EW4 Time:",TimeToStr(time[EW4MARKBAR])," EW4 Bars Diff:",(EW4MARKTIME-time[EW4MARKBAR])/60/Period);
if EW5MARK = 1 and EW0MARK = 0 then print("ERROR: Bars:",Bars-1," EW5 Bar:", EW5MARKBAR, " EW5 Time:",TimeToStr(EW5MARKTIME), " Calculated EW5 Time:",TimeToStr(time[EW5MARKBAR])," EW5 Bars Diff:",(EW5MARKTIME-time[EW5MARKBAR])/60/Period);
}
EW0MARK=0;
EW1MARK=0;
EW1=0;
EW1MARKTIME=0;
EW1MARKBAR=0;
EW2MARK=0;
EW2=0;
EW2MARKTIME=0;
EW2MARKBAR=0;
EW3MARK=0;
EW3=0;
EW3MARKTIME=0;
EW3MARKBAR=0;
EW4MARK=0;
EW4=0;
EW4MARKTIME=0;
EW4MARKBAR=0;
EW5MARK=0;
EW5=0;
EW5MARKTIME=0;
EW5MARKBAR=0;
ORDERMARK=0;
exit;
}


if EW0MARK = 0 and EW1MARK = 0 then 
{
EW0MARK = 0;
EW1MARK = 0;
EW1MARKBAR = 0;
EW1MARKTIME = 0;
EW2MARK = 0;
EW2MARKBAR = 0;
EW2MARKTIME = 0;
EW3MARK = 0;
EW3MARKBAR = 0;
EW3MARKTIME = 0;
EW4MARK = 0;
EW4MARKBAR = 0;
EW4MARKTIME = 0;
EW5MARK = 0;
EW5MARKBAR = 0;
EW5MARKTIME = 0;
}

MaxPriceBar = Highest (MODE_CLOSE,MaxBars+1, MaxBars);
MinPriceBar = Lowest (MODE_CLOSE, MaxBars+1, MaxBars);
MaxPrice = Close[MaxPriceBar];
MinPrice = Close[MinPriceBar];
//MaxPriceBar=time[MaxPriceBar];
//MinPriceBar=time[MinPriceBar];


if EW0MARK = 1 and EW2MARK = 0 and EW3MARK = 0
// Recalculate EW entry point while have only Elliot Wave [I]
then
{
MaxPriceBar = Highest (MODE_CLOSE,MaxBars+1, MaxBars);
MinPriceBar = Lowest (MODE_CLOSE, MaxBars+1, MaxBars);
MaxPrice = Close[MaxPriceBar];
MinPrice = Close[MinPriceBar];
if (WaveAngle = 1 and MinPrice < EW5PRICE)
or (WaveAngle = 2 and MaxPrice > EW5PRICE)
then
 {
if EW5MARKBAR <= MaxBars then
{
DelArrow(EW5MARKTIME,EW5PRICE + StopLoss / 2 * Point);
DelArrow(EW5MARKTIME,EW5PRICE - StopLoss / 2 * Point);
}
EW0MARK=0;
 }
}

/*
if WaveAngle = 1 and Close[counter] > MaxPrice then print("Counter:",counter, " MaxPrice:",MaxPrice);
if WaveAngle = 2 and Close[counter] < MaxPrice then print("Counter:",counter, " MinPrice:",MinPrice);

/*
//Reallign Elliot wave entry point
if WaveAngle = 1 and MaxPriceBar < RetracementBars then WaveAngle = 2
else
if WaveAngle = 2 and MinPriceBar < RetracementBars then WaveAngle = 1;
*/

//print("PriceLevel:",PriceLevel);

if (EW0MARK = 0)
//or (MaxPriceBar > MinPriceBar and WaveAngle = 1)
//or (MaxPriceBar < MinPriceBar and WaveAngle = 2)
then
{
EW0MARK=1;
EW1MARK=0;
EW2MARK=0;
EW3MARK=0;
EW4MARK=0;
EW5MARK=0;


if WaveAngle = 1
// try to mark first Elliot Wave
then
{
EW5=MinPrice;
EW5MARKBAR=MinPriceBar;
EW5MARKTIME=time[MinPriceBar];
EW5PRICE=MinPrice;
EW1=MinPrice;
//SetArrow(EW5MARKTIME,EW5PRICE,128,White);
SetArrow(EW5MARKTIME,EW5PRICE - StopLoss / 2 * Point,384,White);
Comment("\nEWTrend=Possible UP",
"\nLastTime=",TimeToStr(time[0]),
"\nEW0=",TimeToStr(EW5MARKTIME),
"    ",EW5,
"\nPivot                             ",Pivot,
"\nResistance Level I            ",ResistanceLevel1,
"\nSupport Level I                ",SupportLevel1,
"\nResistance Level II          ",ResistanceLevel2,
"\nSupport Level II              ",SupportLevel2,
"\nPrice Level                   ",PriceLevel,"%"
);
//Print(Symbol," EW0 Time:",TimeToStr(EW5MARKTIME),": EW0:",EW5," WaveAngle:",WaveAngle," MaxPriceBar:",MaxPriceBar," MinPriceBar:",MinPriceBar);
}

if WaveAngle = 2
// try to mark first reversed Elliot Wave
then
{
EW5=MaxPrice;
EW5MARKBAR=MaxPriceBar;
EW5MARKTIME=time[MaxPriceBar];
EW5PRICE=MaxPrice;
EW1=MaxPrice;
//SetArrow(EW5MARKTIME,EW5PRICE,128,Violet);
SetArrow(EW5MARKTIME,EW5PRICE + StopLoss / 2 * Point,384,Violet);
Comment("\nEWTrend=Possible DOWN",
"\nLastTime=",TimeToStr(time[0]),
"\nEW0=",TimeToStr(EW5MARKTIME),
"    ",EW5,
"\nPivot                             ",Pivot,
"\nResistance Level I            ",ResistanceLevel1,
"\nSupport Level I                ",SupportLevel1,
"\nResistance Level II          ",ResistanceLevel2,
"\nSupport Level II              ",SupportLevel2,
"\nPrice Level                   ",PriceLevel,"%"
);
//Print(Symbol," EW0 Time:",TimeToStr(EW5MARKTIME),": EW0:",EW5," WaveAngle:",WaveAngle," MaxPriceBar:",MaxPriceBar," MinPriceBar:",MinPriceBar);
}
//print ("waveangle=",WaveAngle);
}


//if IsTesting and EW3MARK = 1 then print("EW0MARK:",EW0MARK," EW1MARK:",EW1MARK," EW2MARK:",EW2MARK," EW3MARK:",EW3MARK," EW4MARK:",EW4MARK);

BarsShift=EW5MARKBAR;

/*
if EW5MARKBAR > MaxBars 
then  // reset EW count start entry 
{
EW0MARK=0;
if WaveAngle = 1 then DelArrow(EW5MARKTIME,EW5PRICE + StopLoss / 2 * Point);
if WaveAngle = 2 then DelArrow(EW5MARKTIME,EW5PRICE - StopLoss / 2 * Point);
}
*/


if EW0MARK=1 and EW2MARK=0 and EW3MARK=0
// and EW5MARKBAR > BarsCount
then
for counter=BarsShift - 1 downto 1
Begin

BarsCount = BarsShift - counter;
MaxPriceBar = Highest (MODE_CLOSE,EW5MARKBAR , BarsCount);
MinPriceBar = Lowest (MODE_CLOSE,EW5MARKBAR , BarsCount);
MaxPrice = Close[MaxPriceBar];
MinPrice = Close[MinPriceBar];



if WaveAngle = 1 and MaxPrice > EW1 and MaxPriceBar < EW5MARKBAR then 
{
EW1 = MaxPrice;
if EW1MARKBAR <= MaxBars then
DelArrow(EW1MARKTIME , Open[counter] + StopLoss / 2 * Point);
EW1MARKTIME=time[MaxPriceBar];
//print("EW1=",EW1);
}
if WaveAngle = 2 and MinPrice < EW1 and MinPriceBar < EW5MARKBAR  then 
{
if EW1MARKBAR <= MaxBars then
DelArrow(EW1MARKTIME , Open[counter] - StopLoss / 2 * Point);
EW1MARKTIME=time[MinPriceBar];
EW1 = MinPrice;
//print("EW1=",EW1);
}

/*
if IsTesting and (counter = BarsShift-1 or counter = 1) then
{
if WaveAngle = 1 then print("BarCount:",BarsCount ," Counter:",counter," Price:",Close[counter]," MaxPrice: ",MaxPrice," MaxPriceBar:",MaxPriceBar);
if WaveAngle = 2 then print("BarCount:",BarsCount ," Counter:",counter," Price:",Close[counter]," MinPrice:",MinPrice," MinPriceBar:",MinPriceBar);
print("Bars:",Bars-1," EW0 Bar:", EW5MARKBAR, " EW0 Time:",TimeToStr(EW5MARKTIME), " Calculated EW0 Time:",TimeToStr(time[EW5MARKBAR])," EW0 Bars Diff:",(EW5MARKTIME-time[EW5MARKBAR])/60/Period);
print("Bars:",Bars-1," EW1 Bar:", EW1MARKBAR, " EW1 Time:",TimeToStr(EW1MARKTIME), " Calculated EW1 Time:",TimeToStr(time[EW1MARKBAR])," EW1 Bars Diff:",(EW1MARKTIME-time[EW1MARKBAR])/60/Period);
print("WaveAngle:",WaveAngle," EW1MARK:",EW1MARK," EW0:",EW5PRICE," EW1:",EW1);
}
*/
if WaveAngle = 1
and Close[EW5MARKBAR] + NoisePips * Point < Close[counter]
and MaxPrice <= Close[counter]
and EW1 > Close[EW5MARKBAR] + NoisePips * Point
and EW1 <= close[counter]
then
{
if EW1MARKBAR <= MaxBars then
DelArrow(EW1MARKTIME , Open[counter] + StopLoss / 2 * Point);
if Close[counter] > MaxPrice then 
{
EW1 = Close[counter];
EW1MARKTIME=time[counter];
}
EW1MARK=1;
EW2=EW1;
EW1MARKTIME=time[counter];
EW1MARKBAR=counter;
//SetArrow(EW1MARKTIME,Open[counter] + StopLoss / 2 * Point,129,White);
Comment("\nEWTrend=Possible UP",
"\nEW0=",TimeToStr(EW5MARKTIME),
"    ",EW5,
"\nEW1=",TimeToStr(EW1MARKTIME),
"    ",EW1,
"\nPivot                             ",Pivot,
"\nResistance Level I            ",ResistanceLevel1,
"\nSupport Level I                ",SupportLevel1,
"\nResistance Level II          ",ResistanceLevel2,
"\nSupport Level II              ",SupportLevel2,
"\nPrice Level                   ",PriceLevel,"%"
);
//Print("EW1 Time:",TimeToStr(EW1MARKTIME),": EW1:",EW1," WaveAngle:",WaveAngle," MaxPriceBar:",MaxPriceBar," MinPriceBar:",MinPriceBar);
}

if WaveAngle = 2 
and Close[EW5MARKBAR] - NoisePips * Point > Close[counter]
and MinPrice >= Close[counter]
and EW1 < Close[EW5MARKBAR] - NoisePips * Point
and EW1 >= close[counter]
then
{
if EW1MARKBAR <= MaxBars then
DelArrow(EW1MARKTIME , Open[counter] - StopLoss / 2 * Point);
if Close[counter] < MinPrice then 
{
EW1 = Close[counter];
EW1MARKTIME=time[counter];
}
EW1MARK=1;
EW2=EW1;
EW1MARKBAR=counter;
//SetArrow(EW1MARKTIME,Open[counter] - StopLoss / 2 * Point,129,Violet);
Comment("\nEWTrend=Possible DOWN",
"\nEW0=",TimeToStr(EW5MARKTIME),
"    ",EW5,
"\nEW1=",TimeToStr(EW1MARKTIME),
"    ",EW1,
"\nPivot                             ",Pivot,
"\nResistance Level I            ",ResistanceLevel1,
"\nSupport Level I                ",SupportLevel1,
"\nResistance Level II          ",ResistanceLevel2,
"\nSupport Level II              ",SupportLevel2,
"\nPrice Level                   ",PriceLevel,"%"
);
//Print("EW1 Time:",TimeToStr(EW1MARKTIME),": EW1:",EW1," WaveAngle:",WaveAngle," MaxPriceBar:",MaxPriceBar," MinPriceBar:",MinPriceBar);
}


if EW1MARK = 1 and counter < EW1MARKBAR 
and (WaveAngle = 1 and Close[counter] < EW1 - NoisePips * Point 
 or (WaveAngle = 2 and Close[counter] > EW1 + NoisePips * Point)) 
then // Wave 1 ended
{
EW3MARK=1;
break;
}


End;


if EW0MARK=1 and EW2MARK=0 and EW3MARK=1
then
{
EW3MARK=0;
if WaveAngle = 1 
 then
 { 
if EW1MARKBAR <= MaxBars then
DelArrow(EW1MARKTIME, EW1 + StopLoss / 2 * Point);
SetArrow(EW1MARKTIME, EW1 + StopLoss / 2 * Point,129,White);
 }
 else
 { 
if EW1MARKBAR <= MaxBars then
DelArrow(EW1MARKTIME, EW1 - StopLoss / 2 * Point);
SetArrow(EW1MARKTIME, EW1 - StopLoss / 2 * Point,129,Violet);
 }
}

BarsShift=EW1MARKBAR;
if Bars < BarsShift then exit;

// Check for failed Elliot Wave 1
if (EW3MARK=0 and EW1MARK=1 and EW2MARK=0 and WaveAngle = 1 and EW1 < EW5PRICE - NoisePips * Point)
or (EW3MARK=0 and EW1MARK=1 and EW2MARK=0 and WaveAngle = 2 and EW1 > EW5PRICE + NoisePips * Point)
then
 {
 for counter=1 to EW5MARKBAR
 {
 DelArrow(time[counter] , Close[counter] + StopLoss / 2 * Point);
 DelArrow(time[counter] , Close[counter] - StopLoss / 2 * Point);
 }
 EW0MARK=0;
 EW1MARK=0;
 EW2MARK=0;
 EW3MARK=0;
 EW4MARK=0;
 EW5MARK=0;
}

if EW1MARK=1 and EW3MARK=0
then
for counter=BarsShift - 1 downto 1
Begin
BarsCount = BarsShift - counter;
MaxPriceBar = Highest (MODE_CLOSE,EW1MARKBAR , BarsCount);
MinPriceBar = Lowest (MODE_CLOSE,EW1MARKBAR , BarsCount);
MaxPrice = Close[MaxPriceBar];
MinPrice = Close[MinPriceBar];

if WaveAngle = 1 and MinPrice < EW2 and MinPriceBar < EW5MARKBAR then 
{
if EW2MARKBAR <= MaxBars then
DelArrow(EW2MARKTIME , Open[counter] - StopLoss / 2 * Point);
EW2 = MinPrice;
EW2MARKTIME=time[MinPriceBar];
}
if WaveAngle = 2 and MaxPrice > EW2 and MaxPriceBar < EW5MARKBAR then 
{
if EW2MARKBAR <= MaxBars then
DelArrow(EW2MARKTIME , Open[counter] + StopLoss / 2 * Point);
EW2 = MaxPrice;
EW2MARKTIME=time[MaxPriceBar];
}
if WaveAngle = 1 
and Close[EW1MARKBAR] - NoisePips * Point > Close[counter]
and MinPrice >= Close[counter]
and EW2 < Close[EW1MARKBAR] - NoisePips * Point
and EW2 > close[counter]
then
{
if EW2MARKBAR <= MaxBars then
DelArrow(EW2MARKTIME , Open[counter] - StopLoss / 2 * Point);
if Close[counter] < MinPrice then 
{
EW2 = Close[counter];
EW2MARKTIME=time[counter];
}
EW3=EW2;
EW2MARK=1;
EW2MARKBAR=counter;
EW3MARKBAR=EW2MARKBAR;
//SetArrow(EW2MARKTIME,Open[counter] - StopLoss / 2 * Point,130,White);
Comment("\nEWTrend=Possible UP",
"\nEW0=",TimeToStr(EW5MARKTIME),
"    ",EW5,
"\nEW1=",TimeToStr(EW1MARKTIME),
"    ",EW1,
"\nEW2=",TimeToStr(EW2MARKTIME),
"    ",EW2,
"\nPivot                             ",Pivot,
"\nResistance Level I            ",ResistanceLevel1,
"\nSupport Level I                ",SupportLevel1,
"\nResistance Level II          ",ResistanceLevel2,
"\nSupport Level II              ",SupportLevel2,
"\nPrice Level                   ",PriceLevel,"%"
);
//Print("EW2 Time:",TimeToStr(EW2MARKTIME),": EW2:",EW2," WaveAngle:",WaveAngle," MaxPriceBar:",MaxPriceBar," MinPriceBar:",MinPriceBar);
}

if WaveAngle = 2 
and Close[EW1MARKBAR] + NoisePips * Point < Close[counter]
and MaxPrice <= Close[counter]
and EW2 > Close[EW1MARKBAR] + NoisePips * Point
and EW2 < close[counter]
then
{
if EW2MARKBAR <= MaxBars then
DelArrow(EW2MARKTIME , Open[counter] + StopLoss / 2 * Point);
if Close[counter] > MaxPrice then 
{
EW2 = Close[counter];
EW2MARKTIME=time[counter];
}
EW3=EW2;
EW2MARK=1;
EW2MARKBAR=counter;
EW3MARKBAR=EW2MARKBAR;
//SetArrow(EW2MARKTIME,Open[counter] + StopLoss / 2 * Point,130,Violet);
Comment("\nEWTrend=Possible DOWN",
"\nEW0=",TimeToStr(EW5MARKTIME),
"    ",EW5,
"\nEW1=",TimeToStr(EW1MARKTIME),
"    ",EW1,
"\nEW2=",TimeToStr(EW2MARKTIME),
"    ",EW2,
"\nPivot                             ",Pivot,
"\nResistance Level I            ",ResistanceLevel1,
"\nSupport Level I                ",SupportLevel1,
"\nResistance Level II          ",ResistanceLevel2,
"\nSupport Level II              ",SupportLevel2,
"\nPrice Level                   ",PriceLevel,"%"
);
//Print("EW2 Time:",TimeToStr(EW2MARKTIME),": EW2:",EW2," WaveAngle:",WaveAngle," MaxPriceBar:",MaxPriceBar," MinPriceBar:",MinPriceBar);
}


// Check for failed Elliot Wave 2
if (EW3MARK=0 and EW2MARK=1 and WaveAngle = 1 and EW2 < EW5 - NoisePips * Point)
or (EW3MARK=0 and EW2MARK=1 and WaveAngle = 2 and EW2 > EW5 + NoisePips * Point)
then
 {
 for counter=1 to EW5MARKBAR
 {
 DelArrow(time[counter] , Close[counter] + StopLoss / 2 * Point);
 DelArrow(time[counter] , Close[counter] - StopLoss / 2 * Point);
 }
 EW0MARK=0;
 EW1MARK=0;
 EW2MARK=0;
 EW3MARK=0;
 EW4MARK=0;
 EW5MARK=0;
Comment("\nEWTrend=Recalculating..",
"\nEW0=",TimeToStr(EW5MARKTIME),
"    ",EW5,
"\nEW1=",TimeToStr(EW1MARKTIME),
"    ",EW1,
"\nEW2=",TimeToStr(EW2MARKTIME),
"    ",EW2,
"\nEW3=",TimeToStr(EW3MARKTIME),
"    ",EW3,
"\nPivot                             ",Pivot,
"\nResistance Level I            ",ResistanceLevel1,
"\nSupport Level I                ",SupportLevel1,
"\nResistance Level II          ",ResistanceLevel2,
"\nSupport Level II              ",SupportLevel2,
"\nPrice Level                   ",PriceLevel,"%"
);
/*
 Print(TimeToStr(time),": ",Symbol," Elliot Wave 2 failed, reverting retracement trend vector. ");
 Print("Old EW0=",TimeToStr(EW5MARKTIME),
" ",EW5,
" EW1=",TimeToStr(EW1MARKTIME),
" ",EW1,
" EW2=",TimeToStr(EW2MARKTIME),
" ",EW2,
" EW3=",TimeToStr(EW3MARKTIME),
" ",EW3
);
*/
/*
 MaxPriceBar = Highest (MODE_CLOSE,EW1MARKBAR + MaxBars+1 ,MaxBars);
 MinPriceBar = Lowest (MODE_CLOSE,EW1MARKBAR + MaxBars+1 ,MaxBars);
 MaxPrice = Close[MaxPriceBar];
 MinPrice = Close[MinPriceBar];

 tempval=EW5;
 EW3=EW2;
 EW2=EW1;
 if WaveAngle = 1 then EW5 = MinPrice;
 if WaveAngle = 2 then EW5 = MaxPrice;
 EW5PRICE=EW5;
 EW1=tempval;
 
 
 tempval=EW5MARKTIME;
 if WaveAngle = 1 then EW5MARKTIME = time[MinPriceBar];
 if WaveAngle = 2 then EW5MARKTIME = time[MaxPriceBar];
 EW3MARKTIME=EW2MARKTIME;
 EW2MARKTIME=EW1MARKTIME;
 EW1MARKTIME=tempval;
 
 tempval=EW5MARKBAR;
 if WaveAngle = 1 then EW5MARKBAR = MinPriceBar;
 if WaveAngle = 2 then EW5MARKBAR = MaxPriceBar;
 EW5MARKBAR=EW1MARKBAR;
 EW3MARKBAR=EW2MARKBAR;
 EW2MARKBAR=EW1MARKBAR;
 EW1MARKBAR=tempval;

if Bars < EW1MARKBAR + MaxBars+1 then
// Check if we have not enough prices for estimating EW0
{
EW5=Close[Bars-1];
EW5PRICE=EW5;
EW5MARKTIME=time[Bars-1];
EW5MARKBAR=Bars-1;
}

 EW4=0;
 EW4MARKTIME=0;

//print(TimeToStr(time),": ",TimeToStr(EW5MARKTIME)," ",EW5MARKBAR," ",EW5 + StopLoss / 2 * Point);
//print(time, " ",EW1MARKTIME," ",EW5MARKTIME," ",Period);
//print(TimeToStr(time), " ",TimeToStr(EW1MARKTIME)," ",TimeToStr(EW5MARKTIME)," ",Period);

 if WaveAngle = 1 then 
 {
// WaveAngle = 2;
Comment("\nEWTrend=Recalculating..",
"\nEW0=",TimeToStr(EW5MARKTIME),
"    ",EW5,
"\nEW1=",TimeToStr(EW1MARKTIME),
"    ",EW1,
"\nEW2=",TimeToStr(EW2MARKTIME),
"    ",EW2,
"\nEW3=",TimeToStr(EW3MARKTIME),
"    ",EW3,
"\nPivot                             ",Pivot,
"\nResistance Level I            ",ResistanceLevel1,
"\nSupport Level I                ",SupportLevel1,
"\nResistance Level II          ",ResistanceLevel2,
"\nSupport Level II              ",SupportLevel2,
"\nPrice Level                   ",PriceLevel,"%"
);
 SetArrow(EW5MARKTIME,EW5 + StopLoss / 2 * Point,128,Violet);
 SetArrow(EW1MARKTIME,EW1 - StopLoss / 2 * Point,129,Violet);
 SetArrow(EW2MARKTIME,EW2 + StopLoss / 2 * Point,130,Violet);
 SetArrow(EW3MARKTIME,EW3 - StopLoss / 2 * Point,131,Violet);
 }
 else 
 {
// WaveAngle = 1;
Comment("\nEWTrend=Recalculating..",
"\nEW0=",TimeToStr(EW5MARKTIME),
"    ",EW5,
"\nEW1=",TimeToStr(EW1MARKTIME),
"    ",EW1,
"\nEW2=",TimeToStr(EW2MARKTIME),
"    ",EW2,
"\nEW3=",TimeToStr(EW3MARKTIME),
"    ",EW3,
"\nPivot                             ",Pivot,
"\nResistance Level I            ",ResistanceLevel1,
"\nSupport Level I                ",SupportLevel1,
"\nResistance Level II          ",ResistanceLevel2,
"\nSupport Level II              ",SupportLevel2,
"\nPrice Level                   ",PriceLevel,"%"
);
 SetArrow(EW5MARKTIME,EW5 - StopLoss / 2 * Point,128,White);
 SetArrow(EW1MARKTIME,EW1 + StopLoss / 2 * Point,129,White);
// print(TimeToStr(EW1MARKTIME)," ",TimeToStr(time[EW1MARKBAR])," ",EW1 + StopLoss / 2 * Point);
// Print("EW0 Time:",TimeToStr(EW5MARKTIME),": EW0:",EW5," WaveAngle:",WaveAngle," MaxPriceBar:",MaxPriceBar," MinPriceBar:",MinPriceBar);

 SetArrow(EW2MARKTIME,EW2 - StopLoss / 2 * Point,130,White);
 SetArrow(EW3MARKTIME,EW3 + StopLoss / 2 * Point,131,White);
 }
 /*
 Print("\nEWTrend=Recalculating..",
 "EW0=",TimeToStr(EW5MARKTIME),
" ",EW5,
" EW1=",TimeToStr(EW1MARKTIME),
" ",EW1,
" EW2=",TimeToStr(EW2MARKTIME),
" ",EW2,
" EW3=",TimeToStr(EW3MARKTIME),
" ",EW3,
" Pivot ",Pivot,
" Resistance Level I ",ResistanceLevel1,
" Support Level I ",SupportLevel1,
" Resistance Level II ",ResistanceLevel2,
"\nSupport Level II              ",SupportLevel2,
"\nPrice Level                   ",PriceLevel,"%"
);
 */
 break;
}  
End;


if EW2MARK=1 and EW3MARK=0
then
{
if WaveAngle = 2 
 then
 { 
if EW2MARKBAR <= MaxBars then
DelArrow(EW2MARKTIME, EW2 + StopLoss / 2 * Point);
SetArrow(EW1MARKTIME, EW1 - StopLoss / 2 * Point,129,Violet);
SetArrow(EW2MARKTIME, EW2 + StopLoss / 2 * Point,130,Violet);
 }
 else
 { 
if EW2MARKBAR <= MaxBars then
DelArrow(EW2MARKTIME, EW2 - StopLoss / 2 * Point);
SetArrow(EW1MARKTIME, EW1 + StopLoss / 2 * Point,129,White);
SetArrow(EW2MARKTIME, EW2 - StopLoss / 2 * Point,130,White);
 }
}

BarsShift=EW1MARKBAR;
if Bars < BarsShift then exit;

if EW2MARK = 1 and EW4MARK = 0
// and EW4MARK = 0 
then
for counter=BarsShift - 1 downto 1
Begin

BarsCount = BarsShift - counter;
MaxPriceBar = Highest (MODE_CLOSE,EW1MARKBAR , BarsCount);
MinPriceBar = Lowest (MODE_CLOSE,EW1MARKBAR , BarsCount);
MaxPrice = Close[MaxPriceBar];
MinPrice = Close[MinPriceBar];

if WaveAngle = 1 and MaxPrice > EW3 and MaxPriceBar < EW2MARKBAR then 
{
EW3 = MaxPrice;
EW3MARKTIME=time[MaxPriceBar];
EW3MARKBAR=MaxPriceBar;
if EW3MARKBAR <= MaxBars then
DelArrow(EW3MARKTIME , Open[counter] + StopLoss / 2 * Point);
//print("EW3=",EW3);
}

if WaveAngle = 2 and MinPrice < EW3 and MinPriceBar < EW2MARKBAR  then 
{
if EW3MARKBAR <= MaxBars then
DelArrow(EW3MARKTIME , Open[counter] - StopLoss / 2 * Point);
EW3MARKTIME=time[MinPriceBar];
EW3MARKBAR=MinPriceBar;
EW3 = MinPrice;
//print("EW3=",EW3);
}


/*
if IsTesting and (counter = BarsShift-1 or counter = 1) then
{
if WaveAngle = 1 then print("BarCount:",BarsCount ," Counter:",counter," Price:",Close[counter]," MaxPrice: ",MaxPrice," MaxPriceBar:",MaxPriceBar);
if WaveAngle = 2 then print("BarCount:",BarsCount ," Counter:",counter," Price:",Close[counter]," MinPrice:",MinPrice," MinPriceBar:",MinPriceBar);
print("Bars:",Bars-1," EW2 Bar:", EW2MARKBAR, " EW2 Time:",TimeToStr(EW2MARKTIME), " Calculated EW2 Time:",TimeToStr(time[EW2MARKBAR])," EW2 Bars Diff:",(EW2MARKTIME-time[EW2MARKBAR])/60/Period);
print("Bars:",Bars-1," EW3 Bar:", EW3MARKBAR, " EW3 Time:",TimeToStr(EW3MARKTIME), " Calculated EW3 Time:",TimeToStr(time[EW3MARKBAR])," EW3 Bars Diff:",(EW3MARKTIME-time[EW3MARKBAR])/60/Period);
print("WaveAngle:",WaveAngle," EW3MARK:",EW3MARK," EW4MARK:",EW4MARK," EW0:",EW5PRICE," EW1:",EW1," EW2:",EW2," EW3:",EW3);
}
/*
if WaveAngle = 1 and Close[counter] > MaxPrice then print("Counter:",counter, " MaxPrice:",MaxPrice);
if WaveAngle = 2 and Close[counter] < MaxPrice then print("Counter:",counter, " MinPrice:",MinPrice);
*/

if WaveAngle = 1 
and EW1 + NoisePips * Point < Close[counter]
and MaxPrice <= Close[counter]
and EW3 > EW2 + NoisePips * Point
and EW3 < close[counter]
then
{
if EW3MARKBAR <= EW5MARKBAR then
DelArrow(EW3MARKTIME , Open[counter] + StopLoss / 2 * Point);
EW3 = Close[counter];
EW3MARKTIME=time[counter];
EW3MARK=1;
EW4=EW3;
EW3MARKBAR=counter;
//SetArrow(time[counter],Open[counter] + StopLoss / 2 * Point,131,White);
//print("EW0 date:",TimeToStr(EW5MARKTIME)," EW1 date:",TimeToStr(EW1MARKTIME)," EW2 date:",TimeToStr(EW2MARKTIME)," EW3 date:",TimeToStr(EW3MARKTIME));
Comment("\nEWTrend=UP",
"\nEW0=",TimeToStr(EW5MARKTIME),
"    ",EW5,
"\nEW1=",TimeToStr(EW1MARKTIME),
"    ",EW1,
"\nEW2=",TimeToStr(EW2MARKTIME),
"    ",EW2,
"\nEW3=",TimeToStr(EW3MARKTIME),
"    ",EW3,
"\nPivot                             ",Pivot,
"\nResistance Level I            ",ResistanceLevel1,
"\nSupport Level I                ",SupportLevel1,
"\nResistance Level II          ",ResistanceLevel2,
"\nSupport Level II              ",SupportLevel2,
"\nPrice Level                   ",PriceLevel,"%"
);
//Print("EW3 Time:",TimeToStr(EW3MARKTIME),": EW3:",EW3," WaveAngle:",WaveAngle," MaxPriceBar:",MaxPriceBar," MinPriceBar:",MinPriceBar);
}

if WaveAngle = 2 
and EW1 - NoisePips * Point > Close[counter]
and MinPrice >= Close[counter]
and EW3 < EW2 - NoisePips * Point
and EW3 > close[counter]
then
{
if EW3MARKBAR <= EW5MARKBAR then
DelArrow(EW3MARKTIME , Open[counter] - StopLoss / 2 * Point);
EW3 = Close[counter];
EW3MARKTIME=time[counter];
EW3MARK=1;
EW4=EW3;
EW4MARKTIME=time[counter];
EW3MARKBAR=counter;
//SetArrow(time[counter],Open[counter],131,Violet);
Comment("\nEWTrend=DOWN",
"\nEW0=",TimeToStr(EW5MARKTIME),
"    ",EW5,
"\nEW1=",TimeToStr(EW1MARKTIME),
"    ",EW1,
"\nEW2=",TimeToStr(EW2MARKTIME),
"    ",EW2,
"\nEW3=",TimeToStr(EW3MARKTIME),
"    ",EW3,
"\nPivot                             ",Pivot,
"\nResistance Level I            ",ResistanceLevel1,
"\nSupport Level I                ",SupportLevel1,
"\nResistance Level II          ",ResistanceLevel2,
"\nSupport Level II              ",SupportLevel2,
"\nPrice Level                   ",PriceLevel,"%"
);
//Print("EW3 Time:",TimeToStr(EW3MARKTIME),": EW3:",EW3," WaveAngle:",WaveAngle," MaxPriceBar:",MaxPriceBar," MinPriceBar:",MinPriceBar);
}

/*
if EW3MARK = 1 and counter < EW3MARKBAR and (WaveAngle = 1 and Close[counter] < EW3 - NoisePips * Point 
or (WaveAngle = 2 and Close[counter] > EW3 + NoisePips * Point)) 
then // Wave 1 ended
{
EW4MARK=1;
break;
}
*/

End;

//Check if we have failed EW 3 and it falls bellow EW Wave 1
if (EW3MARK=1 and WaveAngle = 1 and Open < EW2)
or (EW3MARK=1 and WaveAngle = 2 and Open > EW2)
then
 {
Comment("\nEWTrend=Recalculating..",
"\nLast EW0=",TimeToStr(EW5MARKTIME),
"    ",EW5,
"\nLast EW1=",TimeToStr(EW1MARKTIME),
"    ",EW1,
"\nLast EW2=",TimeToStr(EW2MARKTIME),
"    ",EW2,
"\nLast EW3=",TimeToStr(EW3MARKTIME),
"    ",EW3,
"\nPivot                             ",Pivot,
"\nResistance Level I            ",ResistanceLevel1,
"\nSupport Level I                ",SupportLevel1,
"\nResistance Level II          ",ResistanceLevel2,
"\nSupport Level II              ",SupportLevel2,
"\nPrice Level                   ",PriceLevel,"%"
);
 EW0MARK=0;
 EW1MARK=0;
 EW2MARK=0;
 EW3MARK=0;
 EW4MARK=0;
 EW5MARK=0;
 ORDERMARK=0;
 for counter=1 to EW2MARKBAR
{
    if close[counter] = EW3
    then
    {
    DelArrow(time[counter] , Close[counter] + StopLoss / 2 * Point);
 DelArrow(time[counter] , Close[counter] - StopLoss / 2 * Point);
 break;
 }
 }

 if WaveAngle = 1 then SetArrow(time,Ask,251,Red);
 if WaveAngle = 2 then SetArrow(time,Bid,251,Red);
 LastEW5=EW5Price;
 LastEW1=EW1;
 LastEW2=EW2;
 LastEW3=EW3;
 //Print(TimeToStr(time),": ",Symbol," Elliot Wave 3 failed, recalculating EW0...");

 }

if EW3MARK = 1 and EW4MARK = 0 then
{
EWOscillator = iCustom("ElliotOscillator",EWPeriod,0,RetracementBars,MODE_FIRST,0);
EWLevel = iCustom("ElliotWaves",EWPeriod,0,RetracementBars,MODE_FIRST,0);
}

if EWOscillator != 0 and EWLevel != 0 and EW3MARK = 1 and EW4MARK = 0 then
{
//print("EW0MARK:",EW0MARK," EW1MARK:",EW1MARK," EW2MARK:",EW2MARK," EW3MARK:",EW3MARK," EW4MARK:",EW4MARK);
//Print(TimeToStr(time[0]),": EW1MARKBAR:",EW1MARKBAR," EW2MARKBAR:",EW2MARKBAR," EW3MARKBAR:",EW3MARKBAR," EW3MARKBAR=",EW3MARKBAR," EW4MARK:",EW4MARK);
Print(TimeToStr(time[0]),": EW3 START - Open:",Open," EW0:",EW5PRICE," EW1:",EW1," EW2:",EW2," EW3:",EW3," WaveAngle:",WaveAngle," Price Level:",PriceLevel," Last Price Level:",LastPriceLevel," Max/Min Level:",FiboLevel);
Print(TimeToStr(time[0]),": EW3 START - Pivot:",Pivot," Resistance Level I:",ResistanceLevel1," Support Level I:",SupportLevel1," Resistance Level II:",ResistanceLevel2," Support Level II:",SupportLevel2);
EW3ORDERMARK=0;
LastOp=0;

 if EW3 > Pivot 
 then
 { 
if EW3MARKBAR <= MaxBars then
DelArrow(EW3MARKTIME, EW3 + StopLoss / 2 * Point);
SetArrow(EW3MARKTIME, EW3 + StopLoss / 2 * Point,131,White);
DelArrow(EW3MARKTIME, EW3 + (StopLoss / 2 + NoisePips) * Point);

if EW3 > ResistanceLevel1 
and FiboLevel > 99 
and ResistanceLevel2 - ResistanceLevel1 < SupportLevel1 - SupportLevel2
and BullsAngle = 1
then
{
  SetArrow(EW3MARKTIME, EW3 + (StopLoss / 2 + NoisePips) * Point,246,White); //UP
  EW3ORDERMARK=1;
  LastOp=1;
}   
else
if EW3 > ResistanceLevel1 
and FiboLevel > 100 
and FiboLevel < 130 
then
{
  SetArrow(EW3MARKTIME, EW3 + (StopLoss / 2 + NoisePips) * Point,200,White); // UP
  EW3ORDERMARK=1;
  LastOp=2;
} 
else
if EW2 > SupportLevel1 
and FiboLevel > 80 
and FiboLevel < 130 
and PriceLevel > 65
then
{
  if Open > (MaxPrice + MinPrice) * 2 / 3
  or (MACDAngle = 2 and FiboLevel > 100)
  then
  {
   if PriceLevel > 87.5 // Murrey 7/8 support/resistance line
   //and FiboLevel < 112.5 // Murrey 8/8+1 support/resistance line
   and BullsAngle = 1
   and BearsAngle = 1
   then 
   {
  SetArrow(EW3MARKTIME, EW3 + (StopLoss / 2 + NoisePips) * Point,200,White); // UP
  EW3ORDERMARK=3;
  LastOp=3;
   }
   else 
   {
    if MA < LongMA
    then
    {
  SetArrow(EW3MARKTIME, EW3 + (StopLoss / 2 + NoisePips) * Point,200,White); // UNSTABLE UP
  EW3ORDERMARK=1;
  LastOp=4;
  }
  else
  {
  SetArrow(EW3MARKTIME, EW3 + (StopLoss / 2 + NoisePips) * Point,200,SkyBlue); // UNSTABLE DOWN, POSSIBLE UP
  EW3ORDERMARK=2;
  LastOp=5;
  };
   };
  }
  else
  if FiboLevel > 100 // Over Murrey 8/8 support/resistance line
  then
  {
  SetArrow(EW3MARKTIME, EW3 + (StopLoss / 2 + NoisePips) * Point,200,SkyBlue); // POSSIBLE UP
  EW3ORDERMARK=1;
  LastOp=6;
  }
  else
  if FiboLevel = 100 // Murrey 8/8 support/resistance line
  then
  {
  SetArrow(EW3MARKTIME, EW3 + (StopLoss / 2 + NoisePips) * Point,202,SkyBlue); // POSSIBLE RESIST DOWN
  EW3ORDERMARK=12;
  LastOp=7;
  };
} 
else 
if FiboLevel > 70 
and FiboLevel < 150 
and PriceLevel < 60
//and Bid > EW3 + Slippage * Point
then
{
  if (FiboLevel = 100) // Murrey 8/8 support/resistance line
  and MACDAngle = 1
  then
  {
  SetArrow(EW3MARKTIME, EW3 - (StopLoss / 2 + NoisePips) * Point,196,SkyBlue); //TEMP UP, REVERT TO DOWN
  EW3ORDERMARK=13;
  LastOp=8;
  }
  else
  {
  SetArrow(EW3MARKTIME, EW3 - (StopLoss / 2 + NoisePips) * Point,198,White); //UP
  EW3ORDERMARK=3;
  LastOp=9;
  }
} 
else
if PriceLevel > 65 
and MA < Open
then
{
  SetArrow(EW3MARKTIME, EW3 + (StopLoss / 2 + NoisePips) * Point,202,White); // DOWN
  EW3ORDERMARK=4;
  LastOp=10;
}; 
 }
 else
 { 
if EW3MARKBAR <= MaxBars then
DelArrow(EW3MARKTIME, EW3 - StopLoss / 2 * Point);
SetArrow(EW3MARKTIME, EW3 - StopLoss / 2 * Point,131,Violet);
DelArrow(EW3MARKTIME, EW3 - (StopLoss / 2 + NoisePips) * Point);
if EW3 < SupportLevel1 
and FiboLevel > 99 
and ResistanceLevel2 - ResistanceLevel1 < SupportLevel1 - SupportLevel2 
and BearsAngle = 2
then
   {
 SetArrow(EW3MARKTIME, EW3 + (StopLoss / 2 + NoisePips) * Point,248,Violet); // DOWN
 EW3ORDERMARK=11;
 LastOp=21;
   } 
else
if EW3 < SupportLevel1  
and FiboLevel < 130 
and FiboLevel > 100 
then
{
  SetArrow(EW3MARKTIME, EW3 + (StopLoss / 2 + NoisePips) * Point,202,Violet); // DOWN
  EW3ORDERMARK=11;
  LastOp=22;
} 
else
if EW2 < ResistanceLevel1 
and FiboLevel > 80 
and FiboLevel < 130 
and PriceLevel < -65
    then
{
  if Open < (MaxPrice + MinPrice) * 3 / 2
  or (MACDAngle = 2 and FiboLevel > 100)
  then
  {
   if PriceLevel < -87.5 // Murrey 7/8 support/resistance line
   //and FiboLevel < 112/5 // Murrey 8/8+1 support/resistance line
   and BullsAngle = 2
   and BearsAngle = 2
   then 
   {
  SetArrow(EW3MARKTIME, EW3 + (StopLoss / 2 + NoisePips) * Point,202,Violet); // DOWN
  EW3ORDERMARK=13;
  LastOp=23;
   }
   else
   {
    if MA > LongMA
    then
    {
  SetArrow(EW3MARKTIME, EW3 + (StopLoss / 2 + NoisePips) * Point,202,Violet); // UNSTABLE DOWN
  EW3ORDERMARK=11;
  LastOp=24;
}
else
  {
  SetArrow(EW3MARKTIME, EW3 + (StopLoss / 2 + NoisePips) * Point,202,OrangeRed); // UNSTABLE UP, POSSIBLE DOWN
  EW3ORDERMARK=12;
  LastOp=25;
  };  
   };
   
  }
  else
  if FiboLevel > 100 // Over Murrey 8/8 support/resistance line
  then
  {
  SetArrow(EW3MARKTIME, EW3 + (StopLoss / 2 + NoisePips) * Point,202,OrangeRed); // POSSIBLE DOWN
  EW3ORDERMARK=11;
  LastOp=26;
  }
  else
  if FiboLevel = 100 // Murrey 8/8 support/resistance line
  then
  {
  SetArrow(EW3MARKTIME, EW3 + (StopLoss / 2 + NoisePips) * Point,200,OrangeRed); // POSSIBLE RESIST AND UP
  EW3ORDERMARK=2;
  LastOp=27;
  };  
} 
else 
if FiboLevel > 70 
and FiboLevel < 150 
and PriceLevel > -60
//and Ask < EW3 - Slippage * Point
then
{
  if (FiboLevel = 100) // Murrey 8/8 support/resistance line
  and MACDAngle = 2
  then
  {
  SetArrow(EW3MARKTIME, EW3 + (StopLoss / 2 + NoisePips) * Point,198,OrangeRed); //TEMP DOWN, REVERT TO UP
  EW3ORDERMARK=3;
  LastOp=28;
  }
  else
  {
  SetArrow(EW3MARKTIME, EW3 + (StopLoss / 2 + NoisePips) * Point,196,Violet); //DOWN
  EW3ORDERMARK=13;
  LastOp=29;
  }
} 
else
if PriceLevel < -65 
and MA > Open
then
{
  SetArrow(EW3MARKTIME, EW3 + (StopLoss / 2 + NoisePips) * Point,200,Violet); // UP
  EW3ORDERMARK=14;
  LastOp=30;
}; 

 }
 EW4MARK=1;
 EW4MARKTIME=EW3MARKTIME;
 EW4MARKBAR=EW3MARKBAR;
}

if EW3MARK=1  
and ((WaveAngle = 1 and EW3 - Open > EW1 - EW2 )
or (WaveAngle = 2 and Open - EW3 > EW2 - EW1 ))
then
{
//Print(TimeToStr(time),": ",Symbol," Elliot Wave 3 retracement ended. Last EW3:",EW3," Last EW3 Time:",TimeToStr(EW3MARKTIME)," Order Stop:",TrailingStopPoint);
//Alert(TimeToStr(time),": ",Symbol," Elliot Wave 3 retracement ended. Last EW3:",EW3," Last EW3 Time:",TimeToStr(EW3MARKTIME)," Order Stop:",TrailingStopPoint);
Comment("\nEWTrend=Recalculating..",
"\nLast EW0=",TimeToStr(EW5MARKTIME),
"    ",EW5,
"\nLast EW1=",TimeToStr(EW1MARKTIME),
"    ",EW1,
"\nLast EW2=",TimeToStr(EW2MARKTIME),
"    ",EW2,
"\nLast EW3=",TimeToStr(EW3MARKTIME),
"    ",EW3,
"\nPivot                             ",Pivot,
"\nResistance Level I            ",ResistanceLevel1,
"\nSupport Level I                ",SupportLevel1,
"\nResistance Level II          ",ResistanceLevel2,
"\nSupport Level II              ",SupportLevel2,
"\nPrice Level                   ",PriceLevel,"%"
);
EW0MARK=0;
EW1MARK=0;
EW2MARK=0;
EW3MARK=0;
EW4MARK=0;
EW5MARK=0;
ORDERMARK=0;
 }


if prevbars > 0 and EW3ORDERMARK=99
    and Bars != prevbars
and ((PriceLevel > 0 and LastPriceLevel <= 0) 
  or (PriceLevel < 0 and LastPriceLevel >= 0))
//   and CCI < 200
then
{
 ENTRYPRICE=Open;
 if ParabolicSAR < Open then { ORDERANGLE=1; ENTRYPRICE=Pivot;MinTakeProfitPtS=ResistanceLevel2;};
 if ParabolicSAR > Open then { ORDERANGLE=11; ENTRYPRICE=Pivot;MinTakeProfitPtS=SupportLevel2;} 
 Trace = 1;
    //print(TimeToStr(time),": Trace:",Trace," ORDERMARK:",ORDERMARK," ORDERANGLE:",ORDERANGLE," Price: ",Ask," Commodity Channel Index ",CCI," Pivot ",Pivot," Resistance Level I ",ResistanceLevel1," Support Level I ",SupportLevel1," Resistance Level II ",ResistanceLevel2," Support Level II ",SupportLevel2," Price Level ",PriceLevel," Last Price Level ",LastPriceLevel);    
LastOp=0;
ORDERMARK=1;
ORDERCOUNT=0;
if WaveAngle = 1 then SARAngle = 1;
if WaveAngle = 2 then SARAngle = 2;
for counter = 1 to 10
Begin
tempval =iSAR(SARstep,SARmax,counter);
//print("Price:",Close[counter]," SAR:",tempval);
if (WaveAngle = 1 and tempval > Close[counter])
then
SARAngle = 2;
if (WaveAngle = 2 and tempval < Close[counter])
then
SARAngle = 1;
End;

 if WaveAngle = 1 then print(TimeToStr(time),": Support/Resistance cross at price:",Open," WaveAngle: UP SAR:",ParabolicSAR, " SARAngle:",SarAngle," PriceLevel: ",PriceLevel," LastPriceLevel: ",LastPriceLevel);
 if WaveAngle = 2 then print(TimeToStr(time),": Support/Resistance cross at price:",Open," WaveAngle: DOWN SAR:",ParabolicSAR, " SARAngle:",SarAngle," PriceLevel: ",PriceLevel," LastPriceLevel: ",LastPriceLevel);  
 Print(TimeToStr(time[0]),": Support/Resistance - Pivot:",Pivot," Resistance Level I:",ResistanceLevel1," Support Level I:",SupportLevel1," Resistance Level II:",ResistanceLevel2," Support Level II:",SupportLevel2);
 Print(" Support/Resistance - EW0MARK:",EW0MARK," EW1MARK:",EW1MARK," EW2MARK:",EW2MARK," EW3MARK:",EW3MARK," EW3MARKBAR=",EW3MARKBAR," EW4MARK:",EW4MARK," EW0:",EW5PRICE," EW1:",EW1," EW2:",EW2," EW3:",EW3);
     SetArrow(time,Open,254,Blue);

if WaveAngle = 1 
then
{ 
if EW0MARK = 1 
and EW1MARK=1
and EW2MARK=0
then
ORDERANGLE=2;

if EW0MARK = 1 
and EW1MARK=1
and EW2MARK=1
and EW3MARK=0
then
ORDERANGLE=23;

if EW0MARK = 1 
and EW1MARK=1
and EW2MARK=1
and EW3MARK=1
then
ORDERANGLE=4;
}

if WaveAngle = 2 
then
{ 
if EW0MARK = 1 
and EW1MARK=1
and EW2MARK=0
then
ORDERANGLE=21;

if EW0MARK = 1 
and EW1MARK=1
and EW2MARK=1
and EW3MARK=0
then
ORDERANGLE=22;

if EW0MARK = 1 
and EW1MARK=1
and EW2MARK=1
and EW3MARK=1
then
ORDERANGLE=3;
}
LastOp = 1;
}

if ORDERMARK > 9990
then
{
 ORDERANGLE=WaveAngle;
 if ORDERCOUNT > TradesCount 
    and EW3 <= Open
 then ORDERCOUNT = TradesCount;   
if WaveAngle = 1 and Open - TakeProfit * Point > EW1 then ORDERMARK = 1; // Additional Orders handling
if WaveAngle = 2 and Open + TakeProfit * Point < EW1 then ORDERMARK = 1; // Additional Orders handling

}
if WaveAngle = 1 then SARAngle = 1;
if WaveAngle = 2 then SARAngle = 2;
for counter = 1 to RetracementBars
Begin
tempval =iSAR(SARstep,SARmax,counter);
//print("Price:",Close[counter]," SAR:",tempval);
if (WaveAngle = 1 and tempval > Close[counter])
then
SARAngle = 2;
if (WaveAngle = 2 and tempval < Close[counter])
then
SARAngle = 1;
End;

if WaveAngle = 1 then MACDAngle = 1;
if WaveAngle = 2 then MACDAngle = 2;
for counter = 1 to RetracementBars
Begin
tempval=iMACD(RetracementBars/5,RetracementBars,RetracementBars/5,MODE_EMA,counter);
//print("MACD:",tempval);
if WaveAngle = 1
then
{
  if tempval > 0 and tempval < MACD then MACDAngle = 1;
  if tempval < 0 or tempval > MACD then MACDAngle = 2;
}  

if WaveAngle = 2 
then
{
  if tempval > 0 or tempval < MACD then MACDAngle = 1;
  if tempval < 0 and tempval > MACD then MACDAngle = 2;
}  
End;

ShortMACDAngle = MACDAngle;

if WaveAngle = 1 then MACDAngle = 1;
if WaveAngle = 2 then MACDAngle = 2;
for counter = 1 to RetracementBars
Begin
tempval=iMACD(RetracementBars,MaxBars,RetracementBars,MODE_EMA,counter);
//print("MACD:",tempval);
if WaveAngle = 1 
then
{
  if tempval > 0 and tempval < MACD then MACDAngle = 1;
//  if tempval < 0 or tempval > MACD then MACDAngle = 2;
  if tempval > MACD then MACDAngle = 2;
}  

if WaveAngle = 2 
then
{
  if tempval > 0 or tempval < MACD then MACDAngle = 1;
//  if tempval < 0 and tempval > MACD then MACDAngle = 2;
  if tempval > MACD then MACDAngle = 2;
}  
End;

MaxPriceBar = Highest (MODE_CLOSE,MaxBars+1, RetracementBars);
MinPriceBar = Lowest (MODE_CLOSE, MaxBars+1, RetracementBars);
MaxPrice = Close[MaxPriceBar];
MinPrice = Close[MinPriceBar];

     if WaveAngle = 1 then
     {
  BearsAngle=1;
  BullsAngle=1;
  for counter=1 to RetracementBars
  {
       tempval=iBearsPower(RetracementBars,MODE_HIGH,counter);
//          if tempval < 0 or tempval > Bears then BearsAngle=2;
          if tempval > Bears then BearsAngle=2;
   tempval=iBullsPower(RetracementBars,MODE_LOW,counter); 
//      if tempval < 0 or tempval > Bulls then BullsAngle=2;
      if tempval > Bulls then BullsAngle=2;
  }
 } 
     if WaveAngle = 2 then
     {
  BearsAngle=2;
  BullsAngle=2;
  for counter=1 to RetracementBars
  {
       tempval=iBearsPower(RetracementBars,MODE_HIGH,counter);
//          if tempval > 0 or tempval < Bears then BearsAngle=1;
          if tempval < Bears then BearsAngle=1;
   tempval=iBullsPower(RetracementBars,MODE_LOW,counter); 
//      if tempval > 0 or tempval < Bulls then BullsAngle=1;
      if tempval < Bulls then BullsAngle=1;
  }
} 

if EW3ORDERMARK > 0
  then
  {  
  ORDERCOUNT=0;
          ORDERMARK=1;
  if EW3ORDERMARK = 1 
//  and Bid > EW3 + Slippage * Point
//     and Open >= EW3
//  and Bid > EW3 + NoisePips * Point
  then 
  {
 ORDERANGLE=4;
      }  

  if EW3ORDERMARK = 2
//     and Open >= EW3
//  and Ask < EW3 - NoisePips * Point
  then 
  {
  ORDERANGLE = 3;    
      }  

  if EW3ORDERMARK = 3
//     and Open >= EW3
//  and Bid > EW3 + NoisePips * Point
  then 
  {
  ORDERANGLE = 2;    
      }  

  if EW3ORDERMARK = 4 
//  and Ask < EW3 - NoisePips * Point
  then 
  {
  ORDERANGLE = 22;
      }  
  if EW3ORDERMARK = 11 
//  and Ask < EW3 - Slippage * Point
//     and Open >= EW3
//  and Ask < EW3 - NoisePips * Point
  then 
  {
  ORDERANGLE = 23;    
      }  

  if EW3ORDERMARK = 12
//     and Open >= EW3
//  and Bid > EW3 + NoisePips * Point
  then 
  {
  ORDERANGLE = 22;  
      }  
      
  if EW3ORDERMARK = 13
//     and Open >= EW3
//  and Ask < EW3 - NoisePips * Point
  then 
  {
  ORDERANGLE = 21;  
      }  

  if EW3ORDERMARK = 14 
//  and Ask < EW3 - NoisePips * Point
  then 
  {
  ORDERANGLE = 3;    
      }  
  //EW3ORDERMARK=0; 
   }  

MaxPriceBar = Highest (MODE_CLOSE,MaxBars+1, MaxBars);
MinPriceBar = Lowest (MODE_CLOSE, MaxBars+1, MaxBars);
MaxPrice = Close[MaxPriceBar];
MinPrice = Close[MinPriceBar];

if EW2MARK = 1 and EW3MARK = 0 then
{
If WaveAngle = 1 
and Bid > EW2 + NoisePips * Point
and Bid > SupportLevel1 + NoisePips * Point
and ((EW2 - SupportLevel1 > 0 and (EW2 - SupportLevel1) / 2 < NoisePips * 2 / 2) or (SupportLevel1 - EW2 > 0 and (SupportLevel1 - EW2) / 2 < NoisePips * 2 / 2))
and EW1 - Bid > MinTakeProfit * Point + NoisePips * Point + Slippage
then
{
 ENTRYPRICE=SupportLevel1;
 ORDERMARK=1;
 SetArrow(time,Low,196,Violet);
 Print(TimeToStr(time),": ",Symbol," Elliot Wave 2 collision with Support Level 1 detected. Last EW2:",EW2," Last EW2 Time:",TimeToStr(EW2MARKTIME)," Recommended action: BUYLIMIT at ", ENTRYPRICE, " with T/P at ",EW1 - NoisePips * Point);
 Alert(TimeToStr(time),": ",Symbol," Elliot Wave 2 collision with Support Level 1 detected. Last EW2:",EW2," Last EW2 Time:",TimeToStr(EW2MARKTIME)," Recommended action: BUYLIMIT at ", ENTRYPRICE, " with T/P at ",EW1 - NoisePips * Point);
 Print(TimeToStr(time[0]),Symbol," : Elliot Wave 2 collision - Pivot:",Pivot," Resistance Level I:",ResistanceLevel1," Support Level I:",SupportLevel1," Resistance Level II:",ResistanceLevel2," Support Level II:",SupportLevel2);
}

If WaveAngle = 2 
and Ask < EW2 - NoisePips * Point
and Ask < SupportLevel1 - NoisePips * Point
and ((EW2 - SupportLevel1 > 0 and (EW2 - SupportLevel1) / 2 < NoisePips * 2 / 2) or (SupportLevel1 - EW2 > 0 and (SupportLevel1 - EW2) / 2 < NoisePips * 2 / 2))
and Ask - EW1 > MinTakeProfit * Point + NoisePips * Point + Slippage
then
{
 ENTRYPRICE=SupportLevel1;
 ORDERMARK=2;
 SetArrow(time,High,198,Violet);
 Print(TimeToStr(time),": ",Symbol," Elliot Wave 2 collision with Resistance Level 1 detected. Last EW2:",EW2," Last EW2 Time:",TimeToStr(EW2MARKTIME)," Recommended action: BUYLIMIT at ", ENTRYPRICE, " with T/P at ",EW1 - NoisePips * Point);
 Alert(TimeToStr(time),": ",Symbol," Elliot Wave 2 collision with Resistance Level 1 detected. Last EW2:",EW2," Last EW2 Time:",TimeToStr(EW2MARKTIME)," Recommended action: BUYLIMIT at ", ENTRYPRICE, " with T/P at ",EW1 - NoisePips * Point);
 Print(TimeToStr(time[0]),Symbol," : Elliot Wave 2 collision - Pivot:",Pivot," Resistance Level I:",ResistanceLevel1," Support Level I:",SupportLevel1," Resistance Level II:",ResistanceLevel2," Support Level II:",SupportLevel2);
}
}
}


/************************************ Aggressive Anti Stop Loss - revert to Take Profit ********************************/


If (CloseBadOrder = 2 and OrderRecovery=0) 
   and AntiStopLoss = 1
   and (CurTime-LastBadTime) > 300
   and Open <=MinPrice
   then
   // Compensating BUY order for last bad trade
 {
 LastOp = 3;
 BuyOp = 1;
 SellOp = 0;
  CloseBadOrder = 0; 
  OrderRecovery = 1;
 SetArrow(time,Bid,233,Yellow);
  exit;
 }


If (CloseBadOrder = 1 and OrderRecovery=0) 
   and (CurTime-LastBadTime) > 300
   // Compensating SELL order for last bad trade
   and Open <=MinPrice
   then
 {
 LastOp = 4;
 BuyOp = 0;
 SellOp = 1;
  CloseBadOrder = 0; 
  OrderRecovery = 1;
 SetArrow(time,Bid,234,Yellow);
  exit;
 }


/*********** Open Orders handling: Trailingstops, Delayed Orders Expire, Aggressive Anti Stop Loss logics ***************/

if OrderRecovery = 0 then TradesCount = 0;

if OrderRecovery = 0
and IsTradeAllowed then
for counter = 1 to TotalTrades
{
if (OrderValue(counter,VAL_SYMBOL) = Symbol)
then  // we have pending current currency orders, 
{
TradesCount = TradesCount + 1 ; // calculate trades for current market symbol
}

  OrderType = OrderValue(counter,VAL_TYPE);
    if  FreeMargin < 10
    and IsTesting then
// MetaTrader test do not close orders in with no money test mode
{
       Print("Out of money, I AM BROKEN:( Exiting..");
    If (OrderType = OP_SELL) then CloseOrder(OrderValue(counter,VAL_TICKET),OrderValue(counter,VAL_LOTS),PriceAsk,OrderValue(counter,VAL_SWAP),Yellow);
    If (OrderType = OP_BUY) then CloseOrder(OrderValue(counter,VAL_TICKET),OrderValue(counter,VAL_LOTS),PriceBid,OrderValue(counter,VAL_SWAP),Yellow);
          SetArrow(time,PriceAsk+BidStopPoints,77,Yellow);
   exit;    
  } 

if StopLoss = 0 then TrailingStopLoss = OrderValue(counter,VAL_OPENPRICE)
else TrailingStopLoss = OrderValue(counter,VAL_STOPLOSS);

   If (OrderType = OP_BUY) and OrderValue(counter,VAL_SYMBOL)=Symbol then
   {
// This is our buy order, lets check for prices

   if (TrailingStop) > 0 then
// We have Trailing Stop enabled, arrange our bids
      {
      // Here we check the trailing stop at open position.
      // Trailing stop ( Stop Loss) of the BUY position is being
      // kept at level 15 points below the market.
//            print("ParabolicSAR:",ParabolicSAR, " StopLossTrail:",TrailingStopLoss," MA:",MA);

      If (PriceBid - (TrailingStop + TrailingStep) * Point) > OrderValue(counter,VAL_OPENPRICE)
      // If the profit (current Bid-OpenPrice) more than TrailingStop pips
      // and the last StopLoss exceeds TrailingStep points from Trailingstop
      then
     {
         // we have won already not less than 'TrailingStop' pips!
            // move the trailing stop (Stop Loss) to the level 'TrailingStop' from the market
            StopLossTrail=TrailingStopLoss;
//            print("ParabolicSAR:",ParabolicSAR, " StopLossTrail:",StopLossTrail," MA:",MA);
            
            if Open - ((TrailingStep + TrailingStop) * Point) > OrderValue(counter,VAL_OPENPRICE)
               and StopLossTrail < OrderValue(counter,VAL_OPENPRICE)
               and Open + (TrailingStop * Point) >= OrderValue(counter,VAL_TAKEPROFIT)
   then
// We have won already take profit-trailingstop pips! Set Stop Loss to take profit minimum
   {
            ModifyOrder(OrderValue(counter,VAL_TICKET),OrderValue(counter,VAL_OPENPRICE),
                        OrderValue(counter,VAL_OPENPRICE) + (TrailingStop * Point),OrderValue(counter,VAL_TAKEPROFIT),Blue);
          SetArrow(time,PriceBid,105,Blue);
          exit;
                }        
else
            if ParabolicSAR -
Motivazione: