Up_Down_v3

Download script
Author:
Up_Down_v3

This script is a specialized technical analysis tool designed to identify price action trends and potential reversal points by analyzing historical highs and lows across various timeframes. Instead of relying on standard moving averages, it focuses on "peaks" and "valleys" to determine market direction.

Core Logic Overview

The indicator works by scanning the historical chart data to find significant price extremes (the highest highs and lowest lows) within specific segments of time. It calculates an average level based on these extremes to create a boundary for price movement. If the current market price breaches these boundaries, the script provides a visual signal to indicate an "Up" or "Down" sentiment.

Key Functional Components

1. Timeframe Specificity The script is programmed with unique logic for different trading periods. It behaves differently depending on which timeframe you are viewing:

  • Short-Term (5, 15 minutes): Focuses on hourly transitions to find price shifts.
  • Medium-Term (30, 60 minutes): Looks for specific four-hour intervals throughout the day.
  • Long-Term (240 minutes, Daily, Weekly, Monthly): Adjusts its sensitivity to track daily closes, weekly transitions, and monthly shifts.

2. High/Low Identification For every period defined above, the script scans back through a set number of bars to identify "Highest Highs" and "Lowest Lows." It takes these extreme points and calculates a mathematical average (the "MaH" and "MaL" values). This creates a dynamic zone that represents where the price has historically struggled to move past or stay above.

3. Spread Accounting To ensure accuracy in real-market conditions, the logic incorporates the "spread" (the difference between the buy and sell price). This ensures that the signals aren't triggered by minor noise but rather by actual price movement relative to the market's liquidity.

4. Signal Generation (Up & Down) The script interprets the relationship between the current closing price and these calculated averages:

  • Down Signal: If the price falls below the calculated average of recent lows, it triggers a specific visual indicator (represented by the tomato-colored arrow).
  • Up Signal: If the price rises above the calculated average of recent highs, it triggers a different visual indicator (represented by the lime-colored arrow).

Summary for the User

Essentially, this tool acts as a "Smart Boundary" tracker. It ignores standard price noise and looks only at significant historical peaks and valleys. By identifying when the price breaks away from these established averages on specific timeframes (like the start of a new day or month), it helps traders visualize whether the current momentum is leaning towards an upward or downward trend.

Miscellaneous
Implements a curve of type %1
11 Views
0 Downloads
0 Favorites
Up_Down_v3 
//+------------------------------------------------------------------+
//|                                                      Up&Down.mq4 |
//|                                                                  |
//|                                                                  |
//+------------------------------------------------------------------+
#property copyright ""
#property link      ""
//----
#property indicator_chart_window
#property indicator_buffers 2
#property indicator_color1 Lime
#property indicator_color2 Tomato
//---- input parameters
extern int       HL_period=3;
extern int       NumBars=200;
//---- buffers
double ExtMapBuffer1[];
double ExtMapBuffer2[];
//------
double ur[][2];
int h1[];
int l1[];
int hh=0;
int ll=0;
//----
double spread;
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
  {
//---- indicators
   SetIndexStyle(0,DRAW_ARROW);
   SetIndexArrow(0,159);
   SetIndexBuffer(0,ExtMapBuffer1);
   SetIndexEmptyValue(0,0.0);
   SetIndexStyle(1,DRAW_ARROW);
   SetIndexArrow(1,159);
   SetIndexBuffer(1,ExtMapBuffer2);
   SetIndexEmptyValue(1,0.0);
//----
   ArrayResize(ur,NumBars+1);
   ArrayResize(h1,HL_period);
   ArrayResize(l1,HL_period);
//----
   spread=Ask-Bid;
   return(0);
  }
//+------------------------------------------------------------------+
//| Custor indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit()
  {
//---- 
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start()
  {
   int   n,shift,Nbar,k,mm;
   double MaH,MaL;
//---- 
   if(Period()==5 )
     {
      ArrayInitialize(ur,0);
      ArrayInitialize(h1,0);
      ArrayInitialize(l1,0);
      for( shift=NumBars; shift>=0; shift-- )
        {
         if(TimeHour(Time[shift + 1])!=TimeHour(Time[shift]) )
           {
            Nbar=-1;
            k=0;
            mm=0;
            n=shift - 15;
            while( n<=shift + HL_period * 12 + 5 )
              {
               if(n < 0 )
                 {
                  n=1;
                  Nbar=0;
                 }
               if(TimeHour(Time[n + 1])!=TimeHour(Time[n]) && Nbar==-1 )
                 {
                  Nbar=n;
                  mm=n;
                  n++;
                  continue;
                 }
               if(TimeHour(Time[n + 1])!=TimeHour(Time[n]) && Nbar!=-1 )
                 {
                  h1[k]=Highest(NULL,0,MODE_HIGH,n - Nbar,n-(n-Nbar)+1);
                  l1[k]=Lowest(NULL,0,MODE_LOW,n - Nbar,n-(n-Nbar)+1);
                  k++;
                  Nbar=n;
                 }
               n++;
              }
            MaH=0;
            MaL=0;
            for( n=0; n<HL_period; n++ )
              {
               MaH=MaH + High[h1[n]]+spread;
               MaL=MaL + Low[l1[n]];
              }
            MaH=MaH/HL_period;
            MaL=MaL/HL_period;
            ur[shift][0]=MaH;
            ur[shift][1]=MaL;
            if(Close[mm + 1]+spread/2>=MaH){ ll=1; hh=0; }
            if(Close[mm + 1]+spread/2<=MaL){ hh=1; ll=0; }
           }
         if(ur[shift,1]==0 )
           {
            ur[shift][0]=ur[shift + 1][0];
            ur[shift][1]=ur[shift + 1][1];
           }
         if(ll==1 )
           {
            ExtMapBuffer2[shift]=0;
            ExtMapBuffer1[shift]=ur[shift][1];
           }
         if(hh==1 )
           {
            ExtMapBuffer1[shift]=0;
            ExtMapBuffer2[shift]=ur[shift][0];
           }
        }
      return(0);
     }
//-----------------------------
   if(Period()==15 )
     {
      ArrayInitialize(ur,0);
      ArrayInitialize(h1,0);
      ArrayInitialize(l1,0);
      for( shift=NumBars; shift>=0; shift-- )
        {
         if(TimeHour(Time[shift + 1])!=TimeHour(Time[shift]) )
           {
            Nbar=-1;
            k=0;
            mm=0;
            n=shift - 5;
            while( n<=shift + HL_period * 4 + 2 )
              {
               if(n < 0 )
                 {
                  n=1;
                  Nbar=0;
                 }
               if(TimeHour(Time[n + 1])!=TimeHour(Time[n]) && Nbar==-1 )
                 {
                  Nbar=n;
                  mm=n;
                  n++;
                  continue;
                 }
               if(TimeHour(Time[n + 1])!=TimeHour(Time[n]) && Nbar!=-1 )
                 {
                  h1[k]=Highest(NULL,0,MODE_HIGH,n - Nbar,n-(n-Nbar)+1);
                  l1[k]=Lowest(NULL,0,MODE_LOW,n - Nbar,n-(n-Nbar)+1);
                  k++;
                  Nbar=n;
                 }
               n++;
              }
            MaH=0;
            MaL=0;
            for( n=0; n<HL_period; n++ )
              {
               MaH=MaH + High[h1[n]]+spread;
               MaL=MaL + Low[l1[n]];
              }
            MaH=MaH/HL_period;
            MaL=MaL/HL_period;
            ur[shift][0]=MaH;
            ur[shift][1]=MaL;
            if(Close[mm + 1]+spread/2>=MaH){ ll=1; hh=0; }
            if(Close[mm + 1]+spread/2<=MaL){ hh=1; ll=0; }
           }
         if(ur[shift,1]==0 )
           {
            ur[shift][0]=ur[shift + 1][0];
            ur[shift][1]=ur[shift + 1][1];
           }
         if(ll==1 )
           {
            ExtMapBuffer2[shift]=0;
            ExtMapBuffer1[shift]=ur[shift][1];
           }
         if(hh==1 )
           {
            ExtMapBuffer1[shift]=0;
            ExtMapBuffer2[shift]=ur[shift][0];
           }
        }
      return(0);
     }
//-------------------------
   if(Period()==30 )
     {
      ArrayInitialize(ur,0);
      ArrayInitialize(h1,0);
      ArrayInitialize(l1,0);
      for( shift=NumBars; shift>=0; shift-- )
        {
         if(TimeMinute(Time[shift])==0 && (TimeHour(Time[shift])==0 || TimeHour(Time[shift])==4 || TimeHour(Time[shift])==8 || TimeHour(Time[shift])==12 || TimeHour(Time[shift])==16 || TimeHour(Time[shift])==20) )
           {
            Nbar=-1;
            k=0;
            mm=0;
            n=shift - 10;
            while( n<=shift + HL_period * 8 + 5 )
              {
               if(n < 0 )
                 {
                  n=1;
                  Nbar=0;
                 }
               if(TimeMinute(Time[n])==0 && (TimeHour(Time[n])==0 || TimeHour(Time[n])==4 || TimeHour(Time[n])==8 || TimeHour(Time[n])==12 || TimeHour(Time[n])==16 || TimeHour(Time[n])==20) && Nbar==-1 )
                 {
                  Nbar=n;
                  mm=n;
                  n++;
                  continue;
                 }
               if(TimeMinute(Time[n])==0 && (TimeHour(Time[n])==0 || TimeHour(Time[n])==4 || TimeHour(Time[n])==8 || TimeHour(Time[n])==12 || TimeHour(Time[n])==16 || TimeHour(Time[n])==20) && Nbar!=-1 )
                 {
                  h1[k]=Highest(NULL,0,MODE_HIGH,n - Nbar,n-(n-Nbar)+1);
                  l1[k]=Lowest(NULL,0,MODE_LOW,n - Nbar,n-(n-Nbar)+1);
                  k++;
                  Nbar=n;
                 }
               n++;
              }
            MaH=0;
            MaL=0;
            for( n=0; n<HL_period; n++ )
              {
               MaH=MaH + High[h1[n]]+spread;
               MaL=MaL + Low[l1[n]];
              }
            MaH=MaH/HL_period;
            MaL=MaL/HL_period;
            ur[shift][0]=MaH;
            ur[shift][1]=MaL;
            if(Close[mm + 1]+spread/2>=MaH){ ll=1; hh=0; }
            if(Close[mm + 1]+spread/2<=MaL){ hh=1; ll=0; }
           }
         if(ur[shift,1]==0 )
           {
            ur[shift][0]=ur[shift + 1][0];
            ur[shift][1]=ur[shift + 1][1];
           }
         if(ll==1 )
           {
            ExtMapBuffer2[shift]=0;
            ExtMapBuffer1[shift]=ur[shift][1];
           }
         if(hh==1 )
           {
            ExtMapBuffer1[shift]=0;
            ExtMapBuffer2[shift]=ur[shift][0];
           }
        }
      return(0);
     }
//----
   if(Period()==60 )
     {
      ArrayInitialize(ur,0);
      ArrayInitialize(h1,0);
      ArrayInitialize(l1,0);
      for( shift=NumBars; shift>=0; shift-- )
        {
         if(TimeMinute(Time[shift])==0 && (TimeHour(Time[shift])==0 || TimeHour(Time[shift])==4 || TimeHour(Time[shift])==8 || TimeHour(Time[shift])==12 || TimeHour(Time[shift])==16 || TimeHour(Time[shift])==20) )
           {
            Nbar=-1;
            k=0;
            mm=0;
            n=shift - 6;
            while( n<=shift + HL_period * 4 + 3 )
              {
               if(n < 0 )
                 {
                  Nbar=0;
                  n=1;
                 }
               if(TimeMinute(Time[n])==0 && (TimeHour(Time[n])==0 || TimeHour(Time[n])==4 || TimeHour(Time[n])==8 || TimeHour(Time[n])==12 || TimeHour(Time[n])==16 || TimeHour(Time[n])==20) && Nbar==-1 )
                 {
                  Nbar=n;
                  mm=n;
                  n++;
                  continue;
                 }
               if(TimeMinute(Time[n])==0 && (TimeHour(Time[n])==0 || TimeHour(Time[n])==4 || TimeHour(Time[n])==8 || TimeHour(Time[n])==12 || TimeHour(Time[n])==16 || TimeHour(Time[n])==20) && Nbar!=-1 )
                 {
                  h1[k]=Highest(NULL,0,MODE_HIGH,n - Nbar,n-(n-Nbar)+1);
                  l1[k]=Lowest(NULL,0,MODE_LOW,n - Nbar,n-(n-Nbar)+1);
                  k++;
                  Nbar=n;
                 }
               n++;
              }
            MaH=0;
            MaL=0;
            for( n=0; n<HL_period; n++ )
              {
               MaH=MaH + High[h1[n]]+spread;
               MaL=MaL + Low[l1[n]];
              }
            MaH=MaH/HL_period;
            MaL=MaL/HL_period;
            ur[shift][0]=MaH;
            ur[shift][1]=MaL;
            if(Close[mm + 1]+spread/2>=MaH){ ll=1; hh=0; }
            if(Close[mm + 1]+spread/2<=MaL){ hh=1; ll=0; }
           }
         if(ur[shift,1]==0 )
           {
            ur[shift][0]=ur[shift + 1][0];
            ur[shift][1]=ur[shift + 1][1];
           }
         if(ll==1 )
           {
            ExtMapBuffer2[shift]=0;
            ExtMapBuffer1[shift]=ur[shift][1];
           }
         if(hh==1 )
           {
            ExtMapBuffer1[shift]=0;
            ExtMapBuffer2[shift]=ur[shift][0];
           }
        }
      return(0);
     }
//--------------  
   if(Period()==240 )
     {
      ArrayInitialize(ur,0);
      ArrayInitialize(h1,0);
      ArrayInitialize(l1,0);
      for( shift=NumBars; shift>=0; shift-- )
        {
         if(TimeDay(Time[shift + 1])!=TimeDay(Time[shift]) )
           {
            Nbar=-1;
            k=0;
            mm=0;
            n=shift - 8;
            while( n<=shift + HL_period * 8 + 4 )
              {
               if(n < 0 )
                 {
                  Nbar=0;
                  n=1;
                 }
               if(TimeDay(Time[n + 1])!=TimeDay(Time[n]) && Nbar==-1 )
                 {
                  Nbar=n;
                  mm=n;
                  n++;
                  continue;
                 }
               if(TimeDay(Time[n + 1])!=TimeDay(Time[n]) && Nbar!=-1 )
                 {
                  h1[k]=Highest(NULL,0,MODE_HIGH,n - Nbar,n-(n-Nbar)+1);
                  l1[k]=Lowest(NULL,0,MODE_LOW,n - Nbar,n-(n-Nbar)+1);
                  k++;
                  Nbar=n;
                 }
               n++;
              }
            MaH=0;
            MaL=0;
            for( n=0; n<HL_period; n++ )
              {
               MaH=MaH + High[h1[n]]+spread;
               MaL=MaL + Low[l1[n]];
              }
            MaH=MaH/HL_period;
            MaL=MaL/HL_period;
            ur[shift][0]=MaH;
            ur[shift][1]=MaL;
            if(Close[mm + 1]+spread/2>=MaH){ ll=1; hh=0; }
            if(Close[mm + 1]+spread/2<=MaL){ hh=1; ll=0; }
           }
         if(ur[shift,1]==0 )
           {
            ur[shift][0]=ur[shift + 1][0];
            ur[shift][1]=ur[shift + 1][1];
           }
         if(ll==1 )
           {
            ExtMapBuffer2[shift]=0;
            ExtMapBuffer1[shift]=ur[shift][1];
           }
         if(hh==1 )
           {
            ExtMapBuffer1[shift]=0;
            ExtMapBuffer2[shift]=ur[shift][0];
           }
        }
      return(0);
     }
//----
   if(Period()==1440 )
     {
      ArrayInitialize(ur,0);
      ArrayInitialize(h1,0);
      ArrayInitialize(l1,0);
      for( shift=NumBars; shift>=0; shift-- )
        {
         if(TimeDayOfWeek(Time[shift + 1])==5 && TimeDayOfWeek(Time[shift])==1 )
           {
            Nbar=-1;
            k=0;
            mm=0;
            n=shift - 6;
            while( n<=shift + HL_period * 5 + 3 )
              {
               if(n < 0 )
                 {
                  Nbar=0;
                  n=1;
                 }
               if(TimeDayOfWeek(Time[n + 1])==5 && TimeDayOfWeek(Time[n])==1 && Nbar==-1 )
                 {
                  Nbar=n;
                  mm=n;
                  n++;
                  continue;
                 }
               if(TimeDayOfWeek(Time[n + 1])==5 && TimeDayOfWeek(Time[n])==1 && Nbar!=-1 )
                 {
                  h1[k]=Highest(NULL,0,MODE_HIGH,n - Nbar,n-(n-Nbar)+1);
                  l1[k]=Lowest(NULL,0,MODE_LOW,n - Nbar,n-(n-Nbar)+1);
                  k++;
                  Nbar=n;
                 }
               n++;
              }
            MaH=0;
            MaL=0;
            for( n=0; n<HL_period; n++ )
              {
               MaH=MaH + High[h1[n]]+spread;
               MaL=MaL + Low[l1[n]];
              }
            MaH=MaH/HL_period;
            MaL=MaL/HL_period;
            ur[shift][0]=MaH;
            ur[shift][1]=MaL;
            if(Close[mm + 1]+spread/2>=MaH){ ll=1; hh=0; }
            if(Close[mm + 1]+spread/2<=MaL){ hh=1; ll=0; }
           }
         if(ur[shift,1]==0 )
           {
            ur[shift][0]=ur[shift + 1][0];
            ur[shift][1]=ur[shift + 1][1];
           }
         if(ll==1 )
           {
            ExtMapBuffer2[shift]=0;
            ExtMapBuffer1[shift]=ur[shift][1];
           }
         if(hh==1 )
           {
            ExtMapBuffer1[shift]=0;
            ExtMapBuffer2[shift]=ur[shift][0];
           }
        }
      return(0);
     }
//----
   if(Period()==10080 )
     {
      ArrayInitialize(ur,0);
      ArrayInitialize(h1,0);
      ArrayInitialize(l1,0);
      for( shift=NumBars; shift>=0; shift-- )
        {
         if(TimeMonth(Time[shift + 1]+1440*60)!=TimeMonth(Time[shift]+1440*60) )
           {
            Nbar=-1;
            k=0;
            mm=0;
            n=shift - 8;
            while( n<=shift + HL_period * 8 + 4 )
              {
               if(n < 0 )
                 {
                  Nbar=0;
                  n=1;
                 }
               if(TimeMonth(Time[n + 1]+1440*60)!=TimeMonth(Time[n]+1440*60) && Nbar==-1 )
                 {
                  Nbar=n;
                  mm=n;
                  if(n>NumBars-18)Print(TimeToStr(Time[n]));
                  n++;
                  continue;
                 }
               if(TimeMonth(Time[n + 1]+1440*60)!=TimeMonth(Time[n]+1440*60) && Nbar!=-1 )
                 {
                  h1[k]=Highest(NULL,0,MODE_HIGH,n - Nbar,n-(n-Nbar)+1);
                  l1[k]=Lowest(NULL,0,MODE_LOW,n - Nbar,n-(n-Nbar)+1);
                  k++;
                  Nbar=n;
                 }
               n++;
              }
            MaH=0;
            MaL=0;
            for( n=0; n<HL_period; n++ )
              {
               MaH=MaH + High[h1[n]]+spread;
               MaL=MaL + Low[l1[n]];
              }
            MaH=MaH/HL_period;
            MaL=MaL/HL_period;
            ur[shift][0]=MaH;
            ur[shift][1]=MaL;
            if(Close[mm + 1]+spread/2>=MaH){ ll=1; hh=0; }
            if(Close[mm + 1]+spread/2<=MaL){ hh=1; ll=0; }
           }
         if(ur[shift,1]==0 )
           {
            ur[shift][0]=ur[shift + 1][0];
            ur[shift][1]=ur[shift + 1][1];
           }
         if(ll==1 )
           {
            ExtMapBuffer2[shift]=0;
            ExtMapBuffer1[shift]=ur[shift][1];
           }
         if(hh==1 )
           {
            ExtMapBuffer1[shift]=0;
            ExtMapBuffer2[shift]=ur[shift][0];
           }
        }
      return(0);
     }
//----
   return(0);
  }
//+------------------------------------------------------------------+

Similar scripts

Up_Down

This indicator identifies trend reversals by calculating the average of highest highs and lowest lows across specific chronological anchors like hourly, daily, or monthly transitions.

UP&Down

This indicator identifies structural support and resistance levels by calculating the moving average of historical highs and lows across specific timeframes like hourly, daily, and monthly transitions.

Up_Down_v1

This indicator identifies structural pivot points by calculating the arithmetic mean of extreme price highs and lows across specific chronological sessions.

HL_Activator_NEXT

This indicator identifies significant price breakouts by calculating the rolling average of historical high and low extremes across specific time intervals (hourly, daily, weekly, and monthly) and plotting visual signals when the close price pierces these levels.

BrainTrend1StopLine

BrainTrend1StopLine C

BrainTrend1StopLine_v1

BrainTrend1StopLine C_v1

ZZ_pS_v[1].0.4

This indicator identifies structural trend shifts and price pivot points by analyzing the interplay between historical ZigZag extremes and immediate price action to project directional signals.

up_down_alert

This indicator identifies directional shift alerts by calculating localized high and low pivot averages across specific timeframes and triggering signals when price closes outside these calculated bounds.

^Dyn_Pivot

This indicator calculates and projects daily pivot points based on alternating high, low, and closing price formulas to identify intraday structural levels.

Comments