a trading strategy based on Elliott Wave Theory - page 19

New comment
 
Well, I don't think so ;). Standard deviation is the RMS (root-mean-square deviation) of the observed price from the forecast. That is, you calculate the forecast, see what you get, compare it to what the forecast was supposed to be and then draw your conclusions. This is one of the reasons why the process is iterative.
Using the indicator built in MT4 will automatically mean that you select the moving average as the forecast price. You can select something else. The algorithm for calculating the RMS itself is correct: the square root of the sum of squares divided by the number of degrees of freedom.

Good luck and good luck with the trends.
 
Vladislav, judging by my assumptions stated on the previous page, and which have not been refuted by you yet, in order to find the optimal parabola we look for the shortest distances from price series points to this very parabola (the length of perpendiculars drawn from series points to the parabola) assuming that the price field is potentially relative to the parabola. This understandably complicates the calculations, because we have to solve the cubic equation. I just want to understand once again how much this method of finding the optimal parabola is justified in comparison to finding the optimal parabola by the regression method, when the sum of squares of differences between price series points and the parabola at the same point in time is calculated? Could you give an estimate in terms of the practicality of the regression method for finding the optimal parabola? Was this method rejected by you as a result of some experimental investigations for some reasons (then what reasons?), or did you come to a conclusion that the more complex method of finding the optimal parabola yields more accurate conclusions about the reversal areas, while there is no fundamental difference between the methods? After all, at first glance it is difficult to determine how much difference using different methods to determine the optimal parabola will affect the final result. Of course I understand that coefficients of parabolas found by different methods will differ, but I would like to understand how much, and even more importantly, how much more the final results will differ?
 
Regarding convergence - don't forget there are terms of the series to estimate the approximation error - so you don't need an infinite number of terms.

Vladislav, I would also like to clarify if I understand your recommendation correctly.
Let us give you Taylor formula:

Consider derivatives of parabola f(x)=Ax^2+B
f'(x)=2Ax,
f''(x)=2A,
f''(x)=0, all derivatives from third and above turn to 0.
Then according to Taylor formula we have series consisting only of first three terms. In this case the expansion of the function f(x)=Ax^2+B in the Taylor series will be exact (i.e. the last term for the expansion error turns to zero). Next, we need to evaluate the quality of approximation of the price series by the optimal parabola. That is, our main requirement is that the series of errors of approximation must be convergent (i.e. the sum of errors converges to a finite number). And we can determine this simply by comparing the calculated error of approximation with the third term of expansion. Am I right or not? So when choosing a parabola and the sample itself, we use the criterion that the RMS of approximation errors should not exceed the value of the third term of the series, for a sample of values lying in the interval from a to x? Do you follow the same principle in your strategy or not?
By the way, there is some inconsistency in this. We optimize the parabola using the property of price potentiality (through perpendicular to the parabola) and estimate approximation errors in the usual way.
What is wrong here? How can we reconcile finding the optimal parabola and estimating the approximation error?
 
Let's go over it again - you're getting away from the integral solution. That the trajectory is a parabola follows from the potentiality of the field, but where did you get the idea that I am solving a cubic equation? I wrote - I use integral methods, estimates of which take into account peculiarities of the potential field - really it just simplifies the approach. Now I will ask you a couple of questions, which you need to find an answer for yourself. What are you looking for and in what form do you want to get the result? I set for myself the task of finding the projection of the headland. Consequently, it was necessary to choose a method of approximation (to choose reasonably) and a method of estimation of error of this approximation. These methods are related to each other. Please forgive me, but I won't describe the algorithm I've developed and my system is based on, but the basic principles, please. So here about principles - construction of a projection (actually it is extrapolation, which in turn is based on the current approximation) just substantiates an order of approximating functions, and this in turn is a way to define errors. From considerations of field potentiality, we infer the order of approximation and the basic laws that our approximation must satisfy, while also estimating the maximum permissible error at which our approximation can still be considered adequate. When you start investigations, you will face a situation of some uncertainty - the thing is that the basis for approximations may not be selected in the only way (I think it reflects the reality that a higher order trend may be broken down into lower order trends, and vice versa - lower order trends may become a higher order trend) - here you need a quality criterion, based on which you may choose the best approximation in extrapolation sense (there may be several approximations, equally good in the extrapolation sense). I have chosen as such a criterion the minimum of the potential energy functional (and this is also a consequence of the potentiality of the price field). How to build approximations - you've already figured out that it's a quadratic form - you can look for a parabola, or you can look for another way - think about it. If you look for a parabola (I don't), you can use the standard deviation algorithm from the standard supply - then you have to subtract real prices from the parabola values. And then you need three points to build the parabola - and you'll probably have to use spline approximation by quadratic functions - because it's not certain that all your prices will lie on the same parabola for the entire sampling period. You can also approximate with a muvin - you need to estimate, it might be better. And then estimate the confidence interval. I think the Bolinger lines can be taken as the confidence interval here. In general there are quite a lot of questions. Although this approach will give you an opportunity to use some of the algorithms that are already available. Further - once you have chosen an approximation, you can continue into the future this trajectory (the further you go, the less reliable the result). I also do what I do - I choose approximation period (not the whole sample, but about 2/3, extrapolate the last third and compare it with real prices obtained, if it doesn't fall out of confidence interval, then I use this approximation for further extrapolations, but it belongs to implementation and methods of increasing stability of iterative algorithms).


Good luck and good luck with the trends.
 
good post :)
 
Privet vsem,

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

Neskol'ko moix idej dlia na4ala:

1) At the very beginning istoriji opredelit' v kakuju toru cena ili FLAT
2) if 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 "basic" Elliot Wave patterns 1-2-3 i 1-2-3-4-5 + A-B-C volny after okon4anija dvizenija ceny(trend)
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 from Elliot Wave 1 na4ala to 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/

V rezultat kod indikatora patom mozno podkrutit' k novojiji versi MT4 kak standartnyj indikator :)
 
So about principles - building a projection (actually it's an extrapolation, which in turn is based on the current approximation) just grounds the order of approximating functions, and this in turn is a way of determining the errors.

So you probably do the following.
Step 1. Take a sample
Step 2. Approximate it with a linear regression channel
Step 3. Find approximation errors.
Step 4. Analyze the graph of errors. We get the supposition that the order of approximating function should be higher or the given sample cannot be approximated by any continuous function at all if the error series diverges or has some strong deviations visible to the eye which fall out of the acceptable confidence interval(the calculation automation algorithm is not completely clear yet).
Step 5. Repeat steps 1-4 for approximation by a parabola (or something else)
Step 6. Evaluate the errors; if the errors exceed a reasonable limit, you simply discard this sample. If the error graph has some reasonable structure, then we store the information about sampling, approximation method and additional information about approximating functions in some array.
Step 7. Then, having repeatedly tried all possible samples and having searched for the optimal variants of approximating functions for each sample, we stop at those samples which satisfy our requirements in the extreme way. It is also naturally desirable to use your recommended method of approximating functions not for the entire sample, but only for 2/3, leaving the last third to test the approximation results (this is a very valuable suggestion!).
Step 8. Draw extremum approximations on the price chart with continuation into the future. It is natural that a confidence interval is plotted for each approximation.
Step 9. Thus we see where the limits of intervals intersect. Then we define the approximate dates.
Step 10. During the price approach to the turning points, we calculate the probability of trend reversal using the integral error estimation method. It will probably be necessary to average the pivot estimates for all approximation channels. For the linear regression channel it will also be necessary to calculate the Hearst coefficient to have it as an additional parameter. It is also good to look at the Murray levels. Thus, we have a high probability of making a decision about placing pending orders and determination of stops with minimal risk.
Of course, the Expert Advisor that will calculate all that will be very extensive (you said it contains 6000 lines)! And so far not everything is clear in terms of automatic decision making for each of the samples. Well, I think you just need to start trying to program this algorithm, and then as you experiment, you can figure out something that is difficult to understand even on a theoretical level, but that will become clear by itself during the experiment. And indeed the calculation time will be quite significant. You said that the first variants worked for 30-40 minutes on a weak machine. Well then on a P4 2.4 GHz you should expect about 10 minutes computation time.

On the subject of approximation methods I found the following interesting tutorial.
 
Correct. I think you will figure out the rest in the process of implementing the algorithm.

Since you don't need the parabola itself, you can approximate the derivatives right away. The regression coefficient is what you need (hence the Taylor series ;) ). Then you won't care what the shape of the trajectory is - the main thing is to correctly estimate the confidence interval. Please read carefully the recommended literature, it contains enough information.

Good luck and good trends.
 
Correct.....

Got it... :)
 
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 -
1...121314151617181920212223242526...309
New comment