MacdACSignals

Download script
Author: Tonkonog G.S., 2009
MacdACSignals

This script is a technical analysis tool designed for the MetaTrader 4 platform. Its primary purpose is to identify specific momentum shifts in financial charts and display them as visual markers (arrows) to help traders spot potential buying and selling opportunities.

Core Logic Overview

The indicator operates by analyzing two distinct types of market data: the MACD (Moving Average Convergence Divergence) and the AC (Accelerator Cursor). By combining these two indicators, the script filters out "noise" and attempts to identify high-probability trend reversals.

How the Signals are Generated

1. The MACD Component (The Trend Filter) The script monitors the relationship between the MACD Main line and its Signal line. It looks for specific "crosses":

  • Bullish Interest: When the MACD moves from below to above zero, or when the Main line crosses above the Signal line while remaining in positive territory.
  • Bearish Interest: When the MACD moves from above to below zero, or when the Main line crosses below the Signal line while remaining in negative territory.

2. The AC Component (The Momentum Confirmation) To ensure the signals aren't just temporary fluctuations, the script checks the "Accelerator Cursor" (AC) values across multiple historical points (looking back up to 8 bars). It specifically looks for a consistent "staircase" pattern in price momentum:

  • For Buying: It looks for an upward progression where the momentum values are increasing consistently.
  • For Selling: It looks for a downward progression where the momentum values are decreasing consistently.

Visual Representation

The script processes these rules simultaneously to place two types of markings on your chart:

  • Gold Arrows (Buy Signals): These appear above the price candles. They are triggered when the MACD confirms a bullish crossover and the AC values confirm a consistent upward acceleration in momentum. The script checks for this across several different time horizons (0 to 4 bars back) to ensure the signal is robust before placing the arrow.
  • Red Arrows (Sell Signals): These appear below the price candles. They are triggered when the MACD confirms a bearish crossover and the AC values confirm a consistent downward deceleration in momentum.

Summary for the User

Instead of just telling you that the price is moving up or down, this script waits for a specific "confluence." It requires the main trend (MACD) to align with a momentum acceleration (AC) before it paints an arrow on your screen. This multi-layered approach is intended to help traders identify the start of a move more accurately than using either indicator alone.

Indicators Used
MACD HistogramBill Williams Accelerator/Decelerator oscillator
Miscellaneous
Implements a curve of type %1
12 Views
0 Downloads
0 Favorites
MacdACSignals 
//+------------------------------------------------------------------+
//|                                            MacdACSignals.mq4.mq4 |
//|                                              Tonkonog G.S., 2009 |
//|                                            hurricane79@yandex.ru |
//+------------------------------------------------------------------+
#property copyright "Tonkonog G.S., 2009"
#property link      "hurricane79@yandex.ru"

#property indicator_chart_window
#property indicator_buffers 2
#property indicator_color1 Gold
#property indicator_color2 Red
//---- input parameters
extern int       barsToProcess=500;
//---- buffers
double ExtMapBuffer1[];
double ExtMapBuffer2[];
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
  {
//---- indicators
   SetIndexStyle(0,DRAW_ARROW);
   SetIndexArrow(0,236);
   SetIndexBuffer(0,ExtMapBuffer1);
   SetIndexEmptyValue(0,0.0);
   SetIndexStyle(1,DRAW_ARROW);
   SetIndexArrow(1,238);
   SetIndexBuffer(1,ExtMapBuffer2);
   SetIndexEmptyValue(1,0.0);
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit()
  {
//----
   
//----
   return(0);  
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start()
  {
   int counted_bars=IndicatorCounted(),
       limit;
//---- last counted bar will be recounted
   if(counted_bars>0) counted_bars--;
   limit=Bars-counted_bars;
   
   if(limit>barsToProcess)
      limit=barsToProcess;
//----
   for(int i=0;i<limit;i++)
   {
    double MacdCurrent, MacdPrevious, SignalCurrent, SignalPrevious,
           AC1,AC2,AC3,AC4,AC5,
           AC1_1,AC2_1,AC3_1,AC4_1,AC5_1,
           AC1_2,AC2_2,AC3_2,AC4_2,AC5_2,
           AC1_3,AC2_3,AC3_3,AC4_3,AC5_3,
           AC1_4,AC2_4,AC3_4,AC4_4,AC5_4;
           
           
    MacdCurrent=iMACD(NULL,0,5,34,5,PRICE_CLOSE,MODE_MAIN,i);
    MacdPrevious=iMACD(NULL,0,5,34,5,PRICE_CLOSE,MODE_MAIN,i+1);
    SignalCurrent=iMACD(NULL,0,5,34,5,PRICE_CLOSE,MODE_SIGNAL,i);
    SignalPrevious=iMACD(NULL,0,5,34,5,PRICE_CLOSE,MODE_SIGNAL,i+1);
    AC1=iAC(NULL,0,i);   AC1_1=iAC(NULL,0,i+1); AC1_2=iAC(NULL,0,i+2);
    AC2=iAC(NULL,0,i+1); AC2_1=iAC(NULL,0,i+2); AC2_2=iAC(NULL,0,i+3);
    AC3=iAC(NULL,0,i+2); AC3_1=iAC(NULL,0,i+3); AC3_2=iAC(NULL,0,i+4);
    AC4=iAC(NULL,0,i+3); AC4_1=iAC(NULL,0,i+4); AC4_2=iAC(NULL,0,i+5);
    AC5=iAC(NULL,0,i+4); AC5_1=iAC(NULL,0,i+5); AC5_2=iAC(NULL,0,i+6);
    
    AC1_3=iAC(NULL,0,i+3); AC1_4=iAC(NULL,0,i+4);
    AC2_3=iAC(NULL,0,i+4); AC2_4=iAC(NULL,0,i+5);
    AC3_3=iAC(NULL,0,i+5); AC3_4=iAC(NULL,0,i+6);
    AC4_3=iAC(NULL,0,i+6); AC4_4=iAC(NULL,0,i+7);
    AC5_3=iAC(NULL,0,i+7); AC5_4=iAC(NULL,0,i+8);
    
//--Ïðîâåðêà íàëè÷èÿ ñèãíàëà íà ïîêóïêó--------------------------------------------------------------------------------------+    
    if((MacdCurrent>0 && MacdCurrent>SignalCurrent && MacdPrevious<SignalPrevious) &&
      (((AC4>0 && AC3>0 && AC2>0 && AC1>0) && (AC4>AC3 && AC2>AC3 && AC1>AC2)) ||                     //... íà íóëåâîì áàðå  +
      ((AC4<0 && AC3<0 && AC2<0 && AC1>0) && (AC4>AC3 && AC2>AC3 && AC1>AC2)) ||                     //   åñòü îäèí èç òð¸õ  +
      ((AC5<0 && AC4<0 && AC3<0 && AC2<0 && AC1<0) &&                                               // ñèãíàëîâ îò ÀÑ òî ... +
      (AC5>AC4 && AC4<AC3 && AC3<AC2 && AC2<AC1))))                                                 //                       +
       ExtMapBuffer1[i]=High[i]+15*Point;
    if((MacdCurrent>0 && MacdPrevious<0) &&                                // Åñëè MACD-ãèñòîãðàììà ïåðåøëà ÷åðåç íîëü è ... +
      (((AC4>0 && AC3>0 && AC2>0 && AC1>0) && (AC4>AC3 && AC2>AC3 && AC1>AC2)) ||                     //... íà íóëåâîì áàðå  +
      ((AC4<0 && AC3<0 && AC2<0 && AC1>0) && (AC4>AC3 && AC2>AC3 && AC1>AC2)) ||                     //   åñòü îäèí èç òð¸õ  +
      ((AC5<0 && AC4<0 && AC3<0 && AC2<0 && AC1<0) &&                                               // ñèãíàëîâ îò ÀÑ òî ... +
      (AC5>AC4 && AC4<AC3 && AC3<AC2 && AC2<AC1))))                                                 //                       +
       ExtMapBuffer1[i]=High[i]+15*Point;                                                           // ... ðèñóåì ñòðåëêó    + 
 
 
    if((MacdCurrent>0 && MacdCurrent>SignalCurrent && MacdPrevious<SignalPrevious) &&
      (((AC4_1>0 && AC3_1>0 && AC2_1>0 && AC1_1>0) && (AC4_1>AC3_1 && AC2_1>AC3_1 && AC1_1>AC2_1)) || // ... íà ïåðâîì áàðå  +
      ((AC4_1<0 && AC3_1<0 && AC2_1<0 && AC1_1>0) && (AC4_1>AC3_1 && AC2_1>AC3_1 && AC1_1>AC2_1)) || //   åñòü îäèí èç òð¸õ  +
      ((AC5_1<0 && AC4_1<0 && AC3_1<0 && AC2_1<0 && AC1_1<0) &&                                     // ñèãíàëîâ îò ÀÑ òî ... +
      (AC5_1>AC4_1 && AC4_1<AC3_1 && AC3_1<AC2_1 && AC2_1<AC1_1))))                                 //                       +
       ExtMapBuffer1[i]=High[i]+15*Point;                                                           // ... ðèñóåì ñòðåëêó    +    
    if((MacdCurrent>0 && MacdPrevious<0) &&                                // Åñëè MACD-ãèñòîãðàììà ïåðåøëà ÷åðåç íîëü è ... +
      (((AC4_1>0 && AC3_1>0 && AC2_1>0 && AC1_1>0) && (AC4_1>AC3_1 && AC2_1>AC3_1 && AC1_1>AC2_1)) || // ... íà ïåðâîì áàðå  +
      ((AC4_1<0 && AC3_1<0 && AC2_1<0 && AC1_1>0) && (AC4_1>AC3_1 && AC2_1>AC3_1 && AC1_1>AC2_1)) || //   åñòü îäèí èç òð¸õ  +
      ((AC5_1<0 && AC4_1<0 && AC3_1<0 && AC2_1<0 && AC1_1<0) &&                                     // ñèãíàëîâ îò ÀÑ òî ... +
      (AC5_1>AC4_1 && AC4_1<AC3_1 && AC3_1<AC2_1 && AC2_1<AC1_1))))                                 //                       +
       ExtMapBuffer1[i]=High[i]+15*Point;                                                           // ... ðèñóåì ñòðåëêó    + 

    
    if((MacdCurrent>0 && MacdCurrent>SignalCurrent && MacdPrevious<SignalPrevious) &&
      (((AC4_2>0 && AC3_2>0 && AC2_2>0 && AC1_2>0) && (AC4_2>AC3_2 && AC2_2>AC3_2 && AC1_2>AC2_2)) || // ... íà âòîðîì áàðå  +
      ((AC4_2<0 && AC3_2<0 && AC2_2<0 && AC1_2>0) && (AC4_2>AC3_2 && AC2_2>AC3_2 && AC1_2>AC2_2)) || //   åñòü îäèí èç òð¸õ  +
      ((AC5_2<0 && AC4_2<0 && AC3_2<0 && AC2_2<0 && AC1_2<0) &&                                     // ñèãíàëîâ îò ÀÑ òî ... +
      (AC5_2>AC4_2 && AC4_2<AC3_2 && AC3_2<AC2_2 && AC2_2<AC1_2))))                                 //                       +
       ExtMapBuffer1[i]=High[i]+15*Point;                                                           // ... ðèñóåì ñòðåëêó    +  
    if((MacdCurrent>0 && MacdPrevious<0) &&                                // Åñëè MACD-ãèñòîãðàììà ïåðåøëà ÷åðåç íîëü è ... +
      (((AC4_2>0 && AC3_2>0 && AC2_2>0 && AC1_2>0) && (AC4_2>AC3_2 && AC2_2>AC3_2 && AC1_2>AC2_2)) || // ... íà âòîðîì áàðå  +
      ((AC4_2<0 && AC3_2<0 && AC2_2<0 && AC1_2>0) && (AC4_2>AC3_2 && AC2_2>AC3_2 && AC1_2>AC2_2)) || //   åñòü îäèí èç òð¸õ  +
      ((AC5_2<0 && AC4_2<0 && AC3_2<0 && AC2_2<0 && AC1_2<0) &&                                     // ñèãíàëîâ îò ÀÑ òî ... +
      (AC5_2>AC4_2 && AC4_2<AC3_2 && AC3_2<AC2_2 && AC2_2<AC1_2))))                                 //                       +
       ExtMapBuffer1[i]=High[i]+15*Point;                                                           // ... ðèñóåì ñòðåëêó    + 
    
    
    if((MacdCurrent>0 && MacdCurrent>SignalCurrent && MacdPrevious<SignalPrevious) &&
      (((AC4_3>0 && AC3_3>0 && AC2_3>0 && AC1_3>0) && (AC4_3>AC3_3 && AC2_3>AC3_3 && AC1_3>AC2_3)) || // ... íà òðåòüåì áàðå +
      ((AC4_3<0 && AC3_3<0 && AC2_3<0 && AC1_3>0) && (AC4_3>AC3_3 && AC2_3>AC3_3 && AC1_3>AC2_3)) || //   åñòü îäèí èç òð¸õ  +
      ((AC5_3<0 && AC4_3<0 && AC3_3<0 && AC2_3<0 && AC1_3<0) &&                                     // ñèãíàëîâ îò ÀÑ òî ... +
      (AC5_3>AC4_3 && AC4_3<AC3_3 && AC3_3<AC2_3 && AC2_3<AC1_3))))                                 //                       +
       ExtMapBuffer1[i]=High[i]+15*Point;                                                           // ... ðèñóåì ñòðåëêó    + 
    if((MacdCurrent>0 && MacdPrevious<0) &&                                // Åñëè MACD-ãèñòîãðàììà ïåðåøëà ÷åðåç íîëü è ... +
      (((AC4_3>0 && AC3_3>0 && AC2_3>0 && AC1_3>0) && (AC4_3>AC3_3 && AC2_3>AC3_3 && AC1_3>AC2_3)) || // ... íà òðåòüåì áàðå +
      ((AC4_3<0 && AC3_3<0 && AC2_3<0 && AC1_3>0) && (AC4_3>AC3_3 && AC2_3>AC3_3 && AC1_3>AC2_3)) || //   åñòü îäèí èç òð¸õ  +
      ((AC5_3<0 && AC4_3<0 && AC3_3<0 && AC2_3<0 && AC1_3<0) &&                                     // ñèãíàëîâ îò ÀÑ òî ... +
      (AC5_3>AC4_3 && AC4_3<AC3_3 && AC3_3<AC2_3 && AC2_3<AC1_3))))                                 //                       +
       ExtMapBuffer1[i]=High[i]+15*Point;                                                           // ... ðèñóåì ñòðåëêó    + 
       
    
    if((MacdCurrent>0 && MacdCurrent>SignalCurrent && MacdPrevious<SignalPrevious) &&
      (((AC4_4>0 && AC3_4>0 && AC2_4>0 && AC1_4>0) && (AC4_4>AC3_4 && AC2_4>AC3_4 && AC1_4>AC2_4)) ||//... íà ÷åòâ¸ðòîì áàðå +
      ((AC4_4<0 && AC3_4<0 && AC2_4<0 && AC1_4>0) && (AC4_4>AC3_4 && AC2_4>AC3_4 && AC1_4>AC2_4)) || //   åñòü îäèí èç òð¸õ  +
      ((AC5_4<0 && AC4_4<0 && AC3_4<0 && AC2_4<0 && AC1_4<0) &&                                     // ñèãíàëîâ îò ÀÑ òî ... +
      (AC5_4>AC4_4 && AC4_4<AC3_4 && AC3_4<AC2_4 && AC2_4<AC1_4))))                                 //                       +
       ExtMapBuffer1[i]=High[i]+15*Point;                                                           // ... ðèñóåì ñòðåëêó    + 
    if((MacdCurrent>0 && MacdPrevious<0) &&                                // Åñëè MACD-ãèñòîãðàììà ïåðåøëà ÷åðåç íîëü è ... +
      (((AC4_4>0 && AC3_4>0 && AC2_4>0 && AC1_4>0) && (AC4_4>AC3_4 && AC2_4>AC3_4 && AC1_4>AC2_4)) ||//... íà ÷åòâ¸ðòîì áàðå +
      ((AC4_4<0 && AC3_4<0 && AC2_4<0 && AC1_4>0) && (AC4_4>AC3_4 && AC2_4>AC3_4 && AC1_4>AC2_4)) || //   åñòü îäèí èç òð¸õ  +
      ((AC5_4<0 && AC4_4<0 && AC3_4<0 && AC2_4<0 && AC1_4<0) &&                                     // ñèãíàëîâ îò ÀÑ òî ... +
      (AC5_4>AC4_4 && AC4_4<AC3_4 && AC3_4<AC2_4 && AC2_4<AC1_4))))                                 //                       +
       ExtMapBuffer1[i]=High[i]+15*Point;                                                           // ... ðèñóåì ñòðåëêó    + 

//--Ïðîâåðêà íàëè÷èÿ ñèãíàëà íà ïðîäàæó--------------------------------------------------------------------------------------+
    if((MacdCurrent<0 && MacdCurrent<SignalCurrent && MacdPrevious>SignalPrevious) &&
      (((AC4<0 && AC3<0 && AC2<0 && AC1<0) && (AC4<AC3 && AC2<AC3 && AC1<AC2)) ||
      ((AC4>0 && AC3>0 && AC2>0 && AC1<0) && (AC4<AC3 && AC2<AC3 && AC1<AC2)) ||
      ((AC5>0 && AC4>0 && AC3>0 && AC2>0 && AC1>0) && 
      (AC5<AC4 && AC4>AC3 && AC3>AC2 && AC2>AC1))))
       ExtMapBuffer2[i]=Low[i]-15*Point;
    if((MacdCurrent<0 && MacdPrevious>0) &&
      (((AC4<0 && AC3<0 && AC2<0 && AC1<0) && (AC4<AC3 && AC2<AC3 && AC1<AC2)) ||
      ((AC4>0 && AC3>0 && AC2>0 && AC1<0) && (AC4<AC3 && AC2<AC3 && AC1<AC2)) ||
      ((AC5>0 && AC4>0 && AC3>0 && AC2>0 && AC1>0) && 
      (AC5<AC4 && AC4>AC3 && AC3>AC2 && AC2>AC1)))) 
       ExtMapBuffer2[i]=Low[i]-15*Point;
       
       
    if((MacdCurrent<0 && MacdCurrent<SignalCurrent && MacdPrevious>SignalPrevious) &&
      (((AC4_1<0 && AC3_1<0 && AC2_1<0 && AC1_1<0) && (AC4_1<AC3_1 && AC2_1<AC3_1 && AC1_1<AC2_1)) ||
      ((AC4_1>0 && AC3_1>0 && AC2_1>0 && AC1_1<0) && (AC4_1<AC3_1 && AC2_1<AC3_1 && AC1_1<AC2_1)) ||
      ((AC5_1>0 && AC4_1>0 && AC3_1>0 && AC2_1>0 && AC1_1>0) && 
      (AC5_1<AC4_1 && AC4_1>AC3_1 && AC3_1>AC2_1 && AC2_1>AC1_1))))
       ExtMapBuffer2[i]=Low[i]-15*Point;
    if((MacdCurrent<0 && MacdPrevious>0) &&
      (((AC4_1<0 && AC3_1<0 && AC2_1<0 && AC1_1<0) && (AC4_1<AC3_1 && AC2_1<AC3_1 && AC1_1<AC2_1)) ||
      ((AC4_1>0 && AC3_1>0 && AC2_1>0 && AC1_1<0) && (AC4_1<AC3_1 && AC2_1<AC3_1 && AC1_1<AC2_1)) ||
      ((AC5_1>0 && AC4_1>0 && AC3_1>0 && AC2_1>0 && AC1_1>0) && 
      (AC5_1<AC4_1 && AC4_1>AC3_1 && AC3_1>AC2_1 && AC2_1>AC1_1))))
       ExtMapBuffer2[i]=Low[i]-15*Point;
   
    
    if((MacdCurrent<0 && MacdCurrent<SignalCurrent && MacdPrevious>SignalPrevious) &&
      (((AC4_2<0 && AC3_2<0 && AC2_2<0 && AC1_2<0) && (AC4_2<AC3_2 && AC2_2<AC3_2 && AC1_2<AC2_2)) ||
      ((AC4_2>0 && AC3_2>0 && AC2_2>0 && AC1_2<0) && (AC4_2<AC3_2 && AC2_2<AC3_2 && AC1_2<AC2_2)) ||
      ((AC5_2>0 && AC4_2>0 && AC3_2>0 && AC2_2>0 && AC1_2>0) && 
      (AC5_2<AC4_2 && AC4_2>AC3_2 && AC3_2>AC2_2 && AC2_2>AC1_2))))
       ExtMapBuffer2[i]=Low[i]-15*Point;
    if((MacdCurrent<0 && MacdPrevious>0) &&
      (((AC4_2<0 && AC3_2<0 && AC2_2<0 && AC1_2<0) && (AC4_2<AC3_2 && AC2_2<AC3_2 && AC1_2<AC2_2)) ||
      ((AC4_2>0 && AC3_2>0 && AC2_2>0 && AC1_2<0) && (AC4_2<AC3_2 && AC2_2<AC3_2 && AC1_2<AC2_2)) ||
      ((AC5_2>0 && AC4_2>0 && AC3_2>0 && AC2_2>0 && AC1_2>0) && 
      (AC5_2<AC4_2 && AC4_2>AC3_2 && AC3_2>AC2_2 && AC2_2>AC1_2))))
       ExtMapBuffer2[i]=Low[i]-15*Point;

 
    if((MacdCurrent<0 && MacdCurrent<SignalCurrent && MacdPrevious>SignalPrevious) &&
      (((AC4_3<0 && AC3_3<0 && AC2_3<0 && AC1_3<0) && (AC4_3<AC3_3 && AC2_3<AC3_3 && AC1_3<AC2_3)) ||
      ((AC4_3>0 && AC3_3>0 && AC2_3>0 && AC1_3<0) && (AC4_3<AC3_3 && AC2_3<AC3_3 && AC1_3<AC2_3)) ||
      ((AC5_3>0 && AC4_3>0 && AC3_3>0 && AC2_3>0 && AC1_3>0) && 
      (AC5_3<AC4_3 && AC4_3>AC3_3 && AC3_3>AC2_3 && AC2_3>AC1_3))))
       ExtMapBuffer2[i]=Low[i]-15*Point;
    if((MacdCurrent<0 && MacdPrevious>0) &&
      (((AC4_3<0 && AC3_3<0 && AC2_3<0 && AC1_3<0) && (AC4_3<AC3_3 && AC2_3<AC3_3 && AC1_3<AC2_3)) ||
      ((AC4_3>0 && AC3_3>0 && AC2_3>0 && AC1_3<0) && (AC4_3<AC3_3 && AC2_3<AC3_3 && AC1_3<AC2_3)) ||
      ((AC5_3>0 && AC4_3>0 && AC3_3>0 && AC2_3>0 && AC1_3>0) && 
      (AC5_3<AC4_3 && AC4_3>AC3_3 && AC3_3>AC2_3 && AC2_3>AC1_3))))
       ExtMapBuffer2[i]=Low[i]-15*Point;
    
    
    if((MacdCurrent<0 && MacdCurrent<SignalCurrent && MacdPrevious>SignalPrevious) &&
      (((AC4_4<0 && AC3_4<0 && AC2_4<0 && AC1_4<0) && (AC4_4<AC3_4 && AC2_4<AC3_4 && AC1_4<AC2_4)) ||
      ((AC4_4>0 && AC3_4>0 && AC2_4>0 && AC1_4<0) && (AC4_4<AC3_4 && AC2_4<AC3_4 && AC1_4<AC2_4)) ||
      ((AC5_4>0 && AC4_4>0 && AC3_4>0 && AC2_4>0 && AC1_4>0) && 
      (AC5_4<AC4_4 && AC4_4>AC3_4 && AC3_4>AC2_4 && AC2_4>AC1_4))))
       ExtMapBuffer2[i]=Low[i]-15*Point;
    if((MacdCurrent<0 && MacdPrevious>0) &&
      (((AC4_4<0 && AC3_4<0 && AC2_4<0 && AC1_4<0) && (AC4_4<AC3_4 && AC2_4<AC3_4 && AC1_4<AC2_4)) ||
      ((AC4_4>0 && AC3_4>0 && AC2_4>0 && AC1_4<0) && (AC4_4<AC3_4 && AC2_4<AC3_4 && AC1_4<AC2_4)) ||
      ((AC5_4>0 && AC4_4>0 && AC3_4>0 && AC2_4>0 && AC1_4>0) && 
      (AC5_4<AC4_4 && AC4_4>AC3_4 && AC3_4>AC2_4 && AC2_4>AC1_4))))
       ExtMapBuffer2[i]=Low[i]-15*Point;   
   }
//----
   return(0);
  }
//+------------------------------------------------------------------+

Similar scripts

MACD+MA

The indicator identifies bullish and bearish trend shifts by detecting simultaneous upward or downward price momentum across both a Moving Average and the MACD Main line.

NR7-NR4

The indicator identifies localized momentum shifts by detecting price bars with the largest relative range compared to preceding short-term windows.

Phoenix5_Ind_1_v2

Phoenix5_Ind_1_v3

Phoenix5_Ind_1_v1

StochCCI_Arrows_v7

This indicator identifies potential reversal points by synchronizing Stochastic momentum crossovers with Commodity Channel Index (CCI) divergence filters.

ADX_Cross_Hull_Style_v2

This indicator identifies bullish and bearish trend reversals by detecting crossovers between smoothed PlusDI and MinusDI components derived from an adaptive hull-style calculation.

FractalBest

Identifies structural reversals by detecting five-bar price extremes where the central high or low point exceeds its immediate neighbors.

Price_BarsM2_MTF

This indicator overlays the Open, High, Low, and Close price data from a higher timeframe onto the current chart to visualize structural price boundaries.

LGP_Ivanoff_Maloma-Demark_Levels

This indicator identifies structural reversal points by detecting consecutive identical closing prices that break previous local highs or lows across various temporalities.

4Period_RSI_Arrows_v3

Comments