ta.crossover and ta.crossunder in MQL5: EMA cross signals

//@version=6
indicator("EMA crossover signals", overlay = true)

fastLen = input.int(9, "Fast EMA", minval = 1)
slowLen = input.int(21, "Slow EMA", minval = 1)

fast = ta.ema(close, fastLen)
slow = ta.ema(close, slowLen)

// true on the bar where fast goes from at-or-below slow to above it
crossUp = ta.crossover(fast, slow)
crossDown = ta.crossunder(fast, slow)

plot(fast, "Fast EMA", color.teal, 2)
plot(slow, "Slow EMA", color.orange, 2)
plotshape(crossUp, "Cross up", shape.triangleup, location.belowbar, color.teal, size = size.small)
plotshape(crossDown, "Cross down", shape.triangledown, location.abovebar, color.red, size = size.small)

//+------------------------------------------------------------------+
//| EMA crossover signals: ta.crossover / ta.crossunder in MQL5       |
//| Custom indicator: save in MQL5/Indicators and compile (F7).      |
//+------------------------------------------------------------------+
#property indicator_chart_window
#property indicator_buffers 4
#property indicator_plots   4

#property indicator_label1  "Fast EMA"
#property indicator_type1   DRAW_LINE
#property indicator_color1  clrTeal
#property indicator_width1  2

#property indicator_label2  "Slow EMA"
#property indicator_type2   DRAW_LINE
#property indicator_color2  clrOrange
#property indicator_width2  2

#property indicator_label3  "Cross up"
#property indicator_type3   DRAW_ARROW
#property indicator_color3  clrTeal

#property indicator_label4  "Cross down"
#property indicator_type4   DRAW_ARROW
#property indicator_color4  clrRed

input int InpFastLen = 9;   // Fast EMA
input int InpSlowLen = 21;  // Slow EMA

double FastBuf[], SlowBuf[], UpBuf[], DownBuf[];
int    fastHandle = INVALID_HANDLE;
int    slowHandle = INVALID_HANDLE;

int OnInit()
  {
   if(InpFastLen < 1 || InpSlowLen < 1)
      return INIT_PARAMETERS_INCORRECT;

   SetIndexBuffer(0, FastBuf, INDICATOR_DATA);
   SetIndexBuffer(1, SlowBuf, INDICATOR_DATA);
   SetIndexBuffer(2, UpBuf, INDICATOR_DATA);
   SetIndexBuffer(3, DownBuf, INDICATOR_DATA);

   PlotIndexSetInteger(2, PLOT_ARROW, 233);        // Wingdings up arrow
   PlotIndexSetInteger(3, PLOT_ARROW, 234);        // Wingdings down arrow
   PlotIndexSetInteger(2, PLOT_ARROW_SHIFT, 12);   // pixels below the low
   PlotIndexSetInteger(3, PLOT_ARROW_SHIFT, -12);  // pixels above the high
   for(int p = 0; p < 4; p++)
     {
      PlotIndexSetDouble(p, PLOT_EMPTY_VALUE, EMPTY_VALUE); // EMPTY_VALUE plays the role of Pine's na
      PlotIndexSetInteger(p, PLOT_DRAW_BEGIN, InpSlowLen);
     }

   // ta.ema() becomes a handle, created once
   fastHandle = iMA(_Symbol, _Period, InpFastLen, 0, MODE_EMA, PRICE_CLOSE);
   slowHandle = iMA(_Symbol, _Period, InpSlowLen, 0, MODE_EMA, PRICE_CLOSE);
   if(fastHandle == INVALID_HANDLE || slowHandle == INVALID_HANDLE)
     {
      Print("Could not create the EMA handles, error ", GetLastError());
      return INIT_FAILED;
     }
   return INIT_SUCCEEDED;
  }

void OnDeinit(const int reason)
  {
   IndicatorRelease(fastHandle);
   IndicatorRelease(slowHandle);
  }

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[])
  {
   // The EMAs are calculated by the terminal: wait until they cover every bar
   if(BarsCalculated(fastHandle) < rates_total || BarsCalculated(slowHandle) < rates_total)
      return prev_calculated;

   // First call: every bar. Later calls: the last finished bar and the forming one
   int start = prev_calculated > 0 ? prev_calculated - 1 : 0;
   int count = rates_total - start;

   double fast[], slow[];  // not series: [0] is the oldest of the copied values
   if(CopyBuffer(fastHandle, 0, 0, count, fast) != count || CopyBuffer(slowHandle, 0, 0, count, slow) != count)
      return prev_calculated;  // data not ready: try again on the next tick

   for(int k = 0; k < count; k++)
     {
      int i = start + k;  // i counts from the oldest bar, like Pine's bar_index
      FastBuf[i] = fast[k];
      SlowBuf[i] = slow[k];
      UpBuf[i]   = EMPTY_VALUE;
      DownBuf[i] = EMPTY_VALUE;
      if(i < InpSlowLen)
         continue;  // warm-up bars: Pine's values are na or still settling here

      // ta.crossover(fast, slow): above now, at or below on the previous bar
      if(FastBuf[i] > SlowBuf[i] && FastBuf[i - 1] <= SlowBuf[i - 1])
         UpBuf[i] = low[i];
      // ta.crossunder(fast, slow): below now, at or above on the previous bar
      if(FastBuf[i] < SlowBuf[i] && FastBuf[i - 1] >= SlowBuf[i - 1])
         DownBuf[i] = high[i];
     }
   return rates_total;
  }
//+------------------------------------------------------------------+