une stratégie commerciale basée sur la théorie des vagues d'Elliott - page 19

 
Eh bien, je ne pense pas ;). L'écart-type est l'écart quadratique du prix observé par rapport à la prévision. En d'autres termes, vous calculez la prévision, vous voyez ce que vous obtenez, vous le comparez à ce que la prévision est censée être et seulement ensuite vous tirez des conclusions. C'est l'une des raisons pour lesquelles le processus est itératif.
L'utilisation de l'indicateur intégré à MT4 signifie automatiquement que vous sélectionnez la moyenne mobile comme prix prévisionnel. Vous pouvez sélectionner autre chose. L'algorithme de calcul de la RMS est lui-même correct : la racine carrée de la somme des carrés divisée par le nombre de degrés de liberté.

Bonne chance et bonne chance avec les tendances.
 
Vladislav, d'après mes hypothèses énoncées à la page précédente, et qui n'ont pas encore été réfutées par vous, pour trouver la parabole optimale, nous cherchons les distances les plus courtes entre les points de la série de prix et cette même parabole (les longueurs des perpendiculaires tracées à partir des points de la série vers la parabole) en considérant que le champ des prix est potentiellement relatif à la parabole. Cela complique naturellement les calculs, car nous devons résoudre l'équation cubique. Je veux juste comprendre une fois de plus à quel point cette méthode de recherche de la parabole optimale est justifiée par rapport à la recherche de la parabole optimale par la méthode de régression, lorsque la somme des carrés des différences entre les points de la série de prix et la parabole au même moment est calculée ? Pourriez-vous donner une estimation en termes de praticité de la méthode de régression pour trouver la parabole optimale ? Avez-vous rejeté cette méthode à la suite de certaines recherches expérimentales pour certaines raisons (alors quelles raisons ?), ou êtes-vous arrivé à la conclusion que la méthode plus complexe consistant à trouver la parabole optimale donne des conclusions plus précises sur les zones d'inversion, alors qu'il n'y a pas de différence fondamentale entre les méthodes ? Après tout, à première vue, il est difficile de déterminer dans quelle mesure l'utilisation de différentes méthodes pour déterminer la parabole optimale affectera le résultat final. Bien sûr, je comprends que les coefficients des paraboles trouvés par différentes méthodes seront différents, mais j'aimerais comprendre de combien, et surtout, de combien les résultats finaux seront différents ?
 
En ce qui concerne la convergence - n'oubliez pas qu'il existe des termes de la série pour estimer l'erreur d'approximation - vous n'avez donc pas besoin d'un nombre infini de termes.

Vladislav, je voudrais également préciser si je comprends bien votre recommandation.
Nous vous donnons la formule de Taylor :

Considérons les dérivées de la parabole f(x)=Ax^2+B
f'(x)=2Ax,
f''(x)=2A,
f''(x)=0, toutes les dérivées à partir de la troisième et au-dessus se transforment en 0.
Alors, selon la formule de Taylor, nous avons une série constituée uniquement des trois premiers termes. Dans ce cas, le développement de la fonction f(x)=Ax^2+B dans la série de Taylor sera exact (c'est-à-dire que le dernier terme de l'erreur de développement devient nul). Ensuite, nous devons évaluer la qualité de l'approximation de la série de prix par la parabole optimale. Autrement dit, notre principale exigence est que la série d'erreurs d'approximation doit être convergente (c'est-à-dire que la somme des erreurs converge vers un nombre fini). Et nous pouvons le déterminer simplement en comparant l'erreur d'approximation calculée avec le troisième terme de l'expansion. Ai-je raison ou non ? Ainsi, pour choisir une parabole et l'échantillon lui-même, on utilise le critère selon lequel la RMS des erreurs d'approximation ne doit pas dépasser la valeur du troisième terme de la série, pour un échantillon de valeurs comprises dans l'intervalle de a à x ? Suivez-vous le même principe dans votre stratégie ou non ?
Au fait, il y a une certaine incohérence dans tout ça. Nous optimisons la parabole en utilisant la propriété de la potentialité des prix (par perpendiculaire à la parabole) et estimons les erreurs d'approximation de la manière habituelle.
Qu'est-ce qui ne va pas ici ? Comment concilier la recherche de la parabole optimale et l'estimation de l'erreur d'approximation ?
 
Revoyons tout ça - vous vous éloignez de la solution intégrale. Que la trajectoire soit une parabole découle de la potentialité du champ, mais d'où vient l'idée que je résous une équation cubique ? J'ai écrit - J'utilise des méthodes intégrales, dont les estimations tiennent compte des particularités du champ de potentiel - en réalité, cela ne fait que simplifier l'approche. Je vais maintenant vous poser quelques questions, auxquelles vous devez trouver une réponse par vous-même. Que cherchez-vous et sous quelle forme voulez-vous obtenir le résultat ? Je me suis fixé pour tâche de trouver la projection du promontoire. Par conséquent, il a fallu choisir une méthode d'approximation (à choisir raisonnablement) et une méthode d'estimation de l'erreur de cette approximation. Ces méthodes sont liées les unes aux autres. Veuillez me pardonner, mais je ne décrirai pas l'algorithme que j'ai développé et sur lequel mon système est basé, mais les principes de base, s'il vous plaît. Il s'agit donc ici de principes - la construction d'une projection (en fait, il s'agit d'une extrapolation, qui à son tour est basée sur l'approximation actuelle) ne fait que justifier un ordre de fonctions d'approximation, et ceci est à son tour une façon de définir les erreurs. À partir de considérations sur la potentialité du champ, nous déduisons l'ordre d'approximation et les lois fondamentales que notre approximation doit satisfaire, tout en estimant l'erreur maximale admissible à laquelle notre approximation peut encore être considérée comme adéquate. Lorsque vous commencerez vos recherches, vous serez confronté à une situation d'incertitude - le fait est que la base des approximations peut ne pas être sélectionnée de la seule manière (je pense que cela reflète la réalité qu'une tendance d'ordre supérieur peut être décomposée en tendances d'ordre inférieur, et vice versa - les tendances d'ordre inférieur peuvent devenir une tendance d'ordre supérieur) - ici vous avez besoin d'un critère de qualité, sur la base duquel vous pouvez choisir la meilleure approximation au sens de l'extrapolation (il peut y avoir plusieurs approximations, également bonnes au sens de l'extrapolation). J'ai choisi comme critère le minimum de l'énergie potentielle fonctionnelle (et c'est aussi une conséquence de la potentialité du champ de prix). Comment construire des approximations - vous avez déjà compris qu'il s'agit d'une forme quadratique - vous pouvez chercher une parabole, ou vous pouvez chercher une autre façon - pensez-y. Si vous cherchez une parabole (ce qui n'est pas mon cas), vous pouvez utiliser l'algorithme de l'écart-type de l'offre standard - il faut alors soustraire les prix réels des valeurs de la parabole. Ensuite, vous avez besoin de trois points pour construire la parabole - et vous devrez probablement utiliser une approximation spline par des fonctions quadratiques - car il n'est pas certain que tous vos prix se situent sur la même parabole pendant toute la durée de l'échantillon. Vous pouvez également faire une approximation avec un muvin - vous devez estimer, cela pourrait être mieux. Et ensuite, estimez l'intervalle de confiance. Je pense que les lignes de Bolinger peuvent être considérées comme l'intervalle de confiance ici. En général, il y a beaucoup de questions. Bien que cette approche vous permette d'utiliser certains des algorithmes déjà disponibles. Plus loin - une fois que vous avez choisi une approximation, vous pouvez continuer dans le futur cette trajectoire (plus vous allez loin, moins le résultat est fiable). Je fais aussi ce que je fais - je choisis une période d'approximation (pas tout l'échantillon, mais environ 2/3, j'extrapole le dernier tiers et je le compare avec les prix réels obtenus, s'il ne sort pas de l'intervalle de confiance, alors j'utilise cette approximation pour d'autres extrapolations, mais ceci est lié à la mise en œuvre et aux méthodes d'augmentation de la stabilité des algorithmes itératifs).


Bonne chance et bonne chance avec les tendances.
 
bon article :)
 
Privet vsem,

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

Neskol'ko moix idej dlia na4ala :

1) Au tout début istoriji opredelit' v kakuju toru cena ili FLAT
2) si 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 lookit s indikator MT4 v istoriji ot Elliot Wave 1 na4ala do 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/

Le résultat de l'évaluation de l'indicateur de performance de l'entreprise n'a pas été pris en compte dans la nouvelle version de MT4 comme indicateur standard :)
 
Donc, en ce qui concerne les principes, la construction d'une projection (en fait, il s'agit d'une extrapolation, qui à son tour est basée sur l'approximation actuelle) justifie simplement l'ordre des fonctions d'approximation, et c'est à son tour une façon de déterminer les erreurs.

Vous faites donc probablement ce qui suit.
Étape 1. Prenez un échantillon
Étape 2. Approchez-le avec une voie de régression linéaire
Étape 3. Trouvez les erreurs d'approximation.
Étape 4. Analysez le graphique des erreurs. On peut supposer que l'ordre de la fonction d'approximation devrait être plus élevé ou que l'échantillon donné ne peut être approximé par aucune fonction continue si la série d'erreurs diverge ou présente de fortes déviations visibles à l'œil nu qui sortent de l'intervalle de confiance acceptable (l'algorithme d'automatisation du calcul n'est pas encore complètement clair).
Étape 5. Répétez les étapes 1-4 pour l'approximation par une parabole (ou autre chose)
Étape 6. Évaluez les erreurs ; si les erreurs dépassent une limite raisonnable, vous éliminez simplement cet échantillon. Si le graphe d'erreurs a une structure raisonnable, alors nous stockons les informations sur l'échantillonnage, la méthode d'approximation et les informations supplémentaires sur les fonctions d'approximation dans un tableau.
Étape 7. Ensuite, après avoir essayé à plusieurs reprises tous les échantillons possibles et avoir cherché les variantes optimales des fonctions d'approximation pour chaque échantillon, nous nous arrêtons aux échantillons qui satisfont nos exigences de manière extrême. Il est aussi naturellement souhaitable d'utiliser la méthode d'approximation des fonctions que vous recommandez non pas pour l'ensemble de l'échantillon, mais seulement pour les 2/3, en laissant le dernier tiers pour tester les résultats de l'approximation (c'est une suggestion très précieuse !).
Étape 8. Dessinez des approximations d'extremum sur le graphique des prix avec une continuation dans le futur. Il est naturel qu'un intervalle de confiance soit tracé pour chaque approximation.
Étape 9. On voit ainsi où les limites des intervalles se croisent. Ensuite, nous définissons les dates approximatives.
Étape 10. Pendant l'approche des prix vers les points de retournement, nous calculons la probabilité de renversement de tendance en utilisant la méthode d'estimation de l'erreur intégrale. Il sera probablement nécessaire de faire la moyenne des estimations des pivots pour tous les canaux d'approximation. Pour le canal de régression linéaire, il sera également nécessaire de calculer le coefficient de Hearst pour l'avoir comme paramètre supplémentaire. Il est également bon d'examiner les niveaux de Murray. Ainsi, nous avons une forte probabilité de prendre une décision sur le placement des ordres en attente et la détermination des stops avec un risque minimal.
Bien sûr, le conseiller expert qui calculera tout cela sera très étendu (vous avez dit qu'il contient 6000 lignes) ! Et jusqu'à présent, tout n'est pas clair en termes de prise de décision automatique pour chacun des échantillons. Eh bien, je pense que vous devez juste commencer à essayer de programmer cet algorithme, et ensuite, au fur et à mesure que vous expérimentez, vous pouvez trouver quelque chose qui est difficile à comprendre même à un niveau théorique, mais qui deviendra clair de lui-même au cours de l'expérience. Et en effet, le temps de calcul sera assez important. Vous avez dit que les premières variantes ont fonctionné pendant 30-40 minutes sur une machine faible. Eh bien, sur un P4 2,4 GHz, vous devez vous attendre à un temps de calcul d'environ 10 minutes.

Au sujet des méthodes d'approximation, j'ai trouvé le tutoriel intéressant suivant.
 
Correct. Je pense que vous découvrirez le reste au cours de la mise en œuvre de l'algorithme.

Puisque vous n'avez pas besoin de la parabole elle-même, vous pouvez faire une approximation des dérivées tout de suite. Le coefficient de régression est ce dont vous avez besoin (d'où la série de Taylor ;) ). Ensuite, la forme de la trajectoire n'a plus d'importance - l'essentiel est d'estimer correctement l'intervalle de confiance. Veuillez lire attentivement la documentation recommandée, elle contient suffisamment d'informations.

Bonne chance et bonnes tendances.
 
Correct.....

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

Votez 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 -