FX_FISH-mod

Download script
Author: Copyright � 2005, Kiko Segui
FX_FISH-mod

The FX_FISH indicator is a technical analysis tool designed to help traders identify momentum shifts and potential entry or exit points in the financial markets. It operates by calculating a specific "momentum value" based on price action over a set period, translating these movements into a visual histogram.

Core Logic and Mechanics

1. Data Input and Normalization The script begins by analyzing specific price points (such as High, Low, Open, or Close) within a user-defined lookback period. It identifies the highest high and lowest low within that timeframe to establish a "range." By comparing the current price to this range, the indicator determines where the price currently sits relative to its recent extremes.

2. Momentum Smoothing Instead of showing raw price changes, the script applies a smoothing calculation. It takes the normalized position of the price and blends it with previous values. This helps filter out "noise" or minor fluctuations, ensuring that the resulting data reflects a more stable trend rather than erratic market ticks.

3. The "Fish" Calculation The core of the indicator is the transition from a simple value to a logarithmic momentum figure (referred to as "Fish"). By using a logarithmic scale, the tool amplifies movements that occur at the extremes of the price range while dampening those in the middle. This creates a more sensitive detection of when the market is reaching a turning point or accelerating in a specific direction.

4. Visual Representation The results are displayed as a histogram in a separate window:

  • Dark Blue Histogram: Represents positive momentum (bullish pressure).
  • Red Histogram: Represents negative momentum (bearish pressure).

Automated Signal Generation

The script is programmed to recognize specific behavioral patterns in the momentum data to provide visual cues on the chart:

  • Buy Signals: Triggered when the momentum value exceeds a specific threshold and shows a sharp upward trend compared to its previous two states. This suggests a strong surge in buying pressure.
  • Sell Signals: Triggered when the momentum value drops below a negative threshold and shows a sharp downward trend compared to its previous two states, suggesting an aggressive move toward the downside.
  • Exit Cues: The indicator also monitors "crosses." If the momentum flips from positive to negative (or vice versa), it can identify potential exit points where the current trend has lost its strength and may be reversing.

User Customization

The logic allows for flexibility in how price is interpreted (e.g., focusing on the average price of a candle versus just the closing price) and offers a "Fast Mode" for traders who prefer to see immediate, real-time reactions versus a more smoothed, historical perspective.

Miscellaneous
Implements a curve of type %1
8 Views
0 Downloads
0 Favorites
FX_FISH-mod 
// FX_FISH
#property copyright "Copyright © 2005, Kiko Segui"
#property link      "webtecnic@terra.es"

#property indicator_separate_window
#property indicator_buffers 2
#property indicator_color1 DarkBlue
#property indicator_color2 Red
#property indicator_level1 0.2
#property indicator_level2 0.5
#property indicator_level3 1.0
#property indicator_level4 -0.2
#property indicator_level5 -0.5
#property indicator_level6 -1.0
// #property indicator_maximum 2
// #property indicator_minimum -2

           
double buffer1[];
double buffer2[];


extern int period=10;
extern int price=6; // 0 or other = (H+L)/2
                    // 1 = Open
                    // 2 = Close
                    // 3 = High
                    // 4 = Low
                    // 5 = (H+L+C)/3
                    // 6 = (O+C+H+L)/4
                    // 7 = (O+C)/2
extern bool Mode_Fast= True;
extern bool Signals= False;
      
int init()
  {
  SetIndexStyle(0,DRAW_HISTOGRAM,STYLE_SOLID,2,DarkBlue);
  SetIndexBuffer(0,buffer1);
  SetIndexStyle(1,DRAW_HISTOGRAM,STYLE_SOLID,2,Red);
  SetIndexBuffer(1,buffer2);
  return(0);
  }


int deinit()
  {
  int i;
  double tmp;
  
  
  for (i=0;i<Bars;i++)
    {
    ObjectDelete("SELL SIGNAL: "+DoubleToStr(i,0));
    ObjectDelete("BUY SIGNAL: "+DoubleToStr(i,0));
    ObjectDelete("EXIT: "+DoubleToStr(i,0));
    }
  return(0);
  }


double Value=0,Value1=0,Value2=0,Fish=0,Fish1=0,Fish2=0;

int buy=0,sell=0;

int start()
  {
  int i;
  int barras;
  double _price;
  double tmp;
  
  double MinL=0;
  double MaxH=0;                    
  
  double Threshold=1.2; 

  barras = Bars;
  if (Mode_Fast)
    barras = 1;
  i = 1000;
  while(i>-1)
   {
   MaxH = High[Highest(NULL,0,MODE_HIGH,period,i)];
   MinL = Low[Lowest(NULL,0,MODE_LOW,period,i)];
  
   switch (price)
     {
     case 1: _price = Open[i]; break;
     case 2: _price = Close[i]; break;
     case 3: _price = High[i]; break;
     case 4: _price = Low[i]; break;
     case 5: _price = (High[i]+Low[i]+Close[i])/3; break;
     case 6: _price = (Open[i]+High[i]+Low[i]+Close[i])/4; break;
     case 7: _price = (Open[i]+Close[i])/2; break;
     default: _price = (High[i]+Low[i])/2; break;
     }
   
        
   Value = 0.33*2*((_price-MinL)/(MaxH-MinL)-0.5) + 0.67*Value1;     
   Value=MathMin(MathMax(Value,-0.999),0.999); 
   Fish = 0.5*MathLog((1+Value)/(1-Value)) -0.5*Fish1 -0.5*Fish2;

   buffer1[i]= 0;
   buffer2[i]= 0;
   
   if ( (Fish<0) && (Fish1>0)) 
     {
     if (Signals)
       {
       ObjectCreate("EXIT: "+DoubleToStr(i,0),OBJ_TEXT,0,Time[i],_price);
       ObjectSetText("EXIT: "+DoubleToStr(i,0),"EXIT AT "+DoubleToStr(_price,4),7,"Arial",White);
       }
     buy = 0;
     }   
   if ((Fish>0) && (Fish1<0))
     {
     if (Signals)
       {
       ObjectCreate("EXIT: "+DoubleToStr(i,0),OBJ_TEXT,0,Time[i],_price);
       ObjectSetText("EXIT: "+DoubleToStr(i,0),"EXIT AT "+DoubleToStr(_price,4),7,"Arial",White);
       }
     sell = 0;
     }        
    
   if (Fish>=0)
     {
     buffer1[i] = Fish;
     }
   else
     {
     buffer2[i] = Fish;  
     }
     
   tmp = i;
   if ((Fish<-Threshold) && 
       (Fish>Fish1) && 
       (Fish1<=Fish2))
     {     
     if (Signals)
       {
       ObjectCreate("SELL SIGNAL: "+DoubleToStr(i,0),OBJ_TEXT,0,Time[i],_price);
       ObjectSetText("SELL SIGNAL: "+DoubleToStr(i,0),"SELL AT "+DoubleToStr(_price,4),7,"Arial",Red);
       }
     sell = 1;
     }

  if ((Fish>Threshold) && 
       (Fish<Fish1) && 
       (Fish1>=Fish2))
    {
    if (Signals)
       {
       ObjectCreate("BUY SIGNAL: "+DoubleToStr(i,0),OBJ_TEXT,0,Time[i],_price);
       ObjectSetText("BUY SIGNAL: "+DoubleToStr(i,0),"BUY AT "+DoubleToStr(_price,4),7,"Arial",DarkBlue);
       }
    buy=1;
    }

   Value1 = Value;
   Fish2 = Fish1;  
   Fish1 = Fish;
 
   i--;
   }
  return(0);
  }
//+------------------------------------------------------------------+

Similar scripts

FX Fish_v2

This indicator calculates a smoothed logarithmic transformation of price relative to high-low ranges to identify directional momentum reversals and trend exhaustion.

FX_FISH Mod2_v2

This indicator utilizes a recursive logarithmic transformation of normalized price position relative to recent high-low extremes to identify overextended momentum shifts.

FX_FISH Mod

This indicator calculates a normalized price position within a rolling high-low range, applying a logarithmic transformation to identify extreme momentum shifts and directional exhaustion.

FX_FISH_v2

This indicator utilizes a normalized price range calculation combined with logarithmic smoothing to identify extreme momentum shifts and potential trend exhaustion points.

FX Fish_v1

This indicator calculates a smoothed logarithmic momentum value based on the relative position of price within its high-low range to identify trend reversals and exhaustion.

FX_FISH-mod_v2

The indicator calculates a smoothed relative position of price within a high-low range, then applies a logarithmic transformation to determine momentum direction and volatility extremes.

FX_FISH Mod_v1

This indicator utilizes a smoothed logarithmic transformation of normalized price action relative to local highs and lows to identify directional shifts and extreme momentum reversals.

FX_FISH-mod_v1

This indicator calculates a smoothed, logarithmic momentum value based on the relative position of price within its local high-low range to identify overextended trend exhaustion points.

FXmFish[1]-2

The indicator calculates a smoothed momentum value based on the relative position of price within its high-low range, applying a logarithmic transformation to identify overextended trends and reversal points.

FX_FISH_v1

This indicator utilizes a recursive smoothing algorithm and logarithmic scaling to identify high-velocity price reversals relative to dynamic historical volatility ranges.

FX Fish

This indicator calculates a weighted price position relative to recent highs and lows, applying a logarithmic transformation to detect extreme momentum shifts and trend reversals.

Comments