Macdulio's futures

The New Blog

2017-09-04T03:19:00.002-07:00

The Funky Black Butterfly

2017-08-31T01:13:00.003-07:00

This weekend I'm gonna start working on the new blog.

I had to come up with a filter for Fractals that should prove to be hard to break, and so I reached after the Money Flow Index.

Above: don't mind the 6, it was not meant for the 30 minute chart.

(AUD/USD below)

Guinea Pig

2017-08-29T00:55:00.000-07:00

So, I am facing this dilemma:

Going full time, collecting payments, but with what?

- Selling routines for a fee
or, most likely
- Click based returns blog, providing perhaps codes like you've seen here - and perhaps - signals, updated daily for the 6 pairs I'm looking at

What do you think?

Tell me at macdulio@yahoo.com

My analysis would be different, something like this:

EUR/USD last update: 29/08/17 8:50 AM GMT

GO LONG AND STAY LONG until a fake out develops

ATR target: 1.2047
with Overdrive: 1.2071

channel: above channel buying

professionals: buying

flush out: in progress

last exhaustion: 1.2017

last head: 1.1890, broken

uptrend/downtrend: uptrend from 1.1747

4H projected distance: 1.20219

divergence: in progress

MM Resistances
1.1947
1.1808

MM Supports
gap fill at 1.1921
1.18495
1.1838
1.1810

Feature Trading

2017-08-21T12:49:00.003-07:00

So, what is my suggestion then?

The recognition of the prevailing theme.

i.e:

1. Failed break
2. RSI break above 50 / break of downward sloping trend line
3. Rally from the vicinity of the 50 RSI to a lower high with a higher RSI reading (around a 100 pips from the break out pullback low)

Bonus image: the trick / up the sleeve. The hand shows down, the rebound brings about a low risk entry up the sleeve - about 10 pips above the prompting area.

This Looks Great

2017-08-19T00:41:00.002-07:00

I don't necessary seek out argument opportunities, but I think Scott is totally wrong on this one.

Beautiful chart, best charts in the world (self proclaimed - green with green on cyan), great pride in channel drawing...
The only problem is this... It is totally wrong.

Yes, the top shall be re-visited and most likely surpassed to make a head.
But this is not a an actual channel, there is no support here and the next wave up shall not start from here.

The brown line has no importance. You broke support at 1.1796 and have been consolidating below it.

There is gonna be a another drop to the red support line and the next rally could start from there; an MM level is ought to coincide with it at 1.1574 which should prove to be a good spot for a long. (The next supports below are at 1.14669, 1.1383, 1.1270)

This is Not The Right Chart - MT4

2017-08-18T01:09:00.002-07:00

This is not the right chart to figure out the following: support and resistance levels are not the same, when you break out of a range, say turning a resistance level into a support means not the touch of the very same level above, but making closes above it (thus making a new support line above the previous resistance line).

The idea behind the code below is to give some slack for the price to move about, and to have a clue about where your stop loss should be (over the second flat section), and what at all should be considered as a break.

You hear emini talking about "breaking into a downtrend". This is a way to find it.

The previous flat same color lines can be add to position levels.

The code was intended for 15 min.

//Weight-Reversal by Macdulio
#include <stdlib.mqh>

#property indicator_chart_window
#property indicator_buffers 7
#property indicator_color1 White
#property indicator_color2 Black
#property indicator_color3 Chartreuse
#property indicator_color4 Red
#property indicator_color5 Violet
#property indicator_color6 Cyan
#property indicator_color7 MidnightBlue

double line1[];
double line2[];
double line3[];
double line4[];
double line5[];
double line6[];
double line7[];

double vbru[];
double vbrl[];
double ExtMapBuffer[];

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

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
{
//---- indicators
   SetIndexBuffer(0,line1);
   SetIndexBuffer(1,line2);
   SetIndexBuffer(2,line3);
   SetIndexBuffer(3,vbru);
   SetIndexBuffer(4,vbrl);
   SetIndexBuffer(5,line6);
   SetIndexBuffer(6,line7);


   SetIndexStyle(0,DRAW_ARROW,EMPTY,8,indicator_color7);
    SetIndexArrow(0,59);

   SetIndexStyle(1,DRAW_ARROW,EMPTY,15,indicator_color4);
   SetIndexArrow(1,72);

   SetIndexStyle(2,DRAW_ARROW,EMPTY,15,indicator_color3);
SetIndexArrow(2,71);

   SetIndexStyle(3,DRAW_ARROW,EMPTY,5,indicator_color7);
   SetIndexStyle(4,DRAW_ARROW,EMPTY,5,indicator_color7);
SetIndexArrow(3,118);
SetIndexArrow(4,118);

   SetIndexStyle(5,DRAW_LINE,EMPTY,5,indicator_color4);
   SetIndexStyle(6,DRAW_LINE,EMPTY,5,indicator_color3);

SetIndexEmptyValue(0,EMPTY_VALUE);
SetIndexEmptyValue(1,EMPTY_VALUE);
   SetIndexEmptyValue(2,EMPTY_VALUE);
   SetIndexEmptyValue(3,EMPTY_VALUE);
SetIndexEmptyValue(4,EMPTY_VALUE);
   SetIndexEmptyValue(5,EMPTY_VALUE);
SetIndexEmptyValue(6,EMPTY_VALUE);



   return(0);
}
//+------------------------------------------------------------------+
//| Custom indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit()
{
   return(0);
}
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start()
{

   int      i;

ArrayResize(line1, 601);
ArrayInitialize(line1, EMPTY_VALUE);
ArrayResize(line2, 600);
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(vbru, Bars);
   ArrayInitialize(vbru, 0);
     ArrayResize(vbrl, Bars);
   ArrayInitialize(vbrl, 0);

      ArrayResize(ExtMapBuffer, Bars);
   ArrayInitialize(ExtMapBuffer, 0);


long current_chart_id=ChartID();
   string obj_name="WR";



   line1[601]=iClose(NULL,15,201);
   for (i=600; i>=0; i--){
    line1[i]=line1[i+1];
    if (ChoppinessIndex15(14,i+1)<51 && ChoppinessIndex15(14,i)>51) line1[i]= (iHigh(NULL,15,i)+iLow(NULL,15,i))/2;
          if (Close[i]<line1[i]) line6[i]=line1[i]+.0012;
      if (Close[i]>line1[i]) line7[i]=line1[i]-.0012;
     if (i<550 && Close[i+3]<line1[i+3]-.001 && Close[i+1]<line1[i+1]-.001 && Close[i+6]>line1[i+6]+.0005 && Close[i+8]>line1[i+8]+.0005   ) {   line2[i]=line1[i+5]-.001 ;}
     if (i<550 && Close[i+3]>line1[i+3]+.001 && Close[i+1]>line1[i+1]+.001 && Close[i+6]<line1[i+6]-.0005 && Close[i+8]<line1[i+8]-.0005   ) {   line3[i]=line1[i+5]+.001 ;}


         }

return(0);
}

double ChoppinessIndex15(int period, int bar)
{
    double Low0 = 0, High0 = 0, Close1 = 0;
    double TrueRangeLow = 0, TrueRangeHigh = 0, TrueRangeSum = 0, Input = 0;
    double PeriodTrueRangeLow = 999999999, PeriodTrueRangeHigh = 0, PeriodTrueRange = 0;

    for(int k=bar; k<bar+period; k++)
    {
      Low0   = iLow(NULL,15,k);
      High0 = iHigh(NULL,15,k);
      Close1 = iClose(NULL,15,k+1);

      if (Low0<Close1) TrueRangeLow = Low0; else TrueRangeLow = Close1;
      if (High0>Close1) TrueRangeHigh = High0; else TrueRangeHigh = Close1;

      if (TrueRangeLow <PeriodTrueRangeLow) PeriodTrueRangeLow = TrueRangeLow; // find true low of period
      if (TrueRangeHigh>PeriodTrueRangeHigh) PeriodTrueRangeHigh = TrueRangeHigh; // find true high of period

      TrueRangeSum += TrueRangeHigh;
      TrueRangeSum -= TrueRangeLow;
    }

    PeriodTrueRange = PeriodTrueRangeHigh - PeriodTrueRangeLow;
    if (PeriodTrueRange==0) PeriodTrueRange = MathPow(10, -12); // avoid possibility of division by zero
    Input = TrueRangeSum / PeriodTrueRange;
    return ((logN(Input, 10, MathPow(10, -12)) / logN(period, 10, MathPow(10, -12))) * 100);
}

double logN(double x, double base, double epsilon)
{
    double integer = 0.0;
    if ((x < 1) || (base < 1)) return(0);

    while (x < 1)
    {
      integer -= 1;
      x *= base;
    }

    while (x >= base)
    {
      integer += 1;
      x /= base;
    }

    double partial = 0.5;
    x *= x;
    double decimal = 0.0;

    while (partial > epsilon)
    {
      if (x >= base)
      {
        decimal += partial;
        x = x / base;
      }
      partial *= 0.5;
      x *= x;
    }

    return (integer + decimal);
}

double StdDev(int shift, int samples)
{
double x0=0, x1=0, x2=0;
for (int m=0; m<samples; m++)
    {
    x0 = ExtMapBuffer[m+shift];
    x1 += x0;
    x2 += MathPow(x0,2);
    }
return(MathSqrt((x2-(x1*x1/samples))/(samples-1))); // minimum samples is 2, enforced in the init section
}

I know, it says Weight Reversal, but this thing was more of a side branch for an EA, so this is not the right code for the title.

HSHSHSHSHSHS (MT4)

2017-08-17T02:09:00.001-07:00

No, I'm not the envy type, I share with my audience.

I can make your life easier, yes.

I did not make this routine. In fact, I have no clue who did it.
It is mighty simple.
Stochastic bars. If you have a different background color, change it to None after you hooked up your indicator.

My plus here is the parameters and the knowledge that can be derived from this

The 100 sample is good for 15 min settings.
If you want to use it on 30, you should half the length size.

The promised knowledge:
the head comes with a divergence.
Meaning, after a shoulder, you need a matching/surpassing price reading and a stochastic divergence.
Therefore,
1. you can always bet on a re-test of the shoulder
2. you can bet on a counter-direction move after surpassing the shoulder and not making a new shoulder print
(yes, the head can be re-tested, even superseded by the right shoulder - and the same time, this does not happen in a case of a double top/double bottom)

This indicator is the easiest digitalized way for spotting the divergence of a head.

//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
#property copyright ""
#property link      ""

#property indicator_separate_window
#property indicator_buffers 3
#property indicator_color1 Silver
#property indicator_color2 Red
#property indicator_color3 Blue
#property indicator_width1 2
#property indicator_width2 2
#property indicator_width3 2
#property indicator_maximum 1
#property indicator_minimum 0

double ExtMapBuffer1[];
double ExtMapBuffer2[];
double ExtMapBuffer3[];
//double ma[];

extern int    K_Period = 100;
extern int    D_Period = 3;
extern int    Slowing = 3;
extern int    TopBorder=94;
extern int    BotBorder=6;

extern string TypeMA    = "SMA=0, EMA=1, SMMA=2, LWMA=3";
extern int    MAType    = 0;
//extern int    MAShift   = 0;
extern string TypePrice = "0 - Low/High, 1 - Close/Close";
extern int    PriceType = 0;

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+

int init()
{
   IndicatorBuffers(4);
      SetIndexBuffer(0,ExtMapBuffer1);
      SetIndexBuffer(1,ExtMapBuffer2);
      SetIndexBuffer(2,ExtMapBuffer3);
//     SetIndexBuffer(3,ma);
      SetIndexStyle(0,DRAW_HISTOGRAM);
      SetIndexStyle(1,DRAW_HISTOGRAM);
      SetIndexStyle(2,DRAW_HISTOGRAM);
   return(0);
}

int start()
{
   int      counted_bars=IndicatorCounted();
   int      limit,i;

   if(counted_bars < 0) return(-1);
   if(counted_bars>0) counted_bars--;
         limit = Bars-counted_bars;

   for(i = limit; i >= 0; i--)
   {
      double St=iStochastic(NULL,0,K_Period,D_Period,Slowing,MAType,PriceType,MODE_MAIN,i);
      ExtMapBuffer1[i] = EMPTY_VALUE;
      ExtMapBuffer2[i] = EMPTY_VALUE;
      ExtMapBuffer3[i] = EMPTY_VALUE;
         if (St>BotBorder && St<TopBorder) ExtMapBuffer1[i] = 1;
         if (St<BotBorder) ExtMapBuffer2[i] = 1;
         if (St>TopBorder) ExtMapBuffer3[i] = 1;
   }
   return(0);
}

Thank you, visitor!

Recipe for a Turn

2017-08-15T03:03:00.003-07:00

here is how a flush (wash out) happens:

1. Oversold/Overbought RSI with opposing momentum (MACD)
2. Selling/Buying Exhaustion
3. The highest/lowest RSI reading in the recent history

and...
the whole thing ends into 4. The Market Maker level (resistance line on the upside / support line on the downside)

as for a Head, you need a divergence with an ATR limit MM level

more pronounced on 30 min:

as for the support logic, I can proudly say, that both the EUR/USD and the GBP/CHF had the right support line high lighted,

and GBP/USD was off by merely 1 orange-yellow level

double findsupport (double BowBuffer, double lines2[])
{
   double linesdistance[];
   ArrayResize(linesdistance,30);
   int position;
   for (int i=29; i>=0; i--)
        linesdistance[i]=MathAbs(BowBuffer-(lines2[i]+.0012));
   position=ArrayMinimum(linesdistance,WHOLE_ARRAY,0);
   return(NormalizeDouble(lines2[position],4));
}

The Next Step

2017-08-13T00:51:00.000-07:00

Now, that I have the levels sorted out,
I can combine the knowledge derived from the use of the Daily ATR
("I have noticed that Gold moves in about 75 points increments" (Ira Epstein))
...and this way get a really good idea of what is likely to happen, where the Market Makers would utilize the given levels at (blue S: - blue R:).

(the thick black all the way across is the overbought comfort level, the light coral one is the deeply overbought )

The bottom thingy is the flavor, cyan = overbought, yellow = oversold in a way, although they are a bit hard to explain, for they come with over 45 reading for oversold and below 55 reading for overbought combined with momentum,
there is a cumulative 4-sample RSI in the background, and the 13 sample, non cumulative RSI gets displayed based on that reading,

It was very interesting watching what they were doing, as they dumped half of their belongings 15 pips shy of the target, which resulted in a deeper pullback, yet price did go to target and they got rid of the rest into the close.
The take away here is this: when price turns away right before the resistance line, the next break higher (to the actual resistance level) is a certain sell.

(thick orange line is the median comfort level )

AUD looks to want to break the low and run...

(the last magenta positive bunch can be considered a sell signal)

...

Red indicator strips: downside exhaustion signals (they are supposed to precede the top)
Green indicator strips: upside exhaustion signals (they are supposed to precede the bottom)
I also separated the support and the resistance bunch, for they may overlap each other making it impossible to spot at times

...
uncanny similarity, different outcome

as for end of assault, you want to see two lufts after some intensity

What is a Top? What is a Bottom?

2017-08-03T01:28:00.000-07:00

Different broker,
different data
different plots.

Now, that this is out of the way, let's engage in blowing charts up.

Top and bottom only exist in retrospect.

The most recent bottom was made when there was a 4-hour close above the second support level from the bottom (after a brief breach of the lowest support level).

2nd yellow line (yellow ones are potential supports, blue ones are potential resistances).

(go figure #1)

Basically, it was a close above 1.23

Let's check for a top on the way up.

As you can see, there were a number of fizzles on the way up at potential resistance levels, but the correction never ended in a 4-H close two support lines lower, therefore there is no top yet. As per the current potential fizzle, you would need a close below 1.2786 to make it a valid reversal (this latter number is true with sensitivity cranked up to 25 pips from 35).

As for the Euro,
there was a fizzle+ reversal fake-out earlier, with some intervention to max out pain,
and as it is in the "bird is the word" territory, this 2-line pullback may be the start of the reversal, but to have the resistance line printed as well, a sudden move lower would be required, and you may just get that, perhaps very soon...

In this 1-price system, you are basically looking at a Bid chart. The support lines thus have to be shifted by an average spread. This broker has about 4.5 pips for the GBP/CHF pair, and that is actually very close to the 6 pips displacement that I have on the yellow lines.
The EUR/USD is around 1.5 pips, so I should have shifted the lines down by at least 3.5 pips.
Perhaps at some point.

...
and here's the missing image
showing the 2 blue lines below the one blue...

below: 30 pips sensitivity

Pound Rally

2017-07-30T01:30:00.002-07:00

You are getting end of the volatility signals here;

I do think 1.2760 - the next level is going to be hit before the reversal (it could make a nice fake out to 1.28) i.e.:

(this would fit perfectly)

and 1.28776 is for a much later day.

On the downside the first area of interest is the shamrock congestion just below the overbought neckline, somewhere around 1.2550-1.2525

TOS reads:

Gotta wonder if the level of interest was 1.2740; 1.2796 is an extension possibility. Hard bounce is being suggested here. The next level after that comes in at 1.2846 on the 4 hour.

There is a red channel that rejected the price earlier at 1.3051

This channel resistance may come into play in the coming weeks. It seems like the ultimate target would be somewhere between the white dotted lines: 1.30-1.3150, possibly in a strong rally that would come from the 1.2550 area.

At some point, price should interact with the cloud of the LEMA (green), that would reach the low 30s around the end of this year.
The image below shows the millennium levels starting at 1.38 - this is if everything went beserk, but of course this has very little odds (the daily energy would be capable of this distance in a single move). One thing is certain, the bottom is built very strong, and moves down would be a buy for quite some time to come.

EUR/USD is working on that upper resistance,
1.18+ could be visited on a short notice, but it would make sense to build a short position up here.
There is no real support until the low 1.14s

...

working on a trailing stop that is 2 MM lines and some tolerance away (magenta)

(rising wedge)

...
this image is forwarded to my art collection:

as for entertainment, check out this weekend opening chaos:

3 brokers, same instrument, real time readings...
and for the spread, 437 is at least twice as much as the others...

(This image was taken 25 minutes after the open...)

Who Can You Trust?

2017-07-23T23:48:00.002-07:00

No, I never believed that private firms, driven by profit are not gonna commit anything in their power to take over equity, from the very people they are providing services for, such as you.

One try at binary options was good enough to prove this point.
I had three settlements that went the opposite way than that was on the screen, and I got fed up.
Who can you even turn to or talk to in a case of an offshore company?
They respond if they want to, and as I found out later, everyone is called Mark on Cyprus.
I did end up getting a refund like a month later, but I would never ever want to go through this procedure again.

Spread betting - you can lose more than your deposit, are you kidding me? Not interested.

Forex brokers then?
Sure, here is the one, they claim that they are not market makers.
Cool.

Then you open an account. You trade and realize, this is not so cool either.
Sunday night they jack up the spread to 40 pips?
What?
But that is not enough to take you out of your positions, right?
You have though of everything, except the degree of crookedness they can reach after.

How about fake prints (I thought the binaries thrive on this).

What is that print that just eliminated your account? Does that candle get named after you?
Here's just one of the three other data feeds that I can show you with: this move never ever happened.
Ok. You have no account, they converted it deliberately to an equity call. Who do you turn to? Who do you report to this crooked behavior?

8 Years a Slave

2017-07-22T00:11:00.004-07:00

Do you see these two levels (big arrows)?

The upper one is a Daily MM level, it was plotted the first time on the 29th of May.

The lower one is an Hourly MM, from the 14th of July.

The thing about these levels is that they are for real, not like Fibonacci, that is only in your head.

I spent 8 years building indicators, trading routines, all due to the selfish wanting to know more karma.

I was missing something. Until yesterday, that is.

I need to apologize for something. I said there were no MM levels below 1.2327.

I was wrong. Had to look back further. There were four more levels below. Sometimes you do not have enough history. This is when you need to reach after the dailies.

These are THE levels. Unlike the ones plotted on the right hand side, which are all Closing Prices,

the Market Maker levels I plotted are all shifted by 6-12 pips.

As long as you don't know these levels, you are most likely not going to get the turning points right.

Conditions, such as exhaustion, overbought/oversold RSI are meaningless without touching these levels. Crucial information this is.

These levels define where the flags would take place, these levels mean business when they resist/or break.

My weekend project is set therefore, I need to work out a different look for the scattered fields.

Once you have the levels right, the following things become crystal clear:

- why hedging does not work, merely prolongs your demise

- you need to be aggressive, not defensive

- converting equity to balance is not money making

- building equity is the name of the game

- that's me in the corner

- I have lost my religion a long time ago

Oh no, I said too much...

Well then, preview time...

Dude, where is my 55 Pips?

2017-07-20T05:32:00.002-07:00

Sitting under the MT4 CadetBlue Sky, staring into the bowels of uselessness, it dawns on me:
Scott Barkley, ProAct traders - that is where the Route 55 is originated from, of course!

But dude, where is at?

There are two turn-a-table signals on the following chart:

The RSI is a trick. It is a magic show.
When a hand is flashed, it is to divert your attention.
You need to concentrate on what is up the sleeve.
Yes, they are picking a direction by a sudden, violent move, but then the relapse comes to a level that is at least 10 pips further out than the current 5-sample borderline. That is where you should be taking your actions.

Between 1.2456 and 1.124 - there is your 55 pips at!

https://genius.com/Neuroactive-quiet-afternoon-lyrics

Weekend Project

2017-07-15T01:02:00.001-07:00

Yet another support-resistance project, but more of about finding reversals, break out entries, trail stops right.
Sensitive kind, 15-min CI values.

GBP/CHF may have further to go, the moat is at 1.2680ish
(I'm thinking a pullback to 1.2585 first)

There is an MM level at 1.25662 - this definitely would make for a good catapult level

(this is also the 1H overbought neckline - pink arrows)

Here is your market maker level at 1.2643, as mentioned in my 12/7/17, "Remember?!" article:

People talking of three marching soldiers (daily candles) are ignoring the fact of the third one is coming with range expansion. Besides of the Flush move, this was a back test of a broken 4H support. Although I do believe a higher high will be made, this is probably not the place to go crazy long. CI4H is at 30.5 right now, below the 34 exhaustion level.

The carry trade has definitely been on:

AUD/USD trending beautifully, basically no violation of the green ones.

Looney seems to have just finished a wave 5

USD/CHF looks like a big mess, but may be at a previous break-out level.

Some hints are here and there for a short term Dollar reversal.

my Dollar intel says:

->95.23 (95 pip corr)->95.88 (channel target)

Japanese Yodeling for relaxation...

I chose to have 12 pips of adjustment on the daily MM levels - versus 6 below the daily

For Sure, RSI & Bonus - MT4

2017-07-14T08:54:00.002-07:00

This was pretty darn interesting today,

see below the pullback to the weight & explosion from there up.

Of course, the thick black 30% extra is just an idea, like a 1.27 extension; price does not have to stop dead there.

Some sophisticated stuff as follows: the RSI below is 16 sample, 15 minute basis, HL2.
The first leg up ended when you had 3 pushes up above the 75 mark.
There were three red dots down, and the divergence is shown by the yellow line.
The price was at the same level as before, but the relative strength got much more oversold = a buy.
Now with the red divergence line and the steep run up/scurry, there is a sell signal in place.

Other: the Take Trades EA is looking good enough to enlist it for auto trading

If 45% draw down seems too much, you can always decrease the size.

You have seen these kind of shots before:

The red and green boxes (support and resistance levels) make fairly easy to spot break-outs, just find the last 3 horizontal red groups.

It has no title, but here it is, anyways (the arrows are MACD arrows):

#property copyright "Copyright © 2017, Macdulio"
#property link      "http://macdulio.blogspot.co.uk"
#include <MovingAverages.mqh>
#property indicator_chart_window
#property indicator_buffers 6
extern int       FastMAPeriod=12;
extern int       SlowMAPeriod=26;
extern int       SignalMAPeriod=9;
double sob[];
double sos[];
double ard[];
double aru[];
double fu[];
double fd[];
double MACDLineBuffer[];
double SignalLineBuffer[];
double HistogramBuffer[];
input int InpFastEMA=13;   // Fast EMA Period
input int InpSlowEMA=21;   // Slow EMA Period
input int InpSignalSMA=8; // Signal SMA Period
//--- indicator buffers
double ExtOsmaBuffer[];
double ExtMacdBuffer[];
double ExtSignalBuffer[];
double alpha = 0;
double alpha_1 = 0;
//+------------------------------------------------------------------+
int init() {
//+------------------------------------------------------------------+

SetIndexStyle(0,DRAW_ARROW,EMPTY,5,Green);
SetIndexStyle(1,DRAW_ARROW,EMPTY,5,Red);
SetIndexBuffer(0,sob);
SetIndexBuffer(1,sos);
SetIndexArrow(0,213);
SetIndexArrow(1,213);

SetIndexStyle(2,DRAW_ARROW,EMPTY,8,Magenta);
SetIndexStyle(3,DRAW_ARROW,EMPTY,8,Blue);
SetIndexBuffer(2,ard);
SetIndexBuffer(3,aru);
SetIndexArrow(2,234);
SetIndexArrow(3,233);

SetIndexStyle(4,DRAW_ARROW,EMPTY,8,Black);
SetIndexStyle(5,DRAW_ARROW,EMPTY,8,Black);
SetIndexBuffer(4,fd);
SetIndexBuffer(5,fu);
SetIndexArrow(4,234);
SetIndexArrow(5,233);
IndicatorBuffers(4);

return(0);
}

int OnCalculate (const int rates_total,
                 const int prev_calculated,
                 const datetime& time[],
                 const double& open[],
                 const double& high[],
                 const double& low[],
                 const double& close[],
                 const long& tick_volume[],
                 const long& volume[],
                 const int& spread[])
{
    ArrayResize(MACDLineBuffer, Bars);
   ArrayInitialize(MACDLineBuffer, 0);
    ArrayResize(SignalLineBuffer, Bars);
   ArrayInitialize(SignalLineBuffer, 0);
    ArrayResize(HistogramBuffer, Bars);
   ArrayInitialize(HistogramBuffer, 0);
    ArrayResize(ExtOsmaBuffer, Bars);
   ArrayInitialize(ExtOsmaBuffer, 0);
    ArrayResize(ExtMacdBuffer, Bars);
   ArrayInitialize(ExtMacdBuffer, 0);
    ArrayResize(ExtSignalBuffer, Bars);
   ArrayInitialize(ExtSignalBuffer, 0);

     ArrayResize(sob, 300);
ArrayResize(sos, 300);
ArrayInitialize(sob, EMPTY_VALUE);
    ArrayInitialize(sos, EMPTY_VALUE);
   ArrayResize(ard, 300);
ArrayResize(aru, 300);
ArrayInitialize(ard, EMPTY_VALUE);
    ArrayInitialize(aru, EMPTY_VALUE);
      ArrayResize(fu, 300);
ArrayInitialize(fu, EMPTY_VALUE);
      ArrayResize(fd, 300);
ArrayInitialize(fd, EMPTY_VALUE);

    int i,limit;
      limit=rates_total-prev_calculated;
   if(prev_calculated>0)
      limit++;
//--- macd counted in the 1-st buffer
   for(i=0; i<limit; i++)
      ExtMacdBuffer[i]=iMA(NULL,0,InpFastEMA,0,MODE_EMA,PRICE_CLOSE,i)-
                    iMA(NULL,0,InpSlowEMA,0,MODE_EMA,PRICE_CLOSE,i);
//--- signal line counted in the 2-nd buffer
   SimpleMAOnBuffer(rates_total,prev_calculated,0,InpSignalSMA,ExtMacdBuffer,ExtSignalBuffer);
//--- main loop
   for(i=0; i<limit; i++)
      ExtOsmaBuffer[i]=ExtMacdBuffer[i]-ExtSignalBuffer[i];


   for(i=220; i>=0; i--)
   {
      MACDLineBuffer[i] = iMA(NULL,60,FastMAPeriod,0,MODE_EMA,PRICE_CLOSE,i) - iMA(NULL,60,SlowMAPeriod,0,MODE_EMA,PRICE_CLOSE,i);
      SignalLineBuffer[i] = alpha*MACDLineBuffer[i] + alpha_1*SignalLineBuffer[i+1];
      HistogramBuffer[i] = MACDLineBuffer[i] - SignalLineBuffer[i];
   }
for (i=220; i>=0; i--){
   sos[i]=sos[i+1]; sob[i]=sob[i+1];

   if (iHigh(NULL,0,i+1)<iHigh(NULL,0,i+2)-.0002 && iHigh(NULL,0,i+2)<iHigh(NULL,0,i+3)-.0002) {sos[i]=iHigh(NULL,0,i+2); sob[i]=EMPTY_VALUE; }
   if (iLow(NULL,0,i+1)>iLow(NULL,0,i+2)+.0002 && iLow(NULL,0,i+2)>iLow(NULL,0,i+3)+.0002) {sob[i]=iLow(NULL,0,i+2); sos[i]=EMPTY_VALUE; }
        }
for (i=218; i>=0; i--){

       fd[i]=EMPTY_VALUE;
       fu[i]=EMPTY_VALUE;
   if ( HistogramBuffer[i+2]<HistogramBuffer[i+1] && HistogramBuffer[i+1]>-.0015 && sob[i+1]==EMPTY_VALUE && sob[i]!=EMPTY_VALUE && sob[i+5]==EMPTY_VALUE ) aru[i]=iLow(NULL,0,i)-.0012;
   if ( HistogramBuffer[i+2]>HistogramBuffer[i+1]   && HistogramBuffer[i+2]<.0015 && sos[i+1]==EMPTY_VALUE && sos[i]!=EMPTY_VALUE && sos[i+6]==EMPTY_VALUE ) ard[i]=iHigh(NULL,0,i)+.0012;
   //&& HistogramBuffer[i+4]<HistogramBuffer[i+3]




       if ( sos[i+1]!=EMPTY_VALUE && sos[i+2]!=EMPTY_VALUE && sos[i+3]!=EMPTY_VALUE && sos[i+4]!=EMPTY_VALUE && HistogramBuffer[i+5]>HistogramBuffer[i+4] && HistogramBuffer[i+4]<HistogramBuffer[i+3] && HistogramBuffer[i+1]>-.0015) ard[i]=iHigh(NULL,0,i)+.0012;
      if ( sob[i+1]!=EMPTY_VALUE && sob[i+2]!=EMPTY_VALUE && sob[i+3]!=EMPTY_VALUE && sob[i+4]!=EMPTY_VALUE && sob[i+5]!=EMPTY_VALUE && HistogramBuffer[i+7]<HistogramBuffer[i+6] && HistogramBuffer[i+6]>HistogramBuffer[i+5]&& HistogramBuffer[i+1]<.0015 ) aru[i]=iLow(NULL,0,i)-.0012;
      if ( sos[i+1]!=EMPTY_VALUE && sos[i+2]!=EMPTY_VALUE && sos[i+3]!=EMPTY_VALUE && sos[i+4]!=EMPTY_VALUE && sos[i+5]!=EMPTY_VALUE && sos[i+6]!=EMPTY_VALUE && HistogramBuffer[i+2]>HistogramBuffer[i+3] && HistogramBuffer[i+1]>HistogramBuffer[i+2] && HistogramBuffer[i]>HistogramBuffer[i+1] && ard[i]==EMPTY_VALUE   ) aru[i]=iLow(NULL,0,i)-.0012;
   //&& ard[i]==EMPTY_VALUE
      if ( ExtOsmaBuffer[i+3]<0 && ExtOsmaBuffer[i+1]>0 && ExtOsmaBuffer[i]<0 ) fd[i]= iHigh(NULL,0,i)+.0012;
        if ( ExtOsmaBuffer[i+3]>0 && ExtOsmaBuffer[i+1]<0 && ExtOsmaBuffer[i]>0 ) fu[i]=iLow(NULL,0,i)-.0012;
      //HistogramBuffer[i+3]<0 &&
      //HistogramBuffer[i+3]>0 &&
        }

return(0);
}

I use it on the 1H.

Remember?!

2017-07-12T23:32:00.001-07:00

I posted this on the 1st of July, in the Where To? - article:

Guess what, 1.2381 was filled two days ago, and price went as low as 1.2340.
Now, the big question is this: should the lower value be considered as filled, partially filled or in need of re-visit?

Aleksey Bukuros has been saying for three weeks straight that the global balance was long (sounds very scientific), and that cable will "more probably" go to 1.32.
He just could not say from where and when they would step in.
The above information is what he is missing, and Most Probably some grammar, too.

Once the Market Makers manage to get rid of all underwater shorts, there shall absolutely be no reason / incentive for the price to progress lower.

Good luck to those wanting to see 1.20, 1.21 on the Cable again.

As for me, remember me, for centuries...

On the downside:

1.2408 (new level)

1.2327 (iffy lube)

- and nothing below -

Upside MM reaction levels:
1.2454
1.24776
1.2526
1.2643
1.2880
1.3000

(when progressing to the upside with force, these levels would not put up a whole lot of fight...)

Cadillac Margarita

2017-07-12T08:19:00.000-07:00

I know, what you're thinking.
Did he fire five or six shots?
Do you feel lucky, Punk?

Yes, if you look closely, those previous back test images have a green line showing equity.
If it deviates a great deal on the downside, that is undesired draw down that can potentially bring upon a margin/equity call.

In that case, how about the green one here?

Would no draw down do it for you then, señor?

Now, back to business. You may have figured out by now, that what I have been working on all along is self reading, self commenting charts.

The latest edition goes something like this:

It does say, PL UP! = Play the upside - that is when you are above the black contoured violet line.
The cyan outlined blue line is the weight - generally would be close / coincide with the last consolidation's 1H close value.
This latter line is the basis for the ATR projections.
The thick whites are ATR distance away, the thick black ones are the extra 30% / overdrive.
And now it spells out the target values too in numbers.

I know, I may need to shuffle about the order of the layers, but as I said before, it is a working progress.

...

Yup, a little more visible now:

Oh, yeah, the yellow arrows are the last 1H oversold neckline and the blue ones are the last one or two 1H overbought neckline. But you already knew that...

CA Terminator for MT4

2017-07-09T08:29:00.003-07:00

The Following EA deals with open Buy and Sell orders that have no take profit price.
They get terminated if they are in gains and there was a Captain America signal (on either two different sample lengths), which signals the end of a volatility breach (around a likely turn).

Taking you out of the trades I find very useful if you cannot baby sit them all the time.
Now, you just need a routine that opens these trades based on some goldilocks conditions.

Currently it is for GBP/CHF
you would need to change the two
&& OrderSymbol()=="GBPCHF" -s
if you are trading a different pair.

I was taken out of two longs opened last night by the time I got home from work.
One was more of a break-even after commission, but the other made money.
It is almost like a cautionary sign, saying: something's up.

3:45 AM :)

The best part is this: I am not stuck with those underwater longs 50-60 pips lower, without certainty that the market would not proceed any lower from here.

// CA Terminator by Macdulio
#include <stdlib.mqh>

extern int ChoppinessPeriod=62;        // Number of bars to evaluation CI
extern int SmoothingPeriod=1;          // Number of bars to apply SMA
extern int StdDevPeriod=62;            // Number of bars to evaluate Standard Deviation of the CI
extern int ChoppinessPeriod2=39;        // Number of bars to evaluation CI
extern int SmoothingPeriod2=1;          // Number of bars to apply SMA
extern int StdDevPeriod2=39;
extern bool StdDevFollowPrice=false;   // True, StdDev bars follow price, False, StdDev bars centered on 50
extern int MaxCalcBars=500;           // Limit calculations back this many bars
double ExtMapBuffer[];
double StdDevHiBuffer[];
double StdDevLoBuffer[];
double IntMapBuffer[];
double IntStdDevBuffer[];
double ExtMapBuffer2[];
double StdDevHiBuffer2[];
double StdDevLoBuffer2[];
double IntMapBuffer2[];
double IntStdDevBuffer2[];
double vbru[];
double vbrl[];
double stdl[];

int profits;
int order_type;
int init() {
   return(0);
}

int deinit() {
return(0);
}

int start() {

   int counted_bars=IndicatorCounted();
int z,i;
double bufferTemp1, bufferTemp2;
    ArrayResize(vbru, Bars);
   ArrayInitialize(vbru, 0);
    ArrayResize(vbrl, Bars);
   ArrayInitialize(vbrl, 0);

     ArrayResize(IntMapBuffer, Bars);
   ArrayInitialize(IntMapBuffer, 0);
    ArrayResize(ExtMapBuffer, Bars);
   ArrayInitialize(ExtMapBuffer, 0);
ArrayResize(StdDevHiBuffer, Bars);
   ArrayInitialize(StdDevHiBuffer, 0);
    ArrayResize(StdDevLoBuffer, Bars);
   ArrayInitialize(StdDevLoBuffer, 0);
       ArrayResize(IntStdDevBuffer, Bars);
   ArrayInitialize(IntStdDevBuffer, 0);

     ArrayResize(IntMapBuffer2, Bars);
   ArrayInitialize(IntMapBuffer2, 0);
    ArrayResize(ExtMapBuffer2, Bars);
   ArrayInitialize(ExtMapBuffer2, 0);
ArrayResize(StdDevHiBuffer2, Bars);
   ArrayInitialize(StdDevHiBuffer2, 0);
    ArrayResize(StdDevLoBuffer2, Bars);
   ArrayInitialize(StdDevLoBuffer2, 0);
       ArrayResize(IntStdDevBuffer2, Bars);
   ArrayInitialize(IntStdDevBuffer2, 0);

OrderSelect(i, SELECT_BY_POS);
order_type = OrderType();

for (i=Bars; i>=0; i--)
    {
    IntMapBuffer[i] = ChoppinessIndex(ChoppinessPeriod,i);
    bufferTemp1 = 0;
    for(int j=0; j<SmoothingPeriod; j++) { z=i+j; bufferTemp1 += IntMapBuffer[z]; }
    ExtMapBuffer[i] = bufferTemp1 / SmoothingPeriod;
    IntStdDevBuffer[i] = StdDev(i,StdDevPeriod);
    bufferTemp1 = 0;
    bufferTemp2 = 0;
    for(int n=0; n<StdDevPeriod; n++)
      {
      z=i+n;
      if (StdDevFollowPrice)
        {
        bufferTemp1 += ExtMapBuffer[z];
        bufferTemp2 += ExtMapBuffer[z];
        }
      else
        {
        bufferTemp1 += 52.5;
        bufferTemp2 += 52.5;
        }
      bufferTemp1 += IntStdDevBuffer[i]*2;
      bufferTemp2 -= IntStdDevBuffer[i]*2;
      }
    StdDevHiBuffer[i] = bufferTemp1 / StdDevPeriod;
    StdDevLoBuffer[i] = bufferTemp2 / StdDevPeriod;
    if (ExtMapBuffer[i]>StdDevLoBuffer[i] && ExtMapBuffer[i+1]<StdDevLoBuffer[i+1] && ExtMapBuffer[i+2]<StdDevLoBuffer[i+2] && iRSI(NULL,15,11,PRICE_MEDIAN,i+4)<40) vbrl[i] = 1;
     //&& ExtMapBuffer[i+3]<StdDevLoBuffer[i+3]
     if (ExtMapBuffer[i]>StdDevLoBuffer[i] && ExtMapBuffer[i+1]<StdDevLoBuffer[i+1] && ExtMapBuffer[i+2]<StdDevLoBuffer[i+2] && iRSI(NULL,15,11,PRICE_MEDIAN,i+4)>40 ) vbru[i] = 1;
//&& ExtMapBuffer[i+3]<StdDevLoBuffer[i+3]

    }

for (i=Bars; i>=0; i--)
    {
    IntMapBuffer2[i] = ChoppinessIndex(ChoppinessPeriod2,i);
    bufferTemp1 = 0;
    for(j=0; j<SmoothingPeriod2; j++) { z=i+j; bufferTemp1 += IntMapBuffer2[z]; }
    ExtMapBuffer2[i] = bufferTemp1 / SmoothingPeriod2;
    IntStdDevBuffer2[i] = StdDev(i,StdDevPeriod2);
    bufferTemp1 = 0;
    bufferTemp2 = 0;
    for(n=0; n<StdDevPeriod2; n++)
      {
      z=i+n;
      if (StdDevFollowPrice)
        {
        bufferTemp1 += ExtMapBuffer2[z];
        bufferTemp2 += ExtMapBuffer2[z];
        }
      else
        {
        bufferTemp1 += 52.5;
        bufferTemp2 += 52.5;
        }
      bufferTemp1 += IntStdDevBuffer2[i]*2;
      bufferTemp2 -= IntStdDevBuffer2[i]*2;
      }
    StdDevHiBuffer2[i] = bufferTemp1 / StdDevPeriod2;
    StdDevLoBuffer2[i] = bufferTemp2 / StdDevPeriod2;
    if (ExtMapBuffer2[i]>StdDevLoBuffer2[i] && ExtMapBuffer2[i+1]<StdDevLoBuffer2[i+1] && ExtMapBuffer2[i+2]<StdDevLoBuffer2[i+2] && iRSI(NULL,15,11,PRICE_MEDIAN,i+4)<40) vbrl[i] = 1;
     //&& ExtMapBuffer[i+3]<StdDevLoBuffer[i+3]
     if (ExtMapBuffer2[i]>StdDevLoBuffer2[i] && ExtMapBuffer2[i+1]<StdDevLoBuffer2[i+1] && ExtMapBuffer2[i+2]<StdDevLoBuffer2[i+2] && iRSI(NULL,15,11,PRICE_MEDIAN,i+4)>40 ) vbru[i] = 1;
//&& ExtMapBuffer[i+3]<StdDevLoBuffer[i+3]

    }

for (i = OrdersTotal() - 1; i >= 0; i--){

   if( OrderSelect(i,SELECT_BY_POS))

    if( OrderType()==OP_BUY && Close[0]>OrderOpenPrice() && OrderSymbol()=="GBPCHF" && OrderTakeProfit()==0 && vbru[2]!=0)
        {OrderClose( OrderTicket(), OrderLots(), MarketInfo(OrderSymbol(), MODE_BID), 5, Red );
            Print("CA Terminator Closed LONG for ", OrderProfit());

       }
       else if( OrderType()==OP_SELL && Close[0]<OrderOpenPrice() && OrderSymbol()=="GBPCHF" && OrderTakeProfit()==0 && vbrl[2]!=0)
           {OrderClose( OrderTicket(), OrderLots(), MarketInfo(OrderSymbol(), MODE_ASK), 5, Yellow );

         }

}



return(0);
}

double ChoppinessIndex(int period, int bar)
{
    double Low0 = 0, High0 = 0, Close1 = 0;
    double TrueRangeLow = 0, TrueRangeHigh = 0, TrueRangeSum = 0, Input = 0;
    double PeriodTrueRangeLow = 999999999, PeriodTrueRangeHigh = 0, PeriodTrueRange = 0;

    for(int k=bar; k<bar+period; k++)
    {
      Low0   = iLow(NULL,15,k);
      High0 = iHigh(NULL,15,k);
      Close1 = iClose(NULL,15,k+1);

      if (Low0<Close1) TrueRangeLow = Low0; else TrueRangeLow = Close1;
      if (High0>Close1) TrueRangeHigh = High0; else TrueRangeHigh = Close1;

      if (TrueRangeLow <PeriodTrueRangeLow) PeriodTrueRangeLow = TrueRangeLow; // find true low of period
      if (TrueRangeHigh>PeriodTrueRangeHigh) PeriodTrueRangeHigh = TrueRangeHigh; // find true high of period

      TrueRangeSum += TrueRangeHigh;
      TrueRangeSum -= TrueRangeLow;
    }

    PeriodTrueRange = PeriodTrueRangeHigh - PeriodTrueRangeLow;
    if (PeriodTrueRange==0) PeriodTrueRange = MathPow(10, -12); // avoid possibility of division by zero
    Input = TrueRangeSum / PeriodTrueRange;
    return ((logN(Input, 10, MathPow(10, -12)) / logN(period, 10, MathPow(10, -12))) * 100);
}

double logN(double x, double base, double epsilon)
{
    double integer = 0.0;
    if ((x < 1) || (base < 1)) return(0);

    while (x < 1)
    {
      integer -= 1;
      x *= base;
    }

    while (x >= base)
    {
      integer += 1;
      x /= base;
    }

    double partial = 0.5;
    x *= x;
    double decimal = 0.0;

    while (partial > epsilon)
    {
      if (x >= base)
      {
        decimal += partial;
        x = x / base;
      }
      partial *= 0.5;
      x *= x;
    }

    return (integer + decimal);
}

double StdDev(int shift, int samples)
{
double x0=0, x1=0, x2=0;
for (int m=0; m<samples; m++)
    {
    x0 = ExtMapBuffer[m+shift];
    x1 += x0;
    x2 += MathPow(x0,2);
    }
return(MathSqrt((x2-(x1*x1/samples))/(samples-1))); // minimum samples is 2, enforced in the init section
}

Have I got Something?

2017-07-09T06:07:00.002-07:00

So,
as Mark Douglas said, you don't need to know where the market is going in order to make money in it.
Inspiring in a way,
at least in a poetic manner.
Take Trades is an EA, that simply buys low 8-minute RSI with time and quick motion restrictions, and sells high RSI with almost mirror conditions, plus front tests for open orders hitting the opposite side of the fence to trim away on the branches.

Pretty promising on the back test if you ask me.

Also, here's an image showing wave 1, 3 & 5 as picture perfect RSI sudden moves.

As for the outlook, the fact, that the market maker level did not have a better reaction, leaves with the head being in place at 1.2515, and the right shoulder may or may not exceed this level, but I believe that there will be another assault on the upside still.

This seems to be a flat top drop, a shot over the bow, a three domes before the peak.

1.2470 is certainly attainable on a quick note and there is a shamrock at 1.25695
There was a flush on the downside, and the next divergent momentum - likely at the low should be a buy.
1.2381-1.23747 is the measured target area on the downside if it cares to proceed a little lower.

still not bad

This image shows 1.24866 for channel target:

Either way, play only with trailing stops above that for it may be a flash visit.

...

No, not bad at all...

The Most Important Line - MT4

2017-07-07T00:48:00.001-07:00

The most important level on any chart is the last & nearest level where the energy reached full charge.
If you are making closes above this level, your bias is up, if you are making closes below it, the bias is down.
Violet-black contour.
Also upside & downside average ATR projections in OliveGreen and OrangeRed.
The white lines are additional hourly consolidation levels from the past up to the number you select for max lines.
There is a t bit tiny of displacement, and if you do not plot it on 1-hour (say 15 min), the high light may be showing a different line effectively yielding some additional information about a close d range movement before a break out.

//CI FULL_Lines by Macdulio
#include <stdlib.mqh>

#property indicator_chart_window
#property indicator_buffers 24
#property indicator_color1 White
#property indicator_color2 Black
#property indicator_color3 DarkOliveGreen
#property indicator_color4 OrangeRed
#property indicator_color5 Violet
extern double AF=1.3;
extern double LT=60;
extern int maxlines = 12;
extern int displaylength = 45;
double ATRA;
double ATRAVG[];
double lines[];
double lines2[];
double mid[];
double mid2[];
double at[];
double ci4[];
double cih[];
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 vbru[];
double vbrl[];
double ExtMapBuffer[];
double ExtMapBuffer2[];
double StdDevHiBuffer[];
double StdDevLoBuffer[];
double IntMapBuffer[];
double IntStdDevBuffer[];
double iHi[];
double iLo[];
double xHi[];
double xLo[];

// Main Parameters
extern int ChoppinessPeriod=14;        // Number of bars to evaluation CI
extern int SmoothingPeriod=1;          // Number of bars to apply SMA
extern int StdDevPeriod=13;            // Number of bars to evaluate Standard Deviation of the CI
extern bool StdDevFollowPrice=false;   // True, StdDev bars follow price, False, StdDev bars centered on 50
extern bool EnableAlertOnHigh=false;   // Alert setting for entering time of choppiness
extern double AlertHighVal=62;       // Default value based on fib numbers
extern bool EnableAlertOnLow=false;    // Alert setting for entering time of trending
extern double AlertLowVal=34;        // Default value based on fib numbers
extern int MaxCalcBars=300;           // Limit calculations back this many bars

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);
   SetIndexStyle(0,DRAW_LINE,EMPTY,11,indicator_color2);
   SetIndexStyle(1,DRAW_LINE,EMPTY,5,indicator_color1);
   SetIndexStyle(2,DRAW_LINE,EMPTY,5,indicator_color1);
   SetIndexStyle(3,DRAW_LINE,EMPTY,5,indicator_color1);
   SetIndexStyle(4,DRAW_LINE,EMPTY,5,indicator_color1);
   SetIndexStyle(5,DRAW_LINE,EMPTY,5,indicator_color1);
   SetIndexStyle(6,DRAW_LINE,EMPTY,5,indicator_color1);
   SetIndexStyle(7,DRAW_LINE,EMPTY,5,indicator_color1);
   SetIndexStyle(8,DRAW_LINE,EMPTY,5,indicator_color1);
   SetIndexStyle(9,DRAW_LINE,EMPTY,5,indicator_color1);
   SetIndexStyle(10,DRAW_LINE,EMPTY,5,indicator_color2);
   SetIndexStyle(11,DRAW_LINE,EMPTY,5,indicator_color2);
   SetIndexStyle(12,DRAW_LINE,EMPTY,5,indicator_color2);
   SetIndexStyle(13,DRAW_LINE,EMPTY,5,indicator_color2);
   SetIndexStyle(14,DRAW_LINE,EMPTY,5,indicator_color2);
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_color4);
   SetIndexStyle(21,DRAW_LINE,EMPTY,5,indicator_color3);
   SetIndexStyle(22,DRAW_LINE,EMPTY,5,indicator_color5);


     if (ChoppinessPeriod<2) ChoppinessPeriod = 2;   // Any lower and this indicator isn't relevant
   if (SmoothingPeriod<1) SmoothingPeriod = 1;     // Avoid configuration errors
   if (StdDevPeriod<2) StdDevPeriod = 2;           // Any lower and the Standard Deviation isn't relevant
   if (MaxCalcBars>300) MaxCalcBars = 300;     // Any higher and may adversely affect performance on multi-chart setups
     for(int i=0;i<=Bars;i++) ExtMapBuffer[i]=0; // Smoothed & visible main indicator line
   for(i=0;i<=Bars;i++) ExtMapBuffer2[i]=0;
   for(i=0;i<=Bars;i++) StdDevHiBuffer[i]=0;    // Upper StdDev band, visible
   for(i=0;i<=Bars;i++) StdDevLoBuffer[i]=0;    // Lower StdDev band, visible
   for(i=0;i<=Bars;i++) IntMapBuffer[i]=0;      // Raw CI, not smoothed, not visible
   for(i=0;i<=Bars;i++) IntStdDevBuffer[i]=0;   // Raw StdDev of Smoothed & visible main indicator line (ExtMapBuffer)
//----
switch (Period())
     {
     case     1: TimeFrame = "M1"; break;
     case     5: TimeFrame = "M5"; break;
     case    15: TimeFrame = "M15"; break;
     case    30: TimeFrame = "M30"; break;
     case    60: TimeFrame = "H1"; break;
     case   240: TimeFrame = "H4"; break;
     case 1440: TimeFrame = "D1"; break;
     case 10080: TimeFrame = "W1"; break;
     case 43200: TimeFrame = "MN"; break;
   }
   return(0);
}
//+------------------------------------------------------------------+
//| Custom indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit()
{
   return(0);
}
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start()
{

   int      i,pos,pos2,c_b=IndicatorCounted();;
ArrayResize(lines, maxlines);
ArrayResize(at, c_b);
ArrayInitialize(lines, EMPTY_VALUE);
ArrayResize(lines2, maxlines);
ArrayInitialize(lines2, EMPTY_VALUE);
ArrayInitialize(at, 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(vbru, Bars);
   ArrayInitialize(vbru, 0);
     ArrayResize(vbrl, Bars);
   ArrayInitialize(vbrl, 0);
     ArrayResize(IntMapBuffer, Bars);
   ArrayInitialize(IntMapBuffer, 0);
      ArrayResize(ExtMapBuffer, Bars);
   ArrayInitialize(ExtMapBuffer, 0);
       ArrayResize(ExtMapBuffer2, Bars);
   ArrayInitialize(ExtMapBuffer2, 0);
     ArrayResize(IntStdDevBuffer, Bars);
   ArrayInitialize(IntStdDevBuffer, 0);
       ArrayResize(StdDevHiBuffer, Bars);
   ArrayInitialize(StdDevHiBuffer, 0);
       ArrayResize(StdDevLoBuffer, Bars);
   ArrayInitialize(StdDevLoBuffer, 0);
      ArrayResize(mid, Bars);
   ArrayInitialize(mid, 0);
      ArrayResize(mid2, Bars);
   ArrayInitialize(mid2, 0);
   ArrayResize(iHi, Bars);
ArrayResize(iLo, Bars);
ArrayInitialize(iHi, 0);
ArrayInitialize(iLo, 0);
ArrayResize(xHi, Bars);
ArrayResize(xLo, Bars);
ArrayInitialize(xHi, 0);
ArrayInitialize(xLo, 0);

ArrayResize(ATRAVG, 353);
   ArrayInitialize(ATRAVG, 0);

   ATRA = 0;
   for (i=1; i<=3; i++){
     ATRA = ATRA+iATR(NULL,1440,14,i);}

   for (i=0; i<=160; i++){
     ATRAVG[i] = ATRA/3; }


   int counted_bars=IndicatorCounted();
int limit;

if (counted_bars<0) return(-1);
if (counted_bars>0) counted_bars--;
limit=Bars-counted_bars;
if (limit>MaxCalcBars) limit=MaxCalcBars;

   pos=0;

    for (i=452; i>=0; i--){
    iHi[i]=iHighest(NULL,60,MODE_HIGH,5,i);
    iLo[i]=iLowest(NULL,60,MODE_LOW,5,i);
    xHi[i]=iHigh(NULL,60,iHi[i]);
    xLo[i]=iLow(NULL,60,iLo[i]);}



for (i=250; i>=1; i--) {
        if (ChoppinessIndex(14,i)>53 && ChoppinessIndex(14,i+1)<53 && Close[i]<Close[i+5]) vbru[i] =iClose(NULL,60,i)-.0005;
         if (ChoppinessIndex(14,i)>53 && ChoppinessIndex(14,i+1)<53 && Close[i]>Close[i+5]) vbru[i] =iClose(NULL,60,i)+.0005;

}

pos=0;
for (i=1; i<=150; i++)
        if (vbru[i]>0) {mid[pos]= vbru[i]; pos=pos+1;}
//Print("mid[",pos,"]",   mid[pos]);

pos2=0;
for (i=1; i<=150; i++)
        if (vbrl[i]>0) {mid2[pos2]= vbrl[i];     pos2=pos2+1;}
//Print("mid2[",pos2,"]",   mid2[pos2]);

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

i=0;
   while(i<100 && pos2>0)
            {
               if (i==pos2) break;
               if (mid2[i]!=EMPTY_VALUE) lines2[i]=mid2[i];
               i++;
            }

   for (i=0; i<=displaylength-1; i++) {
      if (lines[0]>0) {line1[i]=lines[0]; line23[i]=lines[0]; line21[i]=line1[i]+ATRAVG[i]; line22[i]=line1[i]-ATRAVG[i]; }
      if (lines[1]>0) line2[i]=lines[1];
      if (lines[2]>0) line3[i]=lines[2];
      if (lines[3]>0) line4[i]=lines[3];
      if (lines[4]>0) line5[i]=lines[4];
      if (lines[5]>0) line6[i]=lines[5];
      if (lines[6]>0) line7[i]=lines[6];
      if (lines[7]>0) line8[i]=lines[7];
      if (lines[8]>0) line9[i]=lines[8];
      if (lines[9]>0) line10[i]=lines[9];
      if (lines2[0]>0) line11[i]=lines2[0];
      if (lines2[1]>0) line12[i]=lines2[1];
      if (lines2[2]>0) line13[i]=lines2[2];
      if (lines2[3]>0) line14[i]=lines2[3];
      if (lines2[4]>0) line15[i]=lines2[4];
      if (lines2[5]>0) line16[i]=lines2[5];
      if (lines2[6]>0) line17[i]=lines2[6];
      if (lines2[7]>0) line18[i]=lines2[7];
      if (lines2[8]>0) line19[i]=lines2[8];
      if (lines2[9]>0) line20[i]=lines2[9];


}
// Print("line1[0]: ", line1[0]);
return(0);
}

double ChoppinessIndex(int period, int bar)
{
    double Low0 = 0, High0 = 0, Close1 = 0;
    double TrueRangeLow = 0, TrueRangeHigh = 0, TrueRangeSum = 0, Input = 0;
    double PeriodTrueRangeLow = 999999999, PeriodTrueRangeHigh = 0, PeriodTrueRange = 0;

    for(int k=bar; k<bar+period; k++)
    {
      Low0   = iLow(NULL,60,k);
      High0 = iHigh(NULL,60,k);
      Close1 = iClose(NULL,60,k+1);

      if (Low0<Close1) TrueRangeLow = Low0; else TrueRangeLow = Close1;
      if (High0>Close1) TrueRangeHigh = High0; else TrueRangeHigh = Close1;

      if (TrueRangeLow <PeriodTrueRangeLow) PeriodTrueRangeLow = TrueRangeLow; // find true low of period
      if (TrueRangeHigh>PeriodTrueRangeHigh) PeriodTrueRangeHigh = TrueRangeHigh; // find true high of period

      TrueRangeSum += TrueRangeHigh;
      TrueRangeSum -= TrueRangeLow;
    }

    PeriodTrueRange = PeriodTrueRangeHigh - PeriodTrueRangeLow;
    if (PeriodTrueRange==0) PeriodTrueRange = MathPow(10, -12); // avoid possibility of division by zero
    Input = TrueRangeSum / PeriodTrueRange;
    return ((logN(Input, 10, MathPow(10, -12)) / logN(period, 10, MathPow(10, -12))) * 100);
}

double logN(double x, double base, double epsilon)
{
    double integer = 0.0;
    if ((x < 1) || (base < 1)) return(0);

    while (x < 1)
    {
      integer -= 1;
      x *= base;
    }

    while (x >= base)
    {
      integer += 1;
      x /= base;
    }

    double partial = 0.5;
    x *= x;
    double decimal = 0.0;

    while (partial > epsilon)
    {
      if (x >= base)
      {
        decimal += partial;
        x = x / base;
      }
      partial *= 0.5;
      x *= x;
    }

    return (integer + decimal);
}

double StdDev(int shift, int samples)
{
double x0=0, x1=0, x2=0;
for (int m=0; m<samples; m++)
    {
    x0 = ExtMapBuffer[m+shift];
    x1 += x0;
    x2 += MathPow(x0,2);
    }
return(MathSqrt((x2-(x1*x1/samples))/(samples-1))); // minimum samples is 2, enforced in the init section
}

...
You are welcome.

...

Yup, this yellow one is a kill all shorts/buy/market maker level.

Here's an image combined the static 1H and the flexible 1H version, showing the range, and the place of the possible back test>

Trade From To - MT4

2017-07-02T06:33:00.003-07:00

...based on Hourly Stochastic overbought/oversold levels

...check back at times to see if I altered the code.

V1.1

Sorted out the ATR value after realizing the ArrayMaximum was returning only an index number.

V1.2

I got rid of the surplus plots and flipped the arrows

// Trade From To V1.2 By Macdulio

#property indicator_chart_window
#property indicator_buffers 4

//---- indicator buffers
double SLKL[];
double atrc[];
double atr[];
double lastob[];
double lastos[];
int chc;
double dwn[];
double uph[];
double line1[];
double line2[];
extern int displaylength = 45;
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
{

SetIndexBuffer(0,dwn);
   SetIndexBuffer(1,uph);
SetIndexStyle(0,DRAW_ARROW,EMPTY,5,LawnGreen);
SetIndexArrow(0,238);
   SetIndexStyle(1,DRAW_ARROW,EMPTY,5,White);
SetIndexArrow(1,236);
SetIndexEmptyValue(0,EMPTY_VALUE);
SetIndexEmptyValue(1,EMPTY_VALUE);
   SetIndexEmptyValue(2,EMPTY_VALUE);

SetIndexBuffer(2,line1);
   SetIndexBuffer(3,line2);
SetIndexStyle(2,DRAW_ARROW,EMPTY,1,Pink);
SetIndexArrow(2,233);
    SetIndexStyle(3,DRAW_ARROW,EMPTY,1,Yellow);
SetIndexArrow(3,234);

SetIndexEmptyValue(3,EMPTY_VALUE);



   int y = 0;
   for(int x=1;x<3;x++)
      for( y=0;y<x;y++)
      {
         ObjectCreate("signal"+x+y,OBJ_LABEL,0,0,0,0,0);
         ObjectSet("signal"+x+y,OBJPROP_XDISTANCE,x*15+0);
         ObjectSet("signal"+x+y,OBJPROP_YDISTANCE,y*35+50);
         ObjectSetText("signal"+x+y,CharToStr(32),30,"Wingdings",Magenta);
      }
//---- indicators

    string short_name="Trade From... To... ";
   IndicatorShortName(short_name);

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

//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start()
{
   int    i,                     // Bar Index
          Counted_bars;             // Number of counted bars

double iHi[];
double iLo[];
double xHi[];
double xLo[];
string symbol = Symbol();
ArrayResize(SLKL, Bars);
ArrayInitialize(SLKL, 0);
ArrayResize(atr, Bars);
ArrayInitialize(atr, 0);
ArrayResize(atrc, Bars);
ArrayInitialize(atrc, 0);
ArrayResize(lastob, Bars);
ArrayInitialize(lastob, EMPTY_VALUE);
ArrayResize(lastos, Bars);
ArrayInitialize(lastos, EMPTY_VALUE);
ArrayResize(dwn, 3);
ArrayInitialize(dwn, EMPTY_VALUE);
ArrayResize(uph, 3);
ArrayInitialize(uph, EMPTY_VALUE);
ArrayResize(line1, displaylength );
ArrayInitialize(line1, EMPTY_VALUE);
ArrayResize(line2, displaylength );
ArrayInitialize(line2, EMPTY_VALUE);
//--------------------------------------------------------------------
   Counted_bars=IndicatorCounted(); // Number of counted bars

int counted_bars=IndicatorCounted();
double flickflock;

double dhi14 = iHigh(NULL,0,iHighest(NULL,0,MODE_HIGH,14,1));
double dlo14 = iLow(NULL,0,iLowest(NULL,0,MODE_LOW,14,1));

if ((dhi14-dlo14)/iClose(NULL,1440,1)<50) flickflock=(100-((dhi14-dlo14)/iClose(NULL,1440,1)))/10000;
else flickflock=((dhi14-dlo14)/iClose(NULL,1440,1)/10000);

   for (i = Bars ; i >= 0; i--) {
   if (95-iATR(NULL,60,5,i)<0) atrc[i]=iATR(NULL,60,5,i+1); else atrc[i]=iATR(NULL,60,5,i+1)*1.67;
    SLKL[i]=iStochastic(NULL,60,14,3,3,0,0,0,i);
// dwn[i]=EMPTY_VALUE;
//   uph[i]=EMPTY_VALUE;
   }


chc = ArrayMaximum(atr,WHOLE_ARRAY,1);
double divider = 90/atrc[chc];

for (i = 600 ; i >= 0; i--)   atr[i] = atrc[i]*divider;

for (i = 2 ; i >= 0; i--) {
    dwn[i] = iClose(NULL,1440,i+1)-flickflock;
   uph[i] = iClose(NULL,1440,i+1)+flickflock;
    }

for (i = 599 ; i >= 0; i--) {
   lastob[i]=lastob[i+1];
   if (SLKL[i+1]>80 && SLKL[i]<80 && atr[i+1]>55 && iClose(NULL,60,i+1)>iOpen(NULL,60,i+1)) lastob[i]=iClose(NULL,60,i+1);
   if (SLKL[i+1]>80 && SLKL[i]<80 && atr[i+1]>55 && iClose(NULL,60,i+1)<iOpen(NULL,60,i+1)) lastob[i]=iOpen(NULL,60,i+1);
   lastos[i]=lastos[i+1];
   if (SLKL[i+1]<20 && SLKL[i]>20 && atr[i+1]>55 && iClose(NULL,60,i+1)>iOpen(NULL,60,i+1)) lastos[i]=iOpen(NULL,60,i+1);
   if (SLKL[i+1]<20 && SLKL[i]>20 && atr[i+1]>55 && iClose(NULL,60,i+1)<iOpen(NULL,60,i+1)) lastos[i]=iClose(NULL,60,i+1);
}
// && atr[i+1]<35

for (i=0; i<=displaylength-1; i++) {
      if (lastob[i]>0) line1[i]=lastob[i];
      if (lastos[i]>0) line2[i]=lastos[1];     }


// ObjectSetText("signal10","atr[0]"+atr[0] ,140,"Tahoma",MidnightBlue);

      ObjectSetText("signal21","B.: "+(DoubleToString(lastos[0],4))+" To:"+(DoubleToString(uph[0],4)),20,"Tahoma",Cyan);


            ObjectSetText("signal20","S.: "+(DoubleToString(lastob[0],4))+" To:"+(DoubleToString(dwn[0],4)),20,"Tahoma",Tomato);



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

Where To? (GBP/CHF)

2017-07-01T01:42:00.003-07:00

We are at the R2, and kind of failing.

If we do not gap up, I would not look for much more upside for now. It may or may not coast to 1.2510+. The EMA channel's too steep, the 30 min energy is done for. Yet, a more pronounced step outside of the green channel would mean a blow off, that may be necessary.

4H Lema

The 4H energy could provide for a quite deep retracement.

There are two levels in the way of organic progression:

1.2381 & 1.2327.

Think of them as litters, that have to be picked up for clearing the stage.

In a runaway mode these events can be postponed a great deal, but then MMs would have to get creative and double down to be able to dump somewhere in the middle for a break even.
This is sort of what happened with the EUR/USD, the professional gap up was not an exhaustion gap, it was a conscious re-pricing, they ditched their shorts at an averaged down price, and although the charts still show levels untouched, they do not actually have to fill. It is not in their interest any more.

There was a scurry sell today, and a rip to a marginal higher high.

Volatility is still outside the envelopes.

The initial measured target has been met. (black oval)

The Trade From To Logic / TOS

def SLKL = reference StochasticFull(80, 20, 14, 3, high, low, close, 3, "SMA").FullK;
def dhi14 = Highest(high(period = "DAY"), 14);

def dlo14 = Lowest(low(period = "DAY"), 14);

def flickflock = if (dhi14 - dlo14) / (close(period = "DAY")[1]) < 50 then (100 - ((dhi14 - dlo14) / (close(period = "DAY")[1]))) / 10000 else ((dhi14 - dlo14) / (close(period = "DAY")[1])) / 10000;

plot uph = if (showOnlyToday and !IsNaN(close(period = "DAY")[-4])) then Double.NaN else flickflock * m + close(period = "DAY")[1];
uph.AssignValueColor(if CIDA[24] > CIDA and CIDA > 37 or CI < 37 then Color.DARK_GRAY else Color.ORANGE);
uph.SetPaintingStrategy(PaintingStrategy.TRIANGLES);
plot dwn = if (showOnlyToday and !IsNaN(close(period = "DAY")[-4])) then Double.NaN else close(period = "DAY")[1] - flickflock * m;
dwn.AssignValueColor(if CIDA[24] > CIDA and CIDA > 37 or CI < 37 then Color.DARK_GRAY else Color.CYAN);
dwn.SetPaintingStrategy(PaintingStrategy.TRIANGLES);

def chc = HighestAll(atrc) ;
def divider = 90 / chc;
def atr = atrc * divider;

def lastob = if SLKL[1] > 80 and atr[1]<55 and close[1]>open[1] then close[1] else if SLKL[1] > 80 and atr[1]<55 and close[1]<open[1] then open[1] else lastob[1];
def lastos = if SLKL[1] < 20 and atr[1]<55 and open[1]<close[1] then open[1] else if SLKL[1] < 20 and atr[1]<55 and open[1]>close[1] then close[1] else lastos[1];

AddLabel (close < lastob + .0045 * m, Concat(Concat("TRADE FROM ", lastob), Concat (" TO ", dwn)), Color.CYAN);
AddLabel (close > lastob - .0045 * m, Concat(Concat("TRADE FROM ", lastos), Concat (" TO ", uph)), Color.YELLOW);

The black arrow shows the channel target, that was filled. This was also the 30-min Lema.
It is worth mentioning that we are barely out of the oversold field - 1.2415.

The light blue marking and the similarly colored trend line can surely be a point of interest (1.2525ish) as a wave 5 target (also the 2-H Lema).

The image below shows the 4H energy bands. Basically they tell about how far the current 4H energy could carry the price (into the middle of the moat(s)).

The bottom band is that 1.233x again, while the upper band is just below 1.26.

We finished at support (black line), and a small gap up is a good probability here.

I'm guessing 2 tries up, before failing completely.
1) 1.2525 for a head
buy 1.2440
2) 1.2550+ for a last kiss

...
the LastOS values differ here, but for now I go with the benefit

With A Little Luck - MT4

2017-06-28T06:08:00.002-07:00

How can something crazy like this work?
With a little luck, and a little help from my friends....

I was experimenting to make something closer to the original Zigzag EMA channel that I have been plotting on TOS. Of course, I could not possibly have the same Zigzag Routine. So I opted for iFractals. It came with too many points. So I reached into my back pocket. I always carry some RSI with me, just in case.

As it turns out, Shamrock is just as good, and sometimes even better...

Please don't contact me about how many leaves a shamrock should have, for this may bring bad luck to you,,,

//+------------------------------------------------------------------+
//|                                             Shamrock by Macdulio |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2017, Macdulio"
#property link      "macdulio@yahoo.com"
#property link      "http://http://macdulio.blogspot.co.uk/"
#property indicator_chart_window
#property indicator_buffers 7

//---- indicator buffers
double ufr[];
double lfr[];
double uar[];
double lar[];
double E36[];
double E36Plus[];
double E36Minus[];
double HighBuffer[];
double LowBuffer[];
double HighBuffer2[];
double LowBuffer2[];
double udistance;
double ldistance;

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
{
     SetIndexBuffer(0,HighBuffer);
   SetIndexBuffer(1,LowBuffer);
   SetIndexStyle(0,DRAW_HISTOGRAM,STYLE_SOLID,4,MidnightBlue);
   SetIndexStyle(1,DRAW_HISTOGRAM,STYLE_SOLID,4,MidnightBlue);
   SetIndexBuffer(2,uar);
   SetIndexBuffer(3,lar);
   SetIndexStyle(2,DRAW_ARROW,EMPTY,9,Magenta);
   SetIndexStyle(3,DRAW_ARROW,EMPTY,9,Green);
   SetIndexArrow(2,124);
   SetIndexArrow(3,124);
   SetIndexBuffer(4,E36);
   SetIndexBuffer(5,E36Plus);
   SetIndexBuffer(6,E36Minus);
   SetIndexStyle(4,DRAW_LINE,EMPTY,5,Orange);
   SetIndexStyle(5,DRAW_LINE,EMPTY,10,Red);
   SetIndexStyle(6,DRAW_LINE,EMPTY,10,Blue);

//---- indicator short name
   IndicatorShortName("Shamrock ");
//---- initialization done
   return(0);
}
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int start()
{
   int    i;

ArrayResize(ufr, Bars);
   ArrayInitialize(ufr, EMPTY_VALUE);
   ArrayResize(lfr, Bars);
   ArrayInitialize(lfr, EMPTY_VALUE);
ArrayResize(uar, 350);
   ArrayInitialize(uar, EMPTY_VALUE);
   ArrayResize(lar, 350);
   ArrayInitialize(lar, EMPTY_VALUE);
ArrayResize(E36, 350);
   ArrayInitialize(E36, EMPTY_VALUE);
   ArrayResize(E36Plus, 350);
   ArrayInitialize(E36Plus, EMPTY_VALUE);
   ArrayResize(E36Minus, 350);
   ArrayInitialize(E36Minus, EMPTY_VALUE);


     for (i=0; i<=400; i++)
   {
        E36 [i] = iMA(NULL,0,36,0,MODE_EMA,PRICE_CLOSE,i);
        LowBuffer[i]=EMPTY_VALUE;
        HighBuffer[i]=EMPTY_VALUE;
        LowBuffer2[i]=EMPTY_VALUE;
        HighBuffer2[i]=EMPTY_VALUE;
            ufr[i]=iFractals(NULL,0,MODE_UPPER,i);
        //    Print("iFractals(NULL,0,MODE_UPPER,i)",iFractals(NULL,0,MODE_UPPER,i));
        lfr[i]=iFractals(NULL,0,MODE_LOWER,i);
       //   Print("iFractals(NULL,0,MODE_LOWER,i)",iFractals(NULL,0,MODE_LOWER,i));
   }

    for (i=299; i>=1; i--)
   {
   HighBuffer[i]=EMPTY_VALUE;
   LowBuffer[i]=EMPTY_VALUE;
     if (ufr[i]>0 && iRSI(NULL,0,12,PRICE_MEDIAN,i)>75){
        udistance=ufr[i]-E36[i];
        HighBuffer[i]=High[i];
        lar[i-1]=E36[i]-ldistance;
        LowBuffer[i]=E36[i]-ldistance;
         }
        else if (lfr[i]>0 && iRSI(NULL,0,12,PRICE_MEDIAN,i)<25){
        ldistance=E36[i]-lfr[i];
        HighBuffer[i]=E36[i]+udistance;
        LowBuffer[i]=Low[i];
        uar[i-1]=E36[i]+udistance;
        }
       E36Plus[i]=E36[i]+udistance;
          E36Minus[i]=E36[i]-ldistance;
   }

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

...

The Gathering - sounds like an 80's band - now on Vinyl, VHS & 4 Hours>

cyan is the new mercury!

RSI pick a direction

2017-06-23T08:40:00.001-07:00

For the first time I'm thinking about an EA that would browse through different pairs in search of RSI surge signals, then limit orders & execution.

if (t3_Oscil[i]>t3_Oscil[i+1]*1.4 && t3_Oscil[i+1]>32 ) hdn[i]=t3_Oscil[i+1];
if (t3_Oscil[i]<t3_Oscil[i+1]*.6 && t3_Oscil[i+1]<68 ) hup[i]=t3_Oscil[i+1];

(my finger's above the water, my feet can't touch the ground...)