dsl_-_rsx

Download script
Author: copyright© mladen
dsl_-_rsx

This script is designed for the MetaTrader trading platform to provide a specialized visual indicator known as "Discontinued Signal Lines RSI." It serves as an analytical tool that processes price data to identify trends and potential signal points.

Core Functionality

The script operates by analyzing historical price movements through several sophisticated layers:

  • Dynamic Price Selection: One of the script's primary features is its ability to interpret different types of "price" data. Instead of just looking at a simple closing price, it can be configured to calculate values based on various metrics, including High/Low averages, Typical prices, Weighted prices, or even complex Heikin Ashi (a Japanese candle charting style) variations. This allows for a smoother, less "noisy" view of market trends.
  • RSI-Based Momentum Tracking: The tool utilizes a Relative Strength Index (RSI) logic to gauge momentum. It calculates the speed and change of price movements over a specific timeframe (defined by the user).

Trend Identification Logic

The script doesn't just show raw numbers; it interprets them to identify specific market "states":

  1. Dynamic Level Tracking: It creates two internal tracking levels—one for upward trends (Upper) and one for downward trends (Lower). These levels adjust dynamically based on the RSI momentum.
  2. State Management: The tool constantly monitors whether the current price action is staying above its upper trend level, below its lower trend level, or moving between them.
  3. Signal Generation: By comparing the live momentum against these moving dynamic levels, the script identifies specific "states." When the conditions meet certain criteria (for example, a crossover of these dynamic bounds), it triggers the visual signals on your chart.

Visual Presentation and Cleaning

To ensure the chart remains readable for a human trader, the script includes a "Cleaning" logic:

  • Point Plotting: Rather than drawing messy, continuous lines that might clutter the screen, the script plots specific points of interest.
  • Smart Filtering: It features an automated cleaning system that manages these points, ensuring that only relevant data is displayed and that "ghost" points or overlapping signals are removed as new price information arrives.

Summary for Traders

In short, this tool acts as a sophisticated filter. It takes raw, erratic market prices, processes them through a variety of mathematical models (like Heikin Ashi or Weighted averages), compares that momentum against dynamic trend boundaries, and finally plots clean signal points to help you visualize where the trend is shifting or potentially "discontinuing."

6 Views
0 Downloads
0 Favorites
dsl_-_rsx 
ÿþ//------------------------------------------------------------------

#property copyright   "copyright© mladen"

#property description "discontinued signal lines rsi"

#property description "made by mladen"

#property link        "mladenfx@gmail.com"

#property link        "www.forex-station.com"

//------------------------------------------------------------------



#property indicator_separate_window

#property indicator_buffers 7

#property indicator_color1  clrDimGray

#property indicator_color2  clrDimGray

#property indicator_color3  clrSilver

#property indicator_color4  clrLimeGreen

#property indicator_color5  clrLimeGreen

#property indicator_color6  clrOrange

#property indicator_color7  clrOrange

#property indicator_style1  STYLE_DOT

#property indicator_style2  STYLE_DOT

#property indicator_width3  2

#property indicator_width4  2

#property indicator_width5  2

#property indicator_width6  2

#property indicator_width7  2

#property strict



//

//

//

//

//



enum enPrices

{

   pr_close,      // Close

   pr_open,       // Open

   pr_high,       // High

   pr_low,        // Low

   pr_median,     // Median

   pr_typical,    // Typical

   pr_weighted,   // Weighted

   pr_average,    // Average (high+low+open+close)/4

   pr_medianb,    // Average median body (open+close)/2

   pr_tbiased,    // Trend biased price

   pr_tbiased2,   // Trend biased (extreme) price

   pr_haclose,    // Heiken ashi close

   pr_haopen ,    // Heiken ashi open

   pr_hahigh,     // Heiken ashi high

   pr_halow,      // Heiken ashi low

   pr_hamedian,   // Heiken ashi median

   pr_hatypical,  // Heiken ashi typical

   pr_haweighted, // Heiken ashi weighted

   pr_haaverage,  // Heiken ashi average

   pr_hamedianb,  // Heiken ashi median body

   pr_hatbiased,  // Heiken ashi trend biased price

   pr_hatbiased2  // Heiken ashi trend biased (extreme) price

};



extern int      RsxPeriod = 32;       // Rsx period

extern enPrices RsxPrice  = pr_close; // Rsx price

extern double   RsxSignal = 32;       // Signal period



double val[],valua[],valub[],valda[],valdb[],levelu[],leveld[],state[];



//------------------------------------------------------------------

//

//------------------------------------------------------------------

//

//

//

//

//



int OnInit()

{

   IndicatorBuffers(8);

      SetIndexBuffer(0,levelu);

      SetIndexBuffer(1,leveld);

      SetIndexBuffer(2,val);

      SetIndexBuffer(3,valua);

      SetIndexBuffer(4,valub);

      SetIndexBuffer(5,valda);

      SetIndexBuffer(6,valdb);

      SetIndexBuffer(7,state);

   IndicatorShortName("dsl rsx ("+(string)RsxPeriod+", dsl period : "+(string)RsxSignal+")");

   return(INIT_SUCCEEDED);

}

void OnDeinit(const int reason) { return; }



//------------------------------------------------------------------

//

//------------------------------------------------------------------

//

//

//

//

//



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[])

{

   int limit=MathMax(rates_total-prev_calculated-1,0);



   //

   //

   //

   //

   //



   double alpha = 2.0/(1.0+RsxSignal);

      if (state[limit]== 1) CleanPoint(limit,valua,valub);

      if (state[limit]==-1) CleanPoint(limit,valda,valdb);

      int i=limit; for(; i>=0 && !_StopFlag; i--)

      {

         val[i]    = iRsi(getPrice(RsxPrice,open,close,high,low,i,Bars),RsxPeriod,i,Bars);

         levelu[i] = (i<Bars-1) ? (val[i]>50) ? levelu[i+1]+alpha*(val[i]-levelu[i+1]) : levelu[i+1] : 50;

         leveld[i] = (i<Bars-1) ? (val[i]<50) ? leveld[i+1]+alpha*(val[i]-leveld[i+1]) : leveld[i+1] : 50;

         state[i]  = (val[i]>levelu[i]) ? 1 : (val[i]<leveld[i]) ? -1 :  0;

         valda[i]  = EMPTY_VALUE;

         valdb[i]  = EMPTY_VALUE;

         valua[i]  = EMPTY_VALUE;

         valub[i]  = EMPTY_VALUE;

            if (state[i]== 1) PlotPoint(i,valua,valub,val);

            if (state[i]==-1) PlotPoint(i,valda,valdb,val);

      }

   return(rates_total-i-1);

}



//------------------------------------------------------------------

//

//------------------------------------------------------------------

//

//

//

//

//

//



#define _rsiInstances     1

#define _rsiInstancesSize 13

double workRsi[][_rsiInstances*_rsiInstancesSize];

#define _price  0

#define _change 1

#define _changa 2



double iRsi(double price, double period, int i, int bars, int instanceNo=0)

{

   if (ArrayRange(workRsi,0)!=bars) ArrayResize(workRsi,bars);

      int z = instanceNo*_rsiInstancesSize; 

      int r = bars-i-1;

   

   //

   //

   //

   //

   //

   

   workRsi[r][z+_price] = price;

      double Kg = (3.0)/(2.0+period), Hg = 1.0-Kg;

            if (r<1) { for (int k=1; k<13; k++) workRsi[r][k+z] = 0; return(50); }  



            //

            //

            //

            //

            //

      

            double mom = workRsi[r][_price+z]-workRsi[r-1][_price+z];

            double moa = MathAbs(mom);

            for (int k=0; k<3; k++)

            {

               int kk = k*2;

               workRsi[r][z+kk+1] = Kg*mom                + Hg*workRsi[r-1][z+kk+1];

               workRsi[r][z+kk+2] = Kg*workRsi[r][z+kk+1] + Hg*workRsi[r-1][z+kk+2]; mom = 1.5*workRsi[r][z+kk+1] - 0.5 * workRsi[r][z+kk+2];

               workRsi[r][z+kk+7] = Kg*moa                + Hg*workRsi[r-1][z+kk+7];

               workRsi[r][z+kk+8] = Kg*workRsi[r][z+kk+7] + Hg*workRsi[r-1][z+kk+8]; moa = 1.5*workRsi[r][z+kk+7] - 0.5 * workRsi[r][z+kk+8];

            }

            return(MathMax(MathMin((mom/MathMax(moa,DBL_MIN)+1.0)*50.0,100.00),0.00)); 

}



//------------------------------------------------------------------

//

//------------------------------------------------------------------

//

//

//

//

//

//



#define _priceInstances     1

#define _priceInstancesSize 4

double workHa[][_priceInstances*_priceInstancesSize];

double getPrice(int tprice, const double& open[], const double& close[], const double& high[], const double& low[], int i, int bars, int instanceNo=0)

{

  if (tprice>=pr_haclose)

   {

      if (ArrayRange(workHa,0)!= bars) ArrayResize(workHa,bars); instanceNo*=_priceInstancesSize; int r = bars-i-1;

         

         //

         //

         //

         //

         //

         

         double haOpen;

         if (r>0)

                haOpen  = (workHa[r-1][instanceNo+2] + workHa[r-1][instanceNo+3])/2.0;

         else   haOpen  = (open[i]+close[i])/2;

         double haClose = (open[i] + high[i] + low[i] + close[i]) / 4.0;

         double haHigh  = MathMax(high[i], MathMax(haOpen,haClose));

         double haLow   = MathMin(low[i] , MathMin(haOpen,haClose));



         if(haOpen  <haClose) { workHa[r][instanceNo+0] = haLow;  workHa[r][instanceNo+1] = haHigh; } 

         else                 { workHa[r][instanceNo+0] = haHigh; workHa[r][instanceNo+1] = haLow;  } 

                                workHa[r][instanceNo+2] = haOpen;

                                workHa[r][instanceNo+3] = haClose;

         //

         //

         //

         //

         //

         

         switch (tprice)

         {

            case pr_haclose:     return(haClose);

            case pr_haopen:      return(haOpen);

            case pr_hahigh:      return(haHigh);

            case pr_halow:       return(haLow);

            case pr_hamedian:    return((haHigh+haLow)/2.0);

            case pr_hamedianb:   return((haOpen+haClose)/2.0);

            case pr_hatypical:   return((haHigh+haLow+haClose)/3.0);

            case pr_haweighted:  return((haHigh+haLow+haClose+haClose)/4.0);

            case pr_haaverage:   return((haHigh+haLow+haClose+haOpen)/4.0);

            case pr_hatbiased:

               if (haClose>haOpen)

                     return((haHigh+haClose)/2.0);

               else  return((haLow+haClose)/2.0);        

            case pr_hatbiased2:

               if (haClose>haOpen)  return(haHigh);

               if (haClose<haOpen)  return(haLow);

                                    return(haClose);        

         }

   }

   

   //

   //

   //

   //

   //

   

   switch (tprice)

   {

      case pr_close:     return(close[i]);

      case pr_open:      return(open[i]);

      case pr_high:      return(high[i]);

      case pr_low:       return(low[i]);

      case pr_median:    return((high[i]+low[i])/2.0);

      case pr_medianb:   return((open[i]+close[i])/2.0);

      case pr_typical:   return((high[i]+low[i]+close[i])/3.0);

      case pr_weighted:  return((high[i]+low[i]+close[i]+close[i])/4.0);

      case pr_average:   return((high[i]+low[i]+close[i]+open[i])/4.0);

      case pr_tbiased:   

               if (close[i]>open[i])

                     return((high[i]+close[i])/2.0);

               else  return((low[i]+close[i])/2.0);        

      case pr_tbiased2:   

               if (close[i]>open[i]) return(high[i]);

               if (close[i]<open[i]) return(low[i]);

                                     return(close[i]);        

   }

   return(0);

}   



//-------------------------------------------------------------------

//                                                                  

//-------------------------------------------------------------------

//

//

//

//

//



void CleanPoint(int i,double& first[],double& second[])

{

   if (i>=Bars-2) return;

   if ((second[i]  != EMPTY_VALUE) && (second[i+1] != EMPTY_VALUE))

        second[i+1] = EMPTY_VALUE;

   else

      if ((first[i] != EMPTY_VALUE) && (first[i+1] != EMPTY_VALUE) && (first[i+2] == EMPTY_VALUE))

          first[i+1] = EMPTY_VALUE;

}



void PlotPoint(int i,double& first[],double& second[],double& from[])

{

   if (i>=Bars-2) return;

   if (first[i+1] == EMPTY_VALUE)

      if (first[i+2] == EMPTY_VALUE) 

            { first[i]  = from[i]; first[i+1]  = from[i+1]; second[i] = EMPTY_VALUE; }

      else  { second[i] = from[i]; second[i+1] = from[i+1]; first[i]  = EMPTY_VALUE; }

   else     { first[i]  = from[i];                          second[i] = EMPTY_VALUE; }

}

Similar scripts

dsl_-_rsi

This indicator synthesizes Relative Strength Index data with multi-variant price calculations, including Heikin Ashi and trend-biased metrics, to identify and plot directional momentum shifts.

dsl_-_DMI_oscillator

This indicator calculates the directional movement index to determine relative momentum, utilizing smoothed moving averages and dynamic threshold levels to visualize trend strength and color-coded signal transitions.

Mtf_SuperTrend nrp new

LSMA_NRP

This indicator identifies directional shifts by calculating the weighted difference between Linear Weighted and Simple Moving Averages to highlight momentum transitions.

PA_adaptive_MACD

This indicator calculates the difference between two Hilbert-transformed Exponential Moving Averages to identify momentum shifts, utilizing quantile and floating thresholds to signal trend reversals and pullbacks.

Volatility ratio

Simple Decycler Oscillator

Holt_double_exponential_smoothing_2.2

This indicator utilizes double exponential smoothing to calculate trend bias, slope dynamics, and a projected price horizon based on multi-variant price inputs.

SRsi

Hull moving average (ema based)

ATR adaptive SMA

Comments