Inverse Fisher Transform of RSIm

Download script
Author: Treberkn\'s Conversion
Inverse Fisher Transform of RSIm

This script is a custom financial technical indicator designed to analyze price momentum by combining three distinct mathematical processes: the Relative Strength Index (RSI), a Weighted Moving Average (WMA), and an Inverse Fisher Transform.

The logic follows a linear pipeline to transform raw price data into a smoothed, bounded signal:

1. Base Momentum Calculation (RSI)

The process begins by looking at the change in closing prices over a user-defined period. It calculates the "Relative Strength" by comparing upward price movements against downward price movements. This creates a standard RSI value, which typically fluctuates between 0 and 100, representing how fast and strongly an asset is moving in a specific direction.

2. Normalization and Smoothing

Because a standard RSI can be volatile, the script performs two specific refinements:

  • Scaling: The RSI value is shifted and scaled so that it centers around zero. This makes it easier to identify directional bias (positive vs. negative).
  • Weighted Smoothing: The script then applies a Weighted Moving Average (WMA). Unlike a simple average where all past data points carry equal weight, this method gives more importance to the most recent price actions. This helps filter out "market noise" and prevents the indicator from reacting too erratically to minor price fluctuations.

3. The Inverse Fisher Transform

The final stage applies an Inverse Fisher Transform to the smoothed data. In technical analysis, this mathematical formula is used to take values that might have a wide range and "compress" them into a much tighter, more defined boundary (typically between -1 and 1). This transformation helps highlight when a trend is reaching an extreme point or beginning to reverse, making it easier for a user to spot significant turning points.

4. Visual Output and Triggers

The script produces two primary visual elements on the chart:

  • The Signal Line: This is the final transformed value, showing the smoothed momentum of the asset.
  • The Trigger Line: The script automatically plots a "trigger" based on your settings. It identifies whether the signal has crossed above or below specific thresholds (High and Low triggers).

Summary for the User: Essentially, this tool takes raw price data, calculates its strength, smooths out the vibrations of the market, and then mathematically "tightens" that data into a clear visual signal. It is designed to help you see whether momentum is accelerating or exhausting without the clutter of standard, unadjusted indicators.

Indicators Used
Relative strength index
Miscellaneous
Implements a curve of type %1It issuies visual alerts to the screen
11 Views
0 Downloads
0 Favorites
Inverse Fisher Transform of RSIm
//+------------------------------------------------------------------+
//|                              Inverse Fisher Transform of RSI.mq4 |
//|                                             Treberk's Conversion |
//|                                             Treberk's Conversion |
//+------------------------------------------------------------------+
#property copyright "Treberkn\'s Conversion"
#property link      "Treberk\'s Conversion"

#property indicator_separate_window
#property indicator_buffers 2
#property indicator_color1 DimGray
#property indicator_color2 Red


//Inputs
 extern double  HiTrigger= 0.5; // default= 0.5
 extern double  LoTrigger=-0.5; // default=-0.5
 extern int  RsiBars=5; // default=5
 extern int  WmaBars=9; // default=9
 extern bool  info    =false; // default=0
 extern bool  zer0Bar =false; // default=0


//---- buffers
double ExtMapBuffer1[];
double ExtMapBuffer2[];
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
  {
//---- indicators
   SetIndexStyle(0,DRAW_LINE);
   SetIndexBuffer(0,ExtMapBuffer2);
   SetIndexStyle(1,DRAW_LINE);
   SetIndexBuffer(1,ExtMapBuffer1);
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| Custor indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit()
  {
//---- 
   
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start()
  {
   int    counted_bars=IndicatorCounted();
//---- 
   
    // SetLoopCount(0);
//--------------------------------------------------------

//Variables: // Generic
int  shift;
int  loopBegin;
bool is_First=True;
double   prevbars;
int   count;

//Variables: // Specific
//   Name(\"InvFisher RSI\"),
double   Value2;
double    IFish;
   // for manual calc. RSI
double    SumUp;
double    SumDn;
double    AvgUp;
double    AvgDn;
double   Delta;
double   RSI;
   // for calc. WMA
double   WmaNumerator;
double   WmaDenominator;
datetime LastTime;
double   PrevAvgUp;
double   PrevAvgDn;
int      cntdown;
   
//Arrays:
   // for ( calc. generic WMA (weighted moving average)
   double Value1[40];
   



// Usage
/*[if (info ) {
   Alert(\"See Terminal>Journal Tab for ( usage of \\n\",Name);
   Print(\"|___________________\");
   Print(\"|* \",Name,\" *\");
   Print(\"|  \",\"Sell: cross under HiTrigger (or under LoTrigger if (no prior cross under  HiTrigger)\");
   Print(\"|  \",\"Buy: cross over LoTrigger (or over HiTrigger if (no prior cross over LoTrigger)\");
   Print(\"|* \",Name,\" *\");
   Print(\"|```````````````````\");
   }]*/
//--------------------------------------------------------

// Check Inputs
if (0>HiTrigger || HiTrigger>1 ) {
   Alert("Input Error:  must be 0< HiTrigger <1, Cannot=",HiTrigger);
   return(0);
}
if (-1>LoTrigger || LoTrigger>0 ) {
   Alert("Input Error:  must be -1< LoTrigger <0, Cannot=",LoTrigger);
   return(0);
}
if (0>RsiBars || RsiBars>50 ) {
   Alert("Input Error:  must be 0< RsiBars <50, Cannot=",RsiBars);
   return(0);
}
//--------------------------------------------------------

// Check for ( additional bars loading or total reloadng.
if (Bars<prevbars || Bars-prevbars>1 ) is_First=True;
prevbars=Bars;
//--------------------------------------------------------

// Pre-Loop setup
// loopbegin prevents counting of previously plotted bars excluding current Bars 
if (is_First ) {
   loopBegin=Bars-1-1;// BarIndexNumber=Shift=Bars-1...0

   // Compute the initial AvgUp & AvgDn for RSI
   for ( shift=loopBegin; shift>=loopBegin-RsiBars; shift--) {
      Delta=Close[shift]-Close[shift+1];
      SumUp=SumUp+MathMax(0,Delta);
      SumDn=SumDn-MathMin(0,Delta);
   }
   AvgUp=SumUp/RsiBars;
   AvgDn=SumDn/RsiBars;
   loopBegin=loopBegin-RsiBars;
}
//--------------------------------------------------------

// loop from loopbegin to current bar (shift=0)
if (! is_First ) {
   if ((Time[0]!=LastTime) ) {
     PrevAvgUp = AvgUp;
     PrevAvgDn = AvgDn;
     AvgUp = 0;
     AvgDn = 0;
     for ( count=WmaBars-1; count>=1; count--) {
        Value1[count]=Value1[count-1];
     }
     LastTime = Time[0];
   }
} else {
       if(zer0Bar)cntdown = 0; else  cntdown = 1;
       }

for ( shift=loopBegin; shift>=cntdown; shift--) {
   // Calc RSI manually
   Delta=Close[shift]-Close[shift+1];
   if (is_First ) {
     AvgUp=((RsiBars-1)*AvgUp+MathMax(0,Delta))/RsiBars;
     AvgDn=((RsiBars-1)*AvgDn-MathMin(0,Delta))/RsiBars;
   } else {
     AvgUp=((RsiBars-1)*PrevAvgUp+MathMax(0,Delta))/RsiBars;
     AvgDn=((RsiBars-1)*PrevAvgDn-MathMin(0,Delta))/RsiBars;
   }
   RSI=100-100/(1+AvgUp/AvgDn);
   // ) scale RSI to between -5 and +5
   /* Do not use iRSI fctn because it\'s too slow
   Value1=0.1*(iRSI(RsiBars,shift)-50); */
   Value1[0]=0.1*(RSI-50);

   // Use weighted moving average to smooth Value1.
   // Ehler suggests could also use EMA, which would be simpler coding at the expense of Alpha.
   WmaNumerator=0;
   WmaDenominator=0;
   for ( count=WmaBars; count>= 1; count--) {
      WmaNumerator=WmaNumerator+count*Value1[WmaBars-count-1];
      WmaDenominator=WmaDenominator+count;
   }
   Value2=WmaNumerator/WmaDenominator;
   IFish=(MathExp(2*Value2)-1)/(MathExp(2*Value2)+1); 

   ExtMapBuffer1[shift]=IFish;
//   SetIndexValue[shift]=RSI;

   // Plot dual-value Trigger Line
   if (IFish >0 )
      ExtMapBuffer2[shift]=HiTrigger;
   else
      ExtMapBuffer2[shift]=LoTrigger;
   //--------------------------------------------------------

   // Update arrays.  This technique minimizes array storage and thus allows more signal bars.
   if (is_First ) for ( count=WmaBars-1; count>= 1; count--) {
      Value1[count]=Value1[count-1];
   }
   //--------------------------------------------------------
}

is_First = False;
cntdown = 0;
loopBegin = 0;
   
   
//----
   return(0);
  }
//+------------------------------------------------------------------+

Comments