mParabolic

Download script
Author: Copyright � 2004, MetaQuotes Software Corp.
mParabolic

This script is designed to function as a sophisticated trend-following tool for trading platforms. It calculates a dynamic "trailing" value that helps traders identify the direction of market momentum and potential reversal points. Instead of just moving with the price, it uses a mathematical logic to project a boundary that adapts to how aggressively the market is moving.

Core Logic and Functionality

Trend Detection and Direction The script monitors price action to determine if the market is in an "Upward" or "Downward" trend. It tracks high and low price points over time to establish a baseline. If the price breaks through certain calculated levels, the script flips its internal logic to recognize the new trend direction.

Dynamic Acceleration (The Parabolic Effect) What makes this specific logic unique is how it adjusts its sensitivity:

  • Acceleration: As a trend continues in a single direction, the gap between the price and the indicator's value narrows more quickly. It uses an "Acceleration Factor" that increases as long as the trend remains strong.
  • Deceleration/Reset: If the trend loses momentum or hits a certain limit (defined by the user), the acceleration slows down. If the price actually breaks through the calculated boundary, the script recognizes this as a trend exhaustion and resets its starting point to begin calculating the new trend from scratch.

Signal Generation The indicator identifies "Reversal" points visually. When the market fails to continue its current trajectory and crosses the trailing line:

  1. It captures the exact moment of the breach.
  2. It records the highest and lowest prices reached during that specific move.
  3. It updates the trend direction (e.g., switching from a "Buy" bias to a "Sell" bias).

Key Parameters for Usage

  • Step: This controls the initial speed of the calculation. A higher step will make the indicator more reactive to immediate price changes, while a lower step makes it smoother and less prone to "noise."
  • Maximum: This acts as a ceiling for the acceleration. It prevents the indicator from becoming too erratic during extremely volatile periods by capping how fast the curve can tighten.

Summary for the User

In simple terms, this tool acts like a "smart" trailing stop. It follows the price closely during strong moves to lock in potential gains but is designed to stay out of the way during minor fluctuations. When it eventually "trips" or reverses, it provides a clear signal that the current trend may be over and a new direction has begun.

Miscellaneous
Implements a curve of type %1
13 Views
0 Downloads
0 Favorites
mParabolic 
//+------------------------------------------------------------------+
//|                                                    Parabolic.mq4 |
//|                      Copyright © 2004, MetaQuotes Software Corp. |
//|                                       http://www.metaquotes.net/ |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2004, MetaQuotes Software Corp."
#property link      "http://www.metaquotes.net/"

#property indicator_chart_window
#property indicator_buffers 1
#property indicator_color1 Lime
//---- input parameters
extern double    Step=0.02;
extern double    Maximum=0.2;
//---- buffers
double SarBuffer[];
//----
int    save_lastreverse;
bool   save_dirlong;
double save_start;
double save_last_high;
double save_last_low;
double save_ep;
double save_sar;
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
  {
//---- indicators
   SetIndexStyle(0,DRAW_ARROW);
   SetIndexArrow(0,159);
   SetIndexBuffer(0,SarBuffer);
//----
   return(0);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void SaveLastReverse(int last,int dir,double start,double low,double high,double ep,double sar)
  {
   save_lastreverse=last;
   save_dirlong=dir;
   save_start=start;
   save_last_low=low;
   save_last_high=high;
   save_ep=ep;
   save_sar=sar;
  }
//+------------------------------------------------------------------+
//| Parabolic Sell And Reverse system                                |
//+------------------------------------------------------------------+
int start()
  {
   static bool first=true;
   bool   dirlong;
   double start,last_high,last_low;
   double ep,sar,price_low,price_high,price;
   int    i,counted_bars=IndicatorCounted();
//----
   if(Bars<3) return(0);
//---- initial settings
   i=Bars-2;
   if(counted_bars==0 || first)
     {
      first=false;
      dirlong=true;
      start=Step;
      last_high=-10000000.0;
      last_low=10000000.0;
      while(i>0)
        {
         save_lastreverse=i;
         price_low=Low[i];
         if(last_low>price_low)   last_low=price_low;
         price_high=High[i];
         if(last_high<price_high) last_high=price_high;
         if(price_high>High[i+1] && price_low>Low[i+1]) break;
         if(price_high<High[i+1] && price_low<Low[i+1]) { dirlong=false; break; }
         i--;
        }
      //---- initial zero
      int k=i;
      while(k<Bars)
        {
         SarBuffer[k]=0.0;
         k++;
        }
      //---- check further
      if(dirlong) { SarBuffer[i]=Low[i+1]; ep=High[i]; }
      else        { SarBuffer[i]=High[i+1]; ep=Low[i]; }
      i--;
     }
    else
     {
      i=save_lastreverse;
      start=save_start;
      dirlong=save_dirlong;
      last_high=save_last_high;
      last_low=save_last_low;
      ep=save_ep;
      sar=save_sar;
     }
//----
   while(i>=0)
     {
      price_low=Low[i];
      price_high=High[i];
      //--- check for reverse
      if(dirlong && price_low<SarBuffer[i+1])
        {
         SaveLastReverse(i,true,start,price_low,last_high,ep,sar);
         start=Step; dirlong=false;
         ep=price_low;  last_low=price_low;
         SarBuffer[i]=last_high;
         i--;
         continue;
        }
      if(!dirlong && price_high>SarBuffer[i+1])
        {
         SaveLastReverse(i,false,start,last_low,price_high,ep,sar);
         start=Step; dirlong=true;
         ep=price_high; last_high=price_high;
         SarBuffer[i]=last_low;
         i--;
         continue;
        }
      //---
      price=SarBuffer[i+1];
      sar=price+start*(ep-price);
      if(dirlong)
        {
         if(ep<price_high && (start+Step)<=Maximum) start+=Step;
         if(price_high<High[i+1] && i==Bars-2)  sar=SarBuffer[i+1];

         price=Low[i+1];
         if(sar>price) sar=price;
         price=Low[i+2];
         if(sar>price) sar=price;
         if(sar>price_low)
           {
            SaveLastReverse(i,true,start,price_low,last_high,ep,sar);
            start=Step; dirlong=false; ep=price_low;
            last_low=price_low;
            SarBuffer[i]=last_high;
            i--;
            continue;
           }
         if(ep<price_high) { last_high=price_high; ep=price_high; }
        }
      else
        {
         if(ep>price_low && (start+Step)<=Maximum) start+=Step;
         if(price_low<Low[i+1] && i==Bars-2)  sar=SarBuffer[i+1];

         price=High[i+1];
         if(sar<price) sar=price;
         price=High[i+2];
         if(sar<price) sar=price;
         if(sar<price_high)
           {
            SaveLastReverse(i,false,start,last_low,price_high,ep,sar);
            start=Step; dirlong=true; ep=price_high;
            last_high=price_high;
            SarBuffer[i]=last_low;
            i--;
            continue;
           }
         if(ep>price_low) { last_low=price_low; ep=price_low; }
        }
      SarBuffer[i]=sar;
      i--;
     }
//   sar=SarBuffer[0];
//   price=iSAR(NULL,0,Step,Maximum,0);
//   if(sar!=price) Print("custom=",sar,"   SAR=",price,"   counted=",counted_bars);
//   if(sar==price) Print("custom=",sar,"   SAR=",price,"   counted=",counted_bars);
//----
   //string tComment="UpTrend";
   //if(SarBuffer[0]>Ask) tComment="DownTrend";
   //Comment("SarBuffer[0]="+DoubleToStr(SarBuffer[0],4)+" "+tComment);
   return(0);
  }
//+------------------------------------------------------------------+

Similar scripts

Parabolic-close

This indicator calculates an adaptive trend line that dynamically adjusts its acceleration based on price extremes to identify structural shifts and momentum exhaustion points.

Parabolic_v2

This indicator utilizes a dynamic parabolic SAR algorithm to identify trend shifts by calculating accelerating price distances and plotting reversal signals based on extreme high and low extremes.

Parabolic_v1

This script calculates a trailing stop-loss logic that dynamically adjusts based on price extremes to identify trend exhaustion and structural reversals.

Parabolic

This indicator calculates a dynamic trailing stop level that accelerates based on price momentum and identifies trend reversal points by detecting breaches of the extrapolated parabolic boundary.

Parabolic_Alert_Mod_001

This indicator dynamically calculates a trailing stop-loss boundary that adjusts based on price extremes to trigger audible and email notifications upon trend exhaustion.

ParabolicM

This algorithm calculates an accelerating trailing boundary that detects trend exhaustion and price reversals by monitoring expansion limits and extreme value shifts.

digfiltr_982

The algorithm calculates four distinct weighted price averages using unique coefficient arrays to determine multi-layered trend momentum and directional shifts.

DigFiltr[1]

This indicator computes momentum dynamics by calculating the differential expansion between four distinct weighted price kernels of varying temporal depths.

DigFiltr_v1

This indicator computes four distinct weighted moving averages using pre-defined coefficients to identify directional momentum shifts between different time horizons.

DigFiltr

This indicator calculates four distinct price momentum profiles using unique weighted coefficient arrays of varying lookback periods to determine trend velocity and relative strength.

DigFiltr_v2

Comments