Простой код

понимаю, что не по сабжу, но видимо круг замкнулся: МТ4 --> www.mql4.com --> МТ5 --> www.mql5.com --> www.mql4.com --> ???

ЗЫ: четыре раза заставлял уже себя сесть и сделать чтонить на МТ5,но, увы, после часа занятий МТ5, плююсь и опять в МТ4 :) 

все таки на пятёрке ответили

//+------------------------------------------------------------------+
//|                                                     Proverka.mq5 |
//|                        Copyright 2010, MetaQuotes Software Corp. |
//|                                              https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2010, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
#property version   "1.00"
#property indicator_buffers 1
#property indicator_separate_window
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
double buf[];

int OnInit()
  {
//--- indicator buffers mapping
   SetIndexBuffer(0,buf,INDICATOR_DATA);
   Print(ArrayIsDynamic(buf));
//---
   return(0);
  }
//+------------------------------------------------------------------+
//| 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[])
  {
   
      if(prev_calculated==0)
      {
         for(int i=0;i<10;i++)
         {
            buf[i]=i;
         }
      }
      else
      {
         for (int i=9;i>=0;i--)
         {
            Print(buf[i]);
         }
      }
   return(rates_total);
  }
//+------------------------------------------------------------------+

В MT4 я поступаю следующим образом: 

При инициализации задаю размерность равной 1 а при работе динамически изменяю ее до нужной. Там есть функция изменения размерности массива.

Пока работало без сбоев 

Задавать размер индикаторнму буферу, а также делать для него ArrayIsDynamic(buf) - это извращение. 

Все что надо, это задать свойства:

#property indicator_buffers 1
#property indicator_plots   1

//+------------------------------------------------------------------+
//|                                                         SSRC.mq5 |
//|                        Copyright 2010, MetaQuotes Software Corp. |
//|                                              https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2010, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
#property version   "1.00"
#property indicator_separate_window
#property indicator_minimum -1
#property indicator_maximum 1
#property indicator_buffers 1
#property indicator_plots   1
//--- plot Label1
#property indicator_label1  "Label1"
#property indicator_type1   DRAW_LINE
#property indicator_color1  Lime
#property indicator_style1  STYLE_SOLID
#property indicator_width1  1
//--- indicator buffers
input int    SnakeRange   =3;
input int    FilterPeriod =21;
input ENUM_APPLIED_PRICE PriceConst=PRICE_CLOSE;
input double MartFiltr=2;
//extern int    PriceConst   =6; // 0 - Close
// 1 - Open
// 2 - High
// 3 - Low
// 4 - (H+L)/2
// 5 - (H+L+C)/3
// 6 - (H+L+2*C)/4
//---- buffers
double MA_Buffer[];
double SRCBuffer[];
double Axis[];
double Mart[];
//---- SpearmanRankCorrelation
int    rangeN=14; //   = 30 maximum
double R2[];
double multiply;
int    PriceInt[];
int    SortInt[];

int hnd_MA;
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- indicator buffers mapping
   SetIndexBuffer(0,SRCBuffer,INDICATOR_DATA);

//SetIndexBuffer(1,Axis,INDICATOR_CALCULATIONS);

//SetIndexBuffer(2,Mart,INDICATOR_CALCULATIONS);

   SetIndexBuffer(1,MA_Buffer,INDICATOR_CALCULATIONS);
//SetIndexBuffer(4,PriceInt,INDICATOR_CALCULATIONS);
//SetIndexBuffer(3,SortInt,INDICATOR_CALCULATIONS);

   if(rangeN>30)
      IndicatorSetString(INDICATOR_SHORTNAME,"Decrease rangeN input!");
   else
      IndicatorSetString(INDICATOR_SHORTNAME,"SSRC( SR:"+SnakeRange+", FP:"+FilterPeriod+" )");
   multiply=MathPow(10,_Digits);
   hnd_MA=iMA(_Symbol,_Period,SnakeRange+1,0,MODE_LWMA,PriceConst);
//---
   return(0);
  }
//+------------------------------------------------------------------+
//| 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 &TickVolume[],
                const long &Volume[],
                const int &Spread[])
  {
   int i,k,limit,limit2,limit3,Pos;
   if(rangeN>30)
      return(0);
   int calculated=BarsCalculated(hnd_MA);
   if(calculated<rates_total)
     {
      Print("Not all data of hnd_MA is calculated (",calculated,"bars ). Error",GetLastError());
      return(0);
     }
   int to_copy;
   if(prev_calculated>rates_total || prev_calculated<0)
      to_copy=rates_total;
   else
     {
      to_copy=rates_total-prev_calculated;
      if(prev_calculated>0) to_copy++;
     }
   if(CopyBuffer(hnd_MA,0,0,to_copy,MA_Buffer)<=0)
     {
      Print("Getting fast MA is failed! Error",GetLastError());
      return(0);
     }
   //ArraySetAsSeries(Mart,true);
   //ArraySetAsSeries(R2,true);
   //ArraySetAsSeries(PriceInt,true);
   //ArraySetAsSeries(SortInt,true);
   if(prev_calculated==0)
     {
      limit=rates_total-(rangeN+FilterPeriod+SnakeRange+4);
      limit2=rates_total-(SnakeRange+2);
      limit3=rates_total-(FilterPeriod+SnakeRange+3); 
     }
   else
   //if(prev_calculated>0)
     {
      limit=rates_total-prev_calculated-1;
      limit2=limit;
      limit3=limit;
     }
   Print(limit2);
   ArraySetAsSeries(MA_Buffer,true);
   ArraySetAsSeries(Axis,true);
   //CopyBuffer();
   for(Pos=0;Pos<limit2;Pos++)
     {
      //MartAxis(i,MA_Buffer[i]);
      Print(Pos);
      int SnakeWeight,w,ww,Shift;
      i=0;
      double SnakeSum;
      Print(Pos," ",Axis[Pos]); //ошибка начинаеться тут
      Axis[Pos]=MA_Buffer[Pos];
      for(Shift=Pos+SnakeRange+2;Shift>Pos;Shift--)
        {
         SnakeSum=0.0;
         SnakeWeight=0; i=0; w=Shift+SnakeRange; ww=Shift-SnakeRange;
         if(ww<Pos) ww=Pos;
         while(w>=Shift)
           {
            i++;
            SnakeSum=SnakeSum+i*PriceConst;//SnakePrice(w); 
            SnakeWeight=SnakeWeight+i; w--;
           }
         while(w>=ww)
           {
            i--;
            SnakeSum=SnakeSum+i*PriceConst;//SnakePrice(w);
            SnakeWeight=SnakeWeight+i; w--;
           }
         Axis[Shift]=SnakeSum/SnakeWeight;
        }
     }
   for(i=limit3;i>=0;i--)
      SmoothOverMart(i);
   for(i=limit;i>=0;i--)
     {
      for(k=0;k<rangeN;k++)
         PriceInt[k]=Mart[i+k]*multiply;
      RankPrices(PriceInt);
      SRCBuffer[i]=SpearmanRankCorrelation(R2,rangeN);
      if(SRCBuffer[i]>1.0)
         SRCBuffer[i]=1.0;
      if(SRCBuffer[i]<-1.0)
         SRCBuffer[i]=-1.0;
     }
   return(rates_total);
  }
//+------------------------------------------------------------------+
void MartAxis(int Pos,double Price_MA)
  {
   int SnakeWeight,i,w,ww,Shift;
   double SnakeSum;
   Axis[Pos]=Price_MA;
   for(Shift=Pos+SnakeRange+2;Shift>Pos;Shift--)
     {
      SnakeSum=0.0;
      SnakeWeight=0; i=0; w=Shift+SnakeRange; ww=Shift-SnakeRange;
      if(ww<Pos) ww=Pos;
      while(w>=Shift)
        {
         i++;
         SnakeSum=SnakeSum+i*PriceConst;//SnakePrice(w); 
         SnakeWeight=SnakeWeight+i; w--;
        }
      while(w>=ww)
        {
         i--;
         SnakeSum=SnakeSum+i*PriceConst;//SnakePrice(w);
         SnakeWeight=SnakeWeight+i; w--;
        }
      Axis[Shift]=SnakeSum/SnakeWeight;
     }
   return;
  }
//----
void SmoothOverMart(int Shift)
  {
   double t,b;
   t=Axis[ArrayMaximum(Axis,FilterPeriod,Shift)];
   b=Axis[ArrayMinimum(Axis,FilterPeriod,Shift)];
   Mart[Shift]=(2*(2+MartFiltr)*Axis[Shift]-(t+b))/2/(1+MartFiltr);
   return;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void RankPrices(const int &InitialArray[])
  {
   double dcounter,averageRank;
   int i,k,m,dublicat,counter,etalon;
   double TrueRanks[];
   ArrayResize(TrueRanks,rangeN);
   ArrayCopy(SortInt,InitialArray);
   for(i=0;i<rangeN;i++)
     {
      TrueRanks[i]=i+1;
     }
   ArraySort(SortInt);
   for(i=0;i<rangeN-1;i++)
     {
      if(SortInt[i]!=SortInt[i+1])
         continue;
      dublicat=SortInt[i];
      k=i+1;
      counter=1;
      averageRank=i+1;
      while(k<rangeN)
        {
         if(SortInt[k]==dublicat)
           {
            counter++;
            averageRank+=k+1;
            k++;
           }
         else
           {
            break;
           }
        }
      dcounter=counter; averageRank=averageRank/dcounter;
      for(m=i;m<k;m++)
         TrueRanks[m]=averageRank; i=k;
     }
   for(i=0;i<rangeN;i++)
     {
      etalon=InitialArray[i];
      k=0;
      while(k<rangeN)
        {
         if(etalon==SortInt[k])
           {
            R2[i]=TrueRanks[k];
            break;
           }
         k++;
        }
     }
   return;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double SpearmanRankCorrelation(const double &Ranks[],int N)
  {
   double res,z2;
   for(int i=0;i<N;i++)
     {
      z2=z2+MathPow(Ranks[i]-i-1,2);
     }
   res=1-6*z2/(MathPow(N,3)-N); return(res);
  }
/*double SnakePrice(int Shift) 
{
   switch(Shift) 
   {
      case  0: return(Close[Shift]);
      case  1: return(Open[Shift]);
      case  2: return(High[Shift]);
      case  3: return(Low[Shift]);
      case  4: return((High[Shift]+Low[Shift])/2);
      case  5: return((Close[Shift]+High[Shift]+Low[Shift])/3);
      case  6: return((2*Close[Shift]+High[Shift]+Low[Shift])/4);
      default: return(Close[Shift]); 
   } 
}*/
//+------------------------------------------------------------------+

Ну тогда я испанский летчик.

   
SetIndexBuffer(0,buf,INDICATOR_CALCULATIONS); 
   for(int i=0;i<10;i++)
   {
      buf[i]=i;
   }