CopyBuffer копирует массив не полностью

   int values_to_copy=(calculated1<calculated2 && calculated1<calculated3 && calculated1<calculated4) ? calculated1 :
                      (calculated2<calculated1 && calculated2<calculated3 && calculated2<calculated4) ? calculated2 :
                      (calculated3<calculated1 && calculated3<calculated2 && calculated3<calculated4) ? calculated3 : calculated4;

   if(CopyBuffer(Fast1MAHandle,0,0,values_to_copy,Fast1MABuffer) != values_to_copy ||
      CopyBuffer(Slow1MAHandle,0,0,values_to_copy,Slow1MABuffer) != values_to_copy ||
      CopyBuffer(Fast2MAHandle,0,0,values_to_copy,Fast2MABuffer) != values_to_copy ||
      CopyBuffer(Slow2MAHandle,0,0,values_to_copy,Slow2MABuffer) != values_to_copy )
      return(rates_total);

Возможно по условиям и будет правильнее, но почему же все таки 

CopyBuffer(Fast1MAHandle,0,0,values_to_copy,Fast1MABuffer)

копирует не все количество values_to_copy?

Где-то меньше бар. Как видите я выбрал минимальное число и его запустил в CopyBuffer

Для каждой валюты свой индикатор, соответственно и Handle.

С этим то я согласен, что где то меньше бар. Поэтому я и считываю количество бар в каждом хэндле индикатора iMA через BarsCalculated().

Это же значение (calculated1,2,3,4) я и указываю, при копировании каждого индивидуально массива. Но смысл в том, что после обработки всех CopyBuffer, получается один и тот же размер массива.

Это тоже ясно, но опять же для двух разных инструментов, для четырех Handle, в итоге выход один размер массивов после CopyBuffer.

ArraySize(Fast1MABuffer);// размер буфера индикатора, все они равны rates_total.

как-то так проверить:

int copy1=CopyBuffer(Fast1MAHandle,0,0,calculated1,Fast1MABuffer);

Print("copy1=",copy1);

Сравните скопированное количество со значением rates_total и попробуйте сделать выводы.

Вот вот именно. А при работе с двумя инструментами у нас выходит, что изначально rates_total у двух инструментов разный, это можно увидеть через BarsCalculated().

Но именно после CopyBuffer с копированием разного количество баров (calculated1,2,3,4) в буффер, выходит что по обоим инструментам размер буфера становится одинаковым. 

Как-то так

//+------------------------------------------------------------------+
//|                                                            3.mq5 |
//|                        Copyright 2019, MetaQuotes Software Corp. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2019, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
#property version   "1.00"
#property indicator_separate_window
#property indicator_buffers 2
#property indicator_plots   2

#property indicator_label1  "Line1"
#property indicator_type1   DRAW_LINE
#property indicator_color1  clrRed
#property indicator_style1  STYLE_SOLID
#property indicator_width1  1

#property indicator_label2  "Line2"
#property indicator_type2   DRAW_LINE
#property indicator_color2  clrBlue
#property indicator_style2  STYLE_SOLID
#property indicator_width2  1

double         Line1Buffer[];
double         Fast1MABuffer[];
double         Slow1MABuffer[];

double         Line2Buffer[];
double         Fast2MABuffer[];
double         Slow2MABuffer[];

int            Fast1MAHandle;
int            Slow1MAHandle;
int            Fast2MAHandle;
int            Slow2MAHandle;

input string Symbol1="EURUSD";
input string Symbol2="GBPUSD";
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
   SetIndexBuffer(0,Line1Buffer,INDICATOR_DATA);
   SetIndexBuffer(1,Line2Buffer,INDICATOR_DATA);
   IndicatorSetInteger(INDICATOR_DIGITS,(int)(SymbolInfoInteger(Symbol1,SYMBOL_DIGITS)<SymbolInfoInteger(Symbol2,SYMBOL_DIGITS) ?
                                                 SymbolInfoInteger(Symbol2,SYMBOL_DIGITS) : SymbolInfoInteger(Symbol1,SYMBOL_DIGITS)));
   ArraySetAsSeries(Line1Buffer,  true);
   ArraySetAsSeries(Line2Buffer,  true);
   ArraySetAsSeries(Fast1MABuffer,true);
   ArraySetAsSeries(Slow1MABuffer,true);
   ArraySetAsSeries(Fast2MABuffer,true);
   ArraySetAsSeries(Slow2MABuffer,true);

   Fast1MAHandle=iMA(Symbol1,PERIOD_CURRENT,12,0,MODE_SMA,PRICE_CLOSE);
   Slow1MAHandle=iMA(Symbol1,PERIOD_CURRENT,26,0,MODE_SMA,PRICE_CLOSE);
   Fast2MAHandle=iMA(Symbol2,PERIOD_CURRENT,12,0,MODE_SMA,PRICE_CLOSE);
   Slow2MAHandle=iMA(Symbol2,PERIOD_CURRENT,26,0,MODE_SMA,PRICE_CLOSE);

   IndicatorSetString(INDICATOR_SHORTNAME,"Индикатор №3: "+Symbol1+"/"+Symbol2);

   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
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=0;
   if(prev_calculated==0)
     {
      limit=BCalc(Fast1MAHandle);
      int _limit=BCalc(Slow1MAHandle);
      if(limit>_limit)
         limit=_limit;
      _limit=BCalc(Fast2MAHandle);
      if(limit>_limit)
         limit=_limit;
      _limit=BCalc(Slow2MAHandle);
      if(limit>_limit)
         limit=_limit;
     }
   else
      limit=rates_total-prev_calculated;
   if(limit<2)
      limit=2;

   ZeroMemory( Fast1MABuffer );
   ZeroMemory( Slow1MABuffer );
   ZeroMemory( Fast2MABuffer );
   ZeroMemory( Slow2MABuffer );
   if(CopyBuffer(Fast1MAHandle,0,0,limit,Fast1MABuffer) != limit ||
      CopyBuffer(Slow1MAHandle,0,0,limit,Slow1MABuffer) != limit ||
      CopyBuffer(Fast2MAHandle,0,0,limit,Fast2MABuffer) != limit ||
      CopyBuffer(Slow2MAHandle,0,0,limit,Slow2MABuffer) != limit )
      return(rates_total);
   for(int i=0;i<limit && !IsStopped();i++)
     {
      Line1Buffer[i]=Fast1MABuffer[i]-Slow1MABuffer[i];
      Line2Buffer[i]=Fast2MABuffer[i]-Slow2MABuffer[i];
     }

   return(rates_total);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
   Comment("");
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int BCalc(const int MAHandle)
  {
   int BCalc=BarsCalculated(MAHandle);
   if(BCalc<=0)
     {
      PrintFormat("BarsCalculated() вернул %d, код ошибки %d",BCalc,GetLastError());
      return(0);
     }
   return(BCalc);
  }
//+------------------------------------------------------------------+

Дальше сами ловите что не так.