This one is gonna be a rant on waves and the behavior of the funny guys.

Calling things symmetrical would be a little bit harsh, but the rhythm of the market more or less remains the same.

Take a look at the following two 5-wave structures.

Although they are certainly not identical, they have commonalities. Three attempts to take the price as high as possible is one of these. In both cases, 2 out of the 3 peaks managed to achieve overdrive prints on the stochastic bars. Both wave structures had #4 undercutting #2 which speaks of a corrective wave structure (by this I mean you should start fading heavily by the time wave 5 is up). In both cases, wave 5 fell short of the overall peak, and they were less than 5 hours long.

Now, let’s discuss for a moment the deep break and why none of that move is connected or marked as part of a structure. They aren’t.

The volatility whip was utilized by some institution smelling funny guys to take over as many longs as were possible and make a killing on the 10% move that transpired in about 6 hours – about one session’s length.

The volatility whip is a thrown up ball, there are no rules other than the idea of making a measurement on what the downside volatility versus the upside volatility relates to each other on a current full throttle.

This institution spotted the short term opportunity: wave structure over with, 10% score on short notice pending, all they needed to do was serving as an amplifier, plus putting a lot of orders out at & below the 30% line.

My assumption for generating a very efficient “trending” move is having a program run that gives every fill at market in one direction. It takes a lot of capital to do this, no doubt. There are about 10 banks in the world that have the funds.

This overwhelming move knocks out everyone on the way down from their longs -> they become taken over by the bank, showing an ever increasing draw down, then they hit their target area that should be strategically placed beyond a lump of orders (stops) that were left out for good measure.

This is by when the auto fill program (in this case auto buy) gets turned off. Appreciate that they cannot exceed the demand on the way down, only match it, so the down move in this case was an “aid” to escort price into their own net. They will have a bottom heavy averaged down entry price and a ghost print on the chart that others would start drawing trend lines onto.

The overwhelming buy is a notch more aggressive, it has to also front run the orders, getting other routines excited and wanting to interact.

It does help the cause that the liquidity is relatively light in the cluelessness of what is happening. A big news event can help their cause, no doubt.

The major puzzle is now, that the 5-wave structure is over with, would they bother to mirror their own cash cow Vol Whip event this time?

Oh, the arrow for hedging? I lifted it from my TOS era. Don’t quite remember how I came up with the expression, but it works.

diff[i] = 100 - (75 - (stoch9[i] - (88 - ChoppinessIndex(14,i)))) * .8;

if (diff[i]<63 && diff[i+1]>63 && ChoppinessIndex(14,i)>34 && Period()==30 && iStochastic(symbol,0,9,3,3,MODE_SMA,0,MODE_SIGNAL,i+1)<80) {downcross[i]=High[i]+40*Point; downcross2[i]=High[i]+40*Point;}

…

4H Doji Lines (any time frame) for you, for you’ve been a good sport

//+------------------------------------------------------------------+
//|                                                4H DOJI Lines.mq4 |
//|                                         Copyright 2019, Macdulio |
//+------------------------------------------------------------------+
#property copyright   "2019, Macdulio"
#property link        "https://forexfore.blog"
#property description "4H DOJI Lines"

#include <stdlib.mqh>
extern double Leverage = 1.5;
#property indicator_chart_window
#property indicator_buffers 30
#property indicator_color1 Black
#property indicator_color2 Yellow
extern double AF=1.3;
extern double LT=60;
extern int maxlines = 10; 
extern int displaylength = 36;     
extern int       MinLengthOfUpTail=1; //candle with upper tail equal or more than this will show up
extern int       MinLengthOfLoTail=1; //candle with lower tail equal or more than this will show up
extern double    MaxLengthOfBody=30; //candle with body less or equal with this will show up
     
//---- input parameters for dragonfly doji
extern int       MaxLengthOfUpTail1=160; //candle with upper tail equal or more than this will show up
extern int       MinLengthOfLoTail1=160; //candle with lower tail equal or more than this will show up
extern double    MaxLengthOfBody1=30; //candle with body less or equal with this will show up

//---- input parameters for gravestone doji
extern int       MinLengthOfUpTail2=160; //candle with upper tail equal or more than this will show up
extern int       MaxLengthOfLoTail2=160; //candle with lower tail equal or more than this will show up
extern double    MaxLengthOfBody2=30; //candle with body less or equal with this will show up
double pt=0.00001;
double lines[];
double mid[];

double line1[];
double line2[];
double line3[];
double line4[];
double line5[];
double line6[];
double line7[];
double line8[];
double line9[];
double line10[];
double line11[];
double line12[];
double line13[];
double line14[];
double line15[];

double line16[];
double line17[];
double line18[];
double line19[];
double line20[];
double line21[];
double line22[];
double line23[];
double line24[];
double line25[];
double line26[];
double line27[];
double line28[];
double line29[];
double line30[];

double vbru[];

string TimeFrame;
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
  {
//---- indicators
   SetIndexBuffer(0,line1);
   SetIndexBuffer(1,line2);
   SetIndexBuffer(2,line3);
   SetIndexBuffer(3,line4);
   SetIndexBuffer(4,line5);  
   SetIndexBuffer(5,line6);
   SetIndexBuffer(6,line7);
   SetIndexBuffer(7,line8);
   SetIndexBuffer(8,line9);
   SetIndexBuffer(9,line10);
   SetIndexBuffer(10,line11);  
   SetIndexBuffer(11,line12);   
   SetIndexBuffer(12,line13);
   SetIndexBuffer(13,line14);
   SetIndexBuffer(14,line15);  
   
   SetIndexBuffer(15,line16);
   SetIndexBuffer(16,line17);
   SetIndexBuffer(17,line18);
   SetIndexBuffer(18,line19);
   SetIndexBuffer(19,line20);  
   SetIndexBuffer(20,line21);
   SetIndexBuffer(21,line22);
   SetIndexBuffer(22,line23);
   SetIndexBuffer(23,line24);
   SetIndexBuffer(24,line25);
   SetIndexBuffer(25,line26);  
   SetIndexBuffer(26,line27);   
   SetIndexBuffer(27,line28);
   SetIndexBuffer(28,line29);
   SetIndexBuffer(29,line30);  
   
                
   SetIndexStyle(0,DRAW_LINE,EMPTY,9,indicator_color1);
   SetIndexStyle(1,DRAW_LINE,EMPTY,9,indicator_color1);
   SetIndexStyle(2,DRAW_LINE,EMPTY,9,indicator_color1);     
   SetIndexStyle(3,DRAW_LINE,EMPTY,9,indicator_color1);
   SetIndexStyle(4,DRAW_LINE,EMPTY,9,indicator_color1);
   SetIndexStyle(5,DRAW_LINE,EMPTY,9,indicator_color1);  
   SetIndexStyle(6,DRAW_LINE,EMPTY,9,indicator_color1);
   SetIndexStyle(7,DRAW_LINE,EMPTY,9,indicator_color1);
   SetIndexStyle(8,DRAW_LINE,EMPTY,9,indicator_color1);     
   SetIndexStyle(9,DRAW_LINE,EMPTY,9,indicator_color1);
   SetIndexStyle(10,DRAW_LINE,EMPTY,9,indicator_color1);
   SetIndexStyle(11,DRAW_LINE,EMPTY,9,indicator_color1);
   SetIndexStyle(12,DRAW_LINE,EMPTY,9,indicator_color1);     
   SetIndexStyle(13,DRAW_LINE,EMPTY,9,indicator_color1);
   SetIndexStyle(14,DRAW_LINE,EMPTY,9,indicator_color1);
   
   SetIndexStyle(15,DRAW_LINE,EMPTY,5,indicator_color2);
   SetIndexStyle(16,DRAW_LINE,EMPTY,5,indicator_color2);
   SetIndexStyle(17,DRAW_LINE,EMPTY,5,indicator_color2);     
   SetIndexStyle(18,DRAW_LINE,EMPTY,5,indicator_color2);
   SetIndexStyle(19,DRAW_LINE,EMPTY,5,indicator_color2);
   SetIndexStyle(20,DRAW_LINE,EMPTY,5,indicator_color2);  
   SetIndexStyle(21,DRAW_LINE,EMPTY,5,indicator_color2);
   SetIndexStyle(22,DRAW_LINE,EMPTY,5,indicator_color2);
   SetIndexStyle(23,DRAW_LINE,EMPTY,5,indicator_color2);     
   SetIndexStyle(24,DRAW_LINE,EMPTY,5,indicator_color2);
   SetIndexStyle(25,DRAW_LINE,EMPTY,5,indicator_color2);
   SetIndexStyle(26,DRAW_LINE,EMPTY,5,indicator_color2);
   SetIndexStyle(27,DRAW_LINE,EMPTY,5,indicator_color2);     
   SetIndexStyle(28,DRAW_LINE,EMPTY,5,indicator_color2);
   SetIndexStyle(29,DRAW_LINE,EMPTY,5,indicator_color2);
   

   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit()
  {
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start()
  {
   string symbol = Symbol();
   int      i,pos,c_b=IndicatorCounted();;
  ArrayResize(lines, maxlines);
 
  ArrayInitialize(lines, 0);

  ArrayResize(line1, 100);
  ArrayInitialize(line1, EMPTY_VALUE);  
  ArrayResize(line2, 100);
  ArrayInitialize(line2, EMPTY_VALUE);  
  ArrayResize(line3, 100);
  ArrayInitialize(line3, EMPTY_VALUE);    
  ArrayResize(line4, 100);
  ArrayInitialize(line4, EMPTY_VALUE);  
  ArrayResize(line5, 100);
  ArrayInitialize(line5, EMPTY_VALUE);  
  ArrayResize(line6, 100);
  ArrayInitialize(line6, EMPTY_VALUE);  
  ArrayResize(line7, 100);
  ArrayInitialize(line7, EMPTY_VALUE);    
  ArrayResize(line8, 100);
  ArrayInitialize(line8, EMPTY_VALUE);    
  ArrayResize(line9, 100);
  ArrayInitialize(line9, EMPTY_VALUE);    
  ArrayResize(line10, 100);
  ArrayInitialize(line10, EMPTY_VALUE);  
  ArrayResize(line11, 100);
  ArrayInitialize(line11, EMPTY_VALUE);    
  ArrayResize(line12, 100);
  ArrayInitialize(line12, EMPTY_VALUE);    
  ArrayResize(line13, 100);
  ArrayInitialize(line13, EMPTY_VALUE);      
  ArrayResize(line14, 100);
  ArrayInitialize(line14, EMPTY_VALUE);  
  ArrayResize(line15, 100);
  ArrayInitialize(line15, EMPTY_VALUE);  
  
  ArrayResize(line16, 100);
  ArrayInitialize(line16, EMPTY_VALUE);  
  ArrayResize(line17, 100);
  ArrayInitialize(line17, EMPTY_VALUE);  
  ArrayResize(line18, 100);
  ArrayInitialize(line18, EMPTY_VALUE);    
  ArrayResize(line19, 100);
  ArrayInitialize(line19, EMPTY_VALUE);  
  ArrayResize(line20, 100);
  ArrayInitialize(line20, EMPTY_VALUE);  
  ArrayResize(line21, 100);
  ArrayInitialize(line21, EMPTY_VALUE);  
  ArrayResize(line22, 100);
  ArrayInitialize(line22, EMPTY_VALUE);    
  ArrayResize(line23, 100);
  ArrayInitialize(line23, EMPTY_VALUE);    
  ArrayResize(line24, 100);
  ArrayInitialize(line24, EMPTY_VALUE);    
  ArrayResize(line25, 100);
  ArrayInitialize(line25, EMPTY_VALUE);  
  ArrayResize(line26, 100);
  ArrayInitialize(line26, EMPTY_VALUE);    
  ArrayResize(line27, 100);
  ArrayInitialize(line27, EMPTY_VALUE);    
  ArrayResize(line28, 100);
  ArrayInitialize(line28, EMPTY_VALUE);      
  ArrayResize(line29, 100);
  ArrayInitialize(line29, EMPTY_VALUE);  
  ArrayResize(line30, 100);
  ArrayInitialize(line30, EMPTY_VALUE);  
  
    ArrayResize(vbru, Bars);
   ArrayInitialize(vbru, 0); 
 
    ArrayResize(mid, Bars);
   ArrayInitialize(mid, 0);     
 


   pos=0;
  
 for (i=500; i>=0; i--) 
    {
    
     
       if(iHigh(NULL,240,i)-iClose(NULL,240,i)>=MinLengthOfUpTail*pt && iClose(NULL,240,i)-iLow(NULL,240,i)>=MinLengthOfLoTail*pt  && MathAbs(iClose(NULL,240,i)-iOpen(NULL,240,i))<=MaxLengthOfBody*pt && vbru[i+1]==0) vbru[i]=(iOpen(NULL,240,i)+iClose(NULL,240,i))/2+.000042;
       if(iHigh(NULL,240,i)-iClose(NULL,240,i)<=MaxLengthOfUpTail1*pt && iClose(NULL,240,i)-iLow(NULL,240,i)>=MinLengthOfLoTail1*pt  && MathAbs(iClose(NULL,240,i)-iOpen(NULL,240,i))<=MaxLengthOfBody1*pt && vbru[i+1]==0) vbru[i]=(iOpen(NULL,240,i)+iClose(NULL,240,i))/2+.000042;
       if(iHigh(NULL,240,i)-iClose(NULL,240,i)>=MinLengthOfUpTail2*pt && iClose(NULL,240,i)-iLow(NULL,240,i)<=MaxLengthOfLoTail2*pt  && MathAbs(iClose(NULL,240,i)-iOpen(NULL,240,i))<=MaxLengthOfBody2*pt && vbru[i+1]==0) vbru[i]=(iOpen(NULL,240,i)+iClose(NULL,240,i))/2+.000042;
    
   
     }
         


  for (i=1; i<=250; i++)
   {
        if (vbru[i]>0){  mid[pos]= vbru[i]; pos=pos+1;}
   }
    
 
deletetxt1("Happy");

i=0;
   while(i<maxlines && pos>0)        
            {
               if (i==pos) break;
               if (mid[i]!=EMPTY_VALUE) lines[i]=mid[i];
               i++;
            }

   for (i=0; i<=displaylength-1; i++) {
   

   
      if (lines[0]>0) {line1[i]=lines[0]; line16[i]=lines[0];}
      if (lines[1]>0) {line2[i]=lines[1]; line17[i]=lines[1];}
      if (lines[2]>0) {line3[i]=lines[2]; line18[i]=lines[2];}
      if (lines[3]>0) {line4[i]=lines[3]; line19[i]=lines[3];}
      if (lines[4]>0) {line5[i]=lines[4]; line20[i]=lines[4];}
      if (lines[5]>0) {line6[i]=lines[5]; line21[i]=lines[5];}
      if (lines[6]>0) {line7[i]=lines[6]; line22[i]=lines[6];}
      if (lines[7]>0) {line8[i]=lines[7]; line23[i]=lines[7];}                
      if (lines[8]>0) {line9[i]=lines[8]; line24[i]=lines[8];}
      if (lines[9]>0) {line10[i]=lines[9]; line25[i]=lines[9];}  
      if (lines[10]>0) {line11[i]=lines[10]; line26[i]=lines[10];}
      if (lines[11]>0) {line12[i]=lines[11]; line27[i]=lines[11];}
      if (lines[12]>0) {line13[i]=lines[12]; line28[i]=lines[12];}
      if (lines[13]>0) {line14[i]=lines[13]; line29[i]=lines[13];}
      if (lines[14]>0) {line15[i]=lines[14]; line30[i]=lines[14];}
      
      
      
     if (i==6) {ObjectCreate("Happygail"+i, OBJ_RECTANGLE, 0,  Time[6], line1[i]+160*Point, Time[2], line1[i]-160*Point);
  ObjectSetInteger(0,"Happygail"+i,OBJPROP_COLOR,clrBlue);
  ObjectSet("Happygail"+i,OBJPROP_BACK,0);
  ObjectSet("Happygail"+i,OBJPROP_WIDTH,5);
  
  ObjectCreate("Happybail"+i, OBJ_RECTANGLE, 0,  Time[5], line2[i]+160*Point, Time[1], line2[i]-160*Point);
  ObjectSetInteger(0,"Happybail"+i,OBJPROP_COLOR,clrRed);
  ObjectSet("Happybail"+i,OBJPROP_BACK,0);
  ObjectSet("Happybail"+i,OBJPROP_WIDTH,5);
  
   
  if (line2[i]>line1[i]){ 
         ObjectCreate("Happydays"+iHigh(symbol,240,i), OBJ_TEXT, 0, Time[0], line2[i]+99*Point); 
         ObjectSetText("Happydays"+iHigh(symbol,240,i), DoubleToStr(NormalizeDouble(line2[i]+80*Point,4),4), 16, "Impact", Black);
         
         ObjectCreate("Happydays"+iLow(symbol,240,i), OBJ_TEXT, 0, Time[0], line1[i]-78*Point); 
         ObjectSetText("Happydays"+iLow(symbol,240,i), DoubleToStr(NormalizeDouble(line1[i]-80*Point,4),4), 16, "Impact", Black);
         }
  else { 
         ObjectCreate("Happydays"+iHigh(symbol,240,i), OBJ_TEXT, 0, Time[0], line1[i]+99*Point); 
         ObjectSetText("Happydays"+iHigh(symbol,240,i), DoubleToStr(NormalizeDouble(line1[i]+80*Point,4),4), 16, "Impact", Black);
         
         ObjectCreate("Happydays"+iLow(symbol,240,i), OBJ_TEXT, 0, Time[0], line2[i]-78*Point); 
         ObjectSetText("Happydays"+iLow(symbol,240,i), DoubleToStr(NormalizeDouble(line2[i]-80*Point,4),4), 16, "Impact", Black);
         }       
         
  
  }
   
      
}

  return(0);
}

   void deletetxt1(string text){
   for(int iObj=ObjectsTotal()-1; iObj >= 0; iObj--){
      string   on = ObjectName(iObj);
      if(StringFind(on, text) == 0)  ObjectDelete(on);
}  }

I probably have mentioned before that I use codes for trail stops,

code 1 applies a 1-pip stop loss first upon hitting 4-pips in gains,

code 2 applies the same protective stop loss, but starting from 8-pip in gains, and

code 3 jumps over the first 3 lower steps and only starts trailing upon having made progress beyond 1/2 of the fluctuation size (i.e. 4 pips locked in beyond a 16+4-pip move) which comes in handy when the market does a whole lot of nothing and would likely take you out for break evens with its back and forth motions.

One recent modification was to figure in the swap when determining about applying the trail ( OrderProfit()+OrderSwap()>0 ).

Code 4 is actually an automatic target setting: it adjusts the get out level relative to the last 8-sample low/ high and displaces it by kickback * points – if the position went into gains, and if the new kickback displacement leaves the minimum of 1 pip on the bone (my EUR/USD round trip cost is 0.6 pips)

Code 5 is quite stylishly adjusts the target to E-16: this is where you would be expecting your wave 4 to end and start wave 5, if your count is correct.

/////Long Target - Code 4

if( OrderType()==OP_BUY && OrderProfit()>0 && OrderStopLoss()==.4 && OrderTakeProfit()!=NormalizeDouble(iLow(symbol,15,iLowest(symbol,15,MODE_LOW,8,0))+kickback*Point,4) && OrderOpenPrice()<NormalizeDouble(iLow(symbol,15,iLowest(symbol,15,MODE_LOW,8,0))+kickback*Point,2)-10*Point
 ) 
       { OrderModify(OrderTicket(), OrderOpenPrice(), OrderStopLoss(), NormalizeDouble(iLow(symbol,15,iLowest(symbol,15,MODE_LOW,8,0))+kickback*Point,4), OrderExpiration());
          Print("LONG Target Set @ "+DoubleToStr(NormalizeDouble(iLow(symbol,15,iLowest(symbol,15,MODE_LOW,8,0))+kickback*Point,4),4));}

/////Short Target  - Code 4

if( OrderType()==OP_SELL && OrderProfit()>0 && OrderStopLoss()==4 && OrderTakeProfit()!=NormalizeDouble(iHigh(symbol,15,iLowest(symbol,15,MODE_HIGH,8,0))-kickback*Point,4) && OrderOpenPrice()>NormalizeDouble(iHigh(symbol,15,iLowest(symbol,15,MODE_HIGH,8,0))-kickback*Point,2)+10*Point
 ) 
     {   OrderModify(OrderTicket(), OrderOpenPrice(), OrderStopLoss(), NormalizeDouble(iHigh(symbol,15,iLowest(symbol,15,MODE_HIGH,8,0))-kickback*Point,4) , OrderExpiration());
           Print("SHORT Target Set @ "+DoubleToStr(NormalizeDouble(iHigh(symbol,15,iLowest(symbol,15,MODE_HIGH,8,0))-kickback*Point,4),4));  }    
      

/////Long Target - Code 5

if( OrderType()==OP_BUY && OrderProfit()>0 && OrderStopLoss()==.5 && OrderTakeProfit()!=NormalizeDouble(iMA(symbol,30,32,0,MODE_EMA, PRICE_CLOSE,0),4) && OrderOpenPrice()<NormalizeDouble(iMA(symbol,30,32,0,MODE_EMA, PRICE_CLOSE,0),4)
 ) 
       { OrderModify(OrderTicket(), OrderOpenPrice(), OrderStopLoss(), NormalizeDouble(iMA(symbol,30,32,0,MODE_EMA, PRICE_CLOSE,0),4), OrderExpiration());
          Print("LONG Target Set to E-16 @ "+DoubleToStr(NormalizeDouble(iMA(symbol,30,32,0,MODE_EMA, PRICE_CLOSE,0),4),4));}

/////Short Target  - Code 5

if( OrderType()==OP_SELL && OrderProfit()>0 && OrderStopLoss()==5 && OrderTakeProfit()!=NormalizeDouble(iMA(symbol,30,32,0,MODE_EMA, PRICE_CLOSE,0),4) && OrderOpenPrice()>NormalizeDouble(iMA(symbol,30,32,0,MODE_EMA, PRICE_CLOSE,0),4)
 ) 
     {   OrderModify(OrderTicket(), OrderOpenPrice(), OrderStopLoss(), NormalizeDouble(iMA(symbol,30,32,0,MODE_EMA, PRICE_CLOSE,0),4) , OrderExpiration());
           Print("SHORT Target Set to E-16 @ "+DoubleToStr(NormalizeDouble(iMA(symbol,30,32,0,MODE_EMA, PRICE_CLOSE,0),4),4));  }    

run your cycle over the open trades:

for(i=OrdersTotal()-1; i>=0 ; i--)
 {   
   if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==false)
        { 
           Print("Access to orders list failed with error (",GetLastError(),")");
           break;
        }

I am currently net 4 lots short, and booked $468.02 in gains, which means that today I managed to purchase 10 pips of movement relative to the naked risk carried forward. This 10-pip measure is the name of the game plus not losing equity when you are managing holdings.

Kickback is 90-160 points depending on recent data.

The following indicator should be placed as 3rd indicator below the chart in order to have the letter plots right – or edit the plots from “3” to the number you want it to be (OBJ_TEXT, 3 <- that one).

//+------------------------------------------------------------------+
//|                                             Stochastic Combo.mq4 |
//|                                         Copyright 2019, Macdulio |
//+------------------------------------------------------------------+
#property copyright   "2019, Macdulio"
#property link        "https://forexfore.blog"
#property description "Stochastic Combo"
#property strict

#property indicator_separate_window
#property indicator_minimum    0
#property indicator_maximum    100
#property indicator_buffers    2
#property indicator_color1     LightSeaGreen
#property indicator_color2     Red
#property indicator_level1     20.0
#property indicator_level2     80.0
#property indicator_level3     35.0
#property indicator_level4     65.0
#property indicator_levelcolor clrBlack
#property indicator_levelstyle STYLE_DASH

extern double FSize=32;
double FMax = FSize*6/5;

double stoch[], stoch30[], RSI2[];
//---------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit(void)
  {
   string short_name;
//--- 2 additional buffers are used for counting.
   IndicatorBuffers(2);
//--- indicator lines
   SetIndexStyle(0,DRAW_LINE,EMPTY,5,indicator_color1);
   SetIndexBuffer(0, stoch30);
   SetIndexStyle(1,DRAW_LINE,EMPTY,4,indicator_color2);
   SetIndexBuffer(1,stoch);

//---
    return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Stochastic oscillator                                            |
//+------------------------------------------------------------------+
int start()
  {
   int    i;
   string symbol = Symbol();
  ArrayResize(stoch, 600);   
 ArrayInitialize(stoch, EMPTY_VALUE); 
  ArrayResize(stoch30, 600);   
 ArrayInitialize(stoch30,  EMPTY_VALUE);  
 ArrayResize(RSI2, 600);   
 ArrayInitialize(RSI2, EMPTY_VALUE); 

 deletetxt1("Jeat");
  deletetxt1("Tit"); 
   for(i=300; i>=0; i--){
          stoch[i]=iStochastic(symbol,0,9,3,3,MODE_SMA,0,MODE_SIGNAL,i);
           stoch30[i]=iStochastic(symbol,0,30,3,3,MODE_SMA,0,MODE_SIGNAL,i);
           RSI2[i]= iRSI(symbol,0,2,PRICE_MEDIAN,i);
           
            if ( (stoch30[i]>stoch[i] && stoch30[i+1]<=stoch[i+1] && stoch[i]>70)  || (stoch[i]<80 && stoch[i+1]>80 && stoch30[i]>stoch[i])  || (stoch[i]>70 && stoch30[i]<35 ) )  { 
             ObjectCreate("Jeat"+DoubleToStr(i)+DoubleToStr(3), OBJ_ELLIPSE, 3, Time[i],  stoch[i]+10, Time[i], stoch[i]);
         ObjectSetInteger(0,"Jeat"+DoubleToStr(i)+DoubleToStr(3),OBJPROP_COLOR,clrOrangeRed);
         ObjectSetDouble(0,"Jeat"+DoubleToStr(i)+DoubleToStr(3),OBJPROP_SCALE,.045);
        ObjectSet("Jeat"+DoubleToStr(i)+DoubleToStr(3),OBJPROP_BACK,0);
        ObjectSet("Jeat"+DoubleToStr(i)+DoubleToStr(3),OBJPROP_WIDTH,38);}
        
        
                  if ( (stoch30[i]<stoch[i] && stoch30[i+1]>=stoch[i+1] && stoch[i]<30)   ||  (stoch[i]>20 && stoch[i+1]<20 && stoch30[i]<stoch[i] && stoch30[i]<10) || (stoch[i]<30 && stoch30[i]>70 && stoch[i+1]<30 && stoch30[i+1]>70) )  { 
             ObjectCreate("Jeat"+DoubleToStr(i)+DoubleToStr(3), OBJ_ELLIPSE, 3, Time[i],  stoch[i]+10, Time[i], stoch[i]);
         ObjectSetInteger(0,"Jeat"+DoubleToStr(i)+DoubleToStr(3),OBJPROP_COLOR,clrLimeGreen);
         ObjectSetDouble(0,"Jeat"+DoubleToStr(i)+DoubleToStr(3),OBJPROP_SCALE,.045);
        ObjectSet("Jeat"+DoubleToStr(i)+DoubleToStr(3),OBJPROP_BACK,0);
        ObjectSet("Jeat"+DoubleToStr(i)+DoubleToStr(3),OBJPROP_WIDTH,38);}
        
       if (Period()==60){ 
           
         if (RSI2[i]<=RSI2[i+1] && RSI2[i+3]<RSI2[i+1] && RSI2[i+1]>81 && stoch[i+1]>68 && stoch30[i+1]>60){
                  
                  
          if (Close[i]>iMA(NULL,0,828,0,MODE_EMA, PRICE_HIGH,i)+FMax*10*Point){ ObjectCreate("Tit"+DoubleToStr(i), OBJ_TEXT, 3, Time[i+1], 55);   ObjectSetText("Tit"+DoubleToStr(i), "S/C", 22, "Arial Black", Gray);}
          else {ObjectCreate("Tit"+DoubleToStr(i), OBJ_TEXT, 3, Time[i+1], 85);  ObjectSetText("Tit"+DoubleToStr(i), "S", 32, "Arial Black", Maroon);}}
         
         if (RSI2[i]>RSI2[i+1] && RSI2[i+2]>RSI2[i+1]  && stoch[i]<30 && ((stoch30[i+1]<40 && RSI2[i+1]<9) ||  (Close[i+1]>iMA(NULL,0,30,0,MODE_SMA, PRICE_CLOSE,i+1)) && RSI2[i+1]<15 && (stoch30[i+1]<50 || stoch30[i+1]>60)  )){
                 
      if (Close[i]<iMA(NULL,0,828,0,MODE_EMA, PRICE_LOW,i)-FMax*10*Point ) { ObjectCreate("Tit"+DoubleToStr(i), OBJ_TEXT, 3, Time[i+1], 55);  ObjectSetText("Tit"+DoubleToStr(i), "B/C", 32, "Arial Black", Gray);}               
                  else if (stoch[i]<35 && stoch[i+1]>stoch30[i+1]+12) { ObjectCreate("Tit"+DoubleToStr(i), OBJ_TEXT, 3, Time[i+1], 45); ObjectSetText("Tit"+DoubleToStr(i), "B", 32, "Arial Black", Maroon);}
                  else if (stoch[i+1]<stoch30[i+1]) { ObjectCreate("Tit"+DoubleToStr(i), OBJ_TEXT, 3, Time[i+1], 45); ObjectSetText("Tit"+DoubleToStr(i), "B", 32, "Arial Black", Maroon);}
                  
                  
                if (RSI2[i]>RSI2[i+1] && RSI2[i+2]>RSI2[i+1]  && stoch[i]<30 && 
                stoch30[i]>70 && stoch30[i+1]>70 &&  stoch30[i+2]>70 &&  stoch30[i+3]>70 && stoch30[i+4]>70 && stoch30[i+5]>70 && stoch30[i+6]>70 &&  stoch30[i+7]>70 &&  stoch30[i+8]>70 
                && RSI2[i+1]<15 ){
                  ObjectCreate("Tite"+DoubleToStr(i), OBJ_TEXT, 3, Time[i+3], 45); 
                  ObjectSetText("Tite"+DoubleToStr(i), "EB", 32, "Arial Black", Blue);        
                  
                  }
                  }
         
           
           }}
   

  return(0);
}
//+------------------------------------------------------------------+

void deletetxt1(string what){
   for(int iObj=ObjectsTotal()-1; iObj >= 0; iObj--){
      string   on = ObjectName(iObj);
      if(StringFind(on, what) == 0)  ObjectDelete(on);
}  }

How do you trade corrective wave structures?

This is how you do it.

Plot this indicator on a 1H chart.

It would produce your lead signal.

Green Line above 80 = overbought

Green Line below 80 = oversold

You need the green line to be “fresh”, not embedded.

In the fresh overbought you are looking for a sell signal.

Now you need to make sure, that a turn is happening. Go to a 30-minute chart and look for a hood in the overbought and a root in the oversold.

These can be spotted with an RSI2 divergence (thick red short lines).

Now you start to count the humps to get the exit right.

Self explaining picture coming up:

The corrective wave structure does not show a continuation divergence between wave 2 and wave 4.

You are calculating the approximate distance of failure from the end of 3 wave (the peak that occurs right before the #4 print in the opposite direction) 1/2 fluctuation size away and factor in the possibility of a failed break as well.

Now you know a lot.

(TNR stands for Total Naked Risk in dollars).

I am planning on releasing a book on Managing Naked Risk in Forex in the coming years.

What is a Vol Whip? It is a calibration after a wave structure, that consists of two full lambda moves – one in each direction and defines a trading range.

The VW is not part of any wave structure.

The wave structure ends with the extension move.

Let’s look at the following inverted head and shoulders to put things in perspective.

The three zeros represent the head and shoulders terminals.

The one on the left with the corresponding red bar (below) is the left shoulder or the overdrive.

The head that sets up the divergence in the middle, does not register anything on the stochastic bars. It finishes the wave structure down.

What follows is the volatility whip that prints the right shoulder in the process. Wave 1 up was started when the volatility whip’s terminal points got exceeded by more than a fake out size (5 pips+).

Remarks: the right shoulder can surpass the terminal point of a Wave Structure, yet it would not become part of it.

I have been talking about the relationship between outmost reading the wave 3 printed and the extension (that wave 5 ends up with): they do not in general get spaced further apart than the instrument’s fluctuation maximum reading.

In the case of the EUR/USD the fluctuation size is 32 pips and so 1/4 more would mean a healthy fake out on top of this = 40 pips. Nothing scientific about this, it is merely things you might notice.

There are the likely extension sizes, and this is how I came up with the 4, 16, 26 and 36 pips failures.

…

I don’t often draw trend lines

So, you just had seen a wave 5 of a Wave 5 transpired. Or did you?

Bear in mind, that your wave counting might be off, and what you thought was the end of Wave 5 was merely the end of wave 3 of Wave 5. Then, there was a continuation divergence printed by the bulls.

I was trying to suggest with my last article that the “head” you are looking for…

…would likely show up as a miss on your stochastic bars, and another clue to the final burn could be the length of it: it is likely going to be 1.5-2 hours altogether that would very likely arrive with a higher high / lower low depending on the direction (red/orange tail). A pullback to E-16 should always be a suspect of a wave 4.

Therefore, coming into today you could had said, that the head was missing, and so was the final burn.
This in itself is a viable trading plan.

• A market does not end on a high note – I’m pretty sure I have said this before somewhere.

Can you spot what you cannot see on the last un up resulting in a higher high?

• 

My most downloaded indicator is the 36 Only. This upper plot puts butterfly marks on potential heads based on the miss – turned an admiral cross as of late.

A daily practice

Pull up the daily chart, and tell me:

1. Where was the last broken trend line? What does that mean for the current direction?
2. How Far can you go in that direction? (Energy Bands)
3. How Far would the daily fuel limit support the move without trending?
4. What wave are you in? Whoop, Bam or Boogie?
5. Talk about the interactions with the comfort levels
6. How does the market behave around overbought / oversold? – does it stay embedded? = Trending
7. Was there any volatility breach on the CI? Has the outside value it been beat for a reversal to take place?

Pull up the 30-minute chart and talk about it

1. What market segment are you in? (Neutral, Bear Zone 1, 2 or Bull Zone 1,2)
2. If the market is trending or is in Bear / Bull Zone, you should fade the attacks on the E-16 if the Purple Haze hasn’t been attacked twice.
3. What are the last Boogie Fail lines (4, 16, 26 and 36 pips out)?
4. Stochastic bars… Do they show a head by not being present on the last run?
5. Can you spot the last two continuation divergences on the RSI2? Wave 2 and Wave 4 end points?
6. If you have holdings not aligned with the direction you must hedge / over compensate 2-pips above the high / 2-pips below the arrow of a counter-directional arrow and hold

Pull up the hourly chart, and talk about it

1. What are the 4H support and resistance numbers (Comfort levels)?
2. Are the mid-term memory support levels mostly above or below?
3. What is your suggested maximum naked risk size?
4. What is the current balance of your holdings?
5. The stochastic combo is your timer for getting in on the direction (is the 30-sample D embedded?)
6. The conditional buys / sells (s/c, b/c) need fine tuning by the use of a 30-minute chart

How far can the market proceed in one direction before a turn would be very likely to take place?

This was the very idea behind developing the energy bands.

There is another way of calling a high probability turn, and that is the volatility breach on the Consolidation indicator.

The first recent example shows a beat 3 days after the breach, and the reaction off of it.

The second example had the beat the next day.

There are two examples on the following snap shot. One was beat 3 days later, the other the next day.

There are countless examples, but what I’m trying to say is to find David Moser’s Choppiness Indicator and use my 7,1,7 settings.

It even works with a 4-H chart.

The close: 2nd pop into the Purple Brain

Mambo #5 was the start of Wave 5 up

The magenta line is the 36-pip failure beyond the Boogie

And to answer the question in the title,

The last wave does not end on a high/low note, hence the back test of the top / bottom for measuring purposes. The divergence at the back test of the top is shown by the black lines. The failure lines are relative from the Wave 3 peak.

Admittedly, it was a little hard to separate the wave 4 from the wave 5 because of the undercut of the low, and 30-minute wasn’t the best for that.

So what exactly went down (beyond a possible fake out of the long term oversold neckline / bear market).

So what now? Being outside the oversold for one day does not change anything, it is called “saving” if the next day closes back in the oversold.

If you end up with multiple closes outside, the market would have transitioned to a balanced/commuting market where the bulls should be aiming for the median at 1.1250 as primary goal.

Most likely you shall see the long overdue ABC correction – usually 2 4H dojis lower for the hourly stochastic would have to go oversold twice. This would put price back below the 4-H Maroon at 1.0974 with a small, say 10-pip undercut for good measure.

However is all the selling that is about to take place would not be able to keep the price below the oversold neckline, the bear market would be over with until further notice.

It would certainly clear up the intentions to see where they place the price upon the Sunday open.

Current location of the Energy Bands

The 4-H Wave Structure:

Range bound trading is fading.

Have no bias, and anticipate a fake out.

Timing is everything.

The next image shows how to find the Boogie hump – since these are not waves.

Once you found your hump 2 and hump 4 hooks, you know that you are in the Boogie leg. This is where you close the previous direction and roll into the opposite one.

As you can see, sometimes there is a second peak, mostly for 4-s, but sometimes for 2-s as well, what makes an echo-like peak a suspect is the close proximity in time.

On the way up the 4 would reach lower than the 2 and the opposite goes for the downside.

On the picture above you can say that you are in a hump 3 to the upside since a #4 hasn’t printed yet. You could also say that the market is potentially printing an inverted ABC.

So, let’s talk about another signal for catching a turn: the inverse ABC.

On RSI2, of course.

The inverted ABC (in black) comes from the oversold / overbought area and the C leg would fall short from the RSI starting point of A.

For exit you can utilize the nearest Peak (Oil) or one of the Boogie humps – that may or may not coincide.

…

My current range limits are the Ilford Towers.

I just made my usual line adjustments, posted this image, when I realized that the volatility whip is way more common than anyone would think.

It feels like they throw the ball up in the air, and which ever team takes hold of it has the right for the next wave sequence.

This was the tricky one, where the volatility whip got broken on the unexpected side for another 5 waves up.

Admittedly, it was terribly hard to get the wave count accurate on this section.

In conclusion, what can be said about the whips, is that you want to go with the direction that steps outside the V, with your stop loss beyond the other end, but also, that you should be giving some slack, i.e. 5 pips out to get excited.

Picture showing the pullback just missing the value at 5 pips out: