Индикаторы: Оптимизированный вариант адаптивной скользящей средней Кауфмана AMA от wellx

Новый комментарий
 

Оптимизированный вариант адаптивной скользящей средней Кауфмана AMA от wellx:

Пример оптимизации методом "нарастающих итогов".

Author: MetaQuotes Software Corp.

 

Rosh

к сожалению индикатор всетаки отличаеться. Нет участка флэта, т.е в этом индикаторе всегда есть точки обозначающие движение верх UP или в низ Down. Варианта когда оба буфера равны 0 несуществует. Изменение dK от 0 до 1000 никак не влияет на график.

+ в лог при инициализации выдаеться 2007.09.05 23:08:04 AMA_for_Expert2 GBPUSD, H1: negative argument for MathSqrt function

 
Хорошо, посмотрю. Давно делал, надо проверить.
 
Не подойдёт?
//+------------------------------------------------------------------+
//|                                                          AMA.mq4 |
//|                      Copyright © 2004, MetaQuotes Software Corp. |
//|                                        https://www.metaquotes.net/ |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2004, by konKop,wellx"
#property link      "https://www.metaquotes.net/"
 
#property indicator_chart_window
#property indicator_buffers 3
#property indicator_color1 Sienna
#property indicator_color2 DeepSkyBlue
#property indicator_color3 Gold
 
//---- input parameters
extern int       Price=0; // 0 = Close             
                          // 1 = Open
                          // 2 = High
                          // 3 = Low
                          // 4 = (H+L)/2
                          // 5 = (H+L+C)/3
                          // 6 = (H+L+C+C)/4                    
                          // 7 = (O+C+H+L)/4
                          // 8 = (O+C)/2
                          //other = Close
extern int       periodAMA=9;
extern int       nfast=2;
extern int       nslow=30;
extern double    G=2.0;
extern double    dK=2.0; 
 
//---- buffers
double kAMAbuffer[];
double kAMAupsig[];
double kAMAdownsig[];
double AMA0[];
double _price[];
//+------------------------------------------------------------------+
 
double slowSC,fastSC;
 
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
  {
   IndicatorBuffers(5);
//---- indicators
   SetIndexStyle(0,DRAW_LINE,0,2);
   SetIndexStyle(1,DRAW_ARROW);
   SetIndexArrow(1,159);
   SetIndexStyle(2,DRAW_ARROW);
   SetIndexArrow(2,159);
   //SetIndexDrawBegin(0,nslow+nfast);
   SetIndexBuffer(0,kAMAbuffer);
   SetIndexBuffer(1,kAMAupsig);
   SetIndexBuffer(2,kAMAdownsig);
   SetIndexBuffer(3,AMA0);
   SetIndexBuffer(4,_price);
   IndicatorDigits(Digits);
   
   //slowSC=0.064516;
   //fastSC=0.2;
   //cbars=IndicatorCounted();
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit()
  {
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start()
  {
   int    i,pos=0;
   double noise=0.000000001,signal,ER;
   double dSC,ERSC,SSC,ddK;
       
//---- TODO: add your code here
   slowSC=(2.0 /(nslow+1));
   fastSC=(2.0 /(nfast+1));
   int cbars=IndicatorCounted();
   if (Bars<=(periodAMA+2)) return(0);
//---- check for possible errors
   if (cbars<0) return(-1);
//---- last counted bar will be recounted
   if (cbars<1) pos=Bars-1;
   else pos=Bars-cbars;
   while (pos>=0)
     {
      switch (Price)
        {
          case  1: _price[pos] =  Open[pos]; break;
          case  2: _price[pos] =  High[pos]; break;
          case  3: _price[pos] =  Low[pos]; break;
          case  4: _price[pos] = (High[pos]+Low[pos])/2; break;
          case  5: _price[pos] = (High[pos]+Low[pos]+Close[pos])/3; break;
          case  6: _price[pos] = (High[pos]+Low[pos]+Close[pos]+Close[pos])/4; break;
          case  7: _price[pos] = (Open[pos]+Close[pos]+High[pos]+Low[pos])/4; break;
          case  8: _price[pos] = (Open[pos]+Close[pos])/2; break;
          default: _price[pos] =  Close[pos];
        }
      pos--; 
     }   
   if (cbars<1) pos=Bars-periodAMA-2;
   else pos=Bars-cbars;
   while (pos>=0)
     {
      if(pos==Bars-periodAMA-2) AMA0[pos+1]=_price[pos+1];
      signal=MathAbs(_price[pos]-_price[pos+periodAMA]);
      noise=0.000000001;
      for(i=0;i<periodAMA;i++)
       {
        noise=noise+MathAbs(_price[pos+i]-_price[pos+i+1]);
       }
      ER =signal/noise;
      dSC=(fastSC-slowSC);
      ERSC=ER*dSC;
      SSC=ERSC+slowSC;
      kAMAbuffer[pos]=AMA0[pos+1]+(MathPow(SSC,G)*(_price[pos]-AMA0[pos+1]));
      
      ddK=(kAMAbuffer[pos]-AMA0[pos+1]);
      if ((MathAbs(ddK)) > (dK*Point) && (ddK > 0)) kAMAupsig[pos] =kAMAbuffer[pos]; else kAMAupsig[pos]=0;
      if ((MathAbs(ddK)) > (dK*Point) && (ddK < 0)) kAMAdownsig[pos]=kAMAbuffer[pos]; else kAMAdownsig[pos]=0; 
     
      AMA0[pos]=kAMAbuffer[pos];
      pos--;
     }
//----
   return(0);
  }
 
Sadhu:
Не подойдёт?
Подойдет, но идея была в том, чтобы на порядок ускорить расчеты. Я пытался исключить лишний цикл. Но возможно, ошибки округления при больших значениях начинают играть роль. Нужно будет проверить.
 
Sadhu:
Не подойдёт

Этот то подайдет, но он не оптемезирован по быстродействию. Вариант periodAMA= 500 + порядка 18 раз вызывается в эксперте с разнами параметрами, используються минутки. Этот эксперт никаким образом не уложиться в 5 мин (ограничения чемпионата). Жаль, что то надо думать. Если всемогущий Rosh сможет оптимизировать то будет гуд, нет так и на нет и суда нет :)

 
Prival:

Rosh

к сожалению индикатор всетаки отличаеться. Нет участка флэта, т.е в этом индикаторе всегда есть точки обозначающие движение верх UP или в низ Down. Варианта когда оба буфера равны 0 несуществует. Изменение dK от 0 до 1000 никак не влияет на график.

+ в лог при инициализации выдаеться 2007.09.05 23:08:04 AMA_for_Expert2 GBPUSD, H1: negative argument for MathSqrt function

Я посмотрел код обоих индикаторов и нашел причину разницы. Внешняя переменная dK определеяет чувствительность индикатора
extern int       periodAMA=10;
extern double    nfast=2.0;
extern double    nslow=30.0;
extern double    G=2.0;
extern double    dK=2.0;
Если значение адаптивной скользящей средней меняется на некую пороговую величину deltaAMA, то появляется круглая цветная метка на линии AMA, указывающая направление текущего тренда. В оригинале эта deltaAMA изверяется в пунктах и равна dK*Point.

Но , насколько я помню, в оригинале у Кауфмана она должна измеряться в стандратных отклонениях, то есть deltaAMA=dK*STD(AMA).
Поэтому я действительно сделала не полную копию, а ближе к оригиналу, но при этом сохранил все названия внешних переменных и значения по умолчанию для них.

Тем не менее я сейчас сделал третий вариант AMA for Expert3.mq4, который является полной копией по функционалу оригинала от wellx, и желающие могут использовать ее.

//+------------------------------------------------------------------+
//|                                              AMA for Expert3.mq4 |
//|                      Copyright © 2006, MetaQuotes Software Corp. |
//|                                Copyright © 2004, by konKop,wellx |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2006, MetaQuotes Software Corp."
#property link      "optimized by Rosh"
 
#property indicator_chart_window
#property indicator_buffers 3
#property indicator_color1 Lime
#property indicator_color2 Aqua
#property indicator_color3 Magenta
//---- input parameters
extern int       periodAMA=10;
extern double    nfast=2.0;
extern double    nslow=30.0;
extern double    G=2.0;
extern double    dK=2.0;
extern int       PriceType=0; // цена, от которой строится 
//PRICE_CLOSE 0 Цена закрытия 
//PRICE_OPEN 1 Цена открытия 
//PRICE_HIGH 2 Максимальная цена 
//PRICE_LOW 3 Минимальная цена 
//PRICE_MEDIAN 4 Средняя цена, (high+low)/2 
//PRICE_TYPICAL 5 Типичная цена, (high+low+close)/3 
//PRICE_WEIGHTED 6 Взвешенная цена закрытия, (high+low+close+close)/4 
 
//---- buffers
double AMAbuffer[];
double upAMA[];
double downAMA[];
double AbsBuffer[];
 
double AMA2Buffer[];
double SumAMABuffer[];
double StdAMA[];
 
double slowSC,fastSC,dFS;
 
//+------------------------------------------------------------------+
//| возвращает цену                                                  |
//+------------------------------------------------------------------+
double Price(int shift)
  {
//----
   double res;
//----
   switch (PriceType)
      {
      case PRICE_OPEN: res=Open[shift]; break;
      case PRICE_HIGH: res=High[shift]; break;
      case PRICE_LOW: res=Low[shift]; break;
      case PRICE_MEDIAN: res=(High[shift]+Low[shift])/2.0; break;
      case PRICE_TYPICAL: res=(High[shift]+Low[shift]+Close[shift])/3.0; break;
      case PRICE_WEIGHTED: res=(High[shift]+Low[shift]+2*Close[shift])/4.0; break;
      default: res=Close[shift];break;
      }
   return(res);
  }
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
  {
//---- indicators
   IndicatorBuffers(7);
   SetIndexStyle(0,DRAW_LINE);
   SetIndexBuffer(0,AMAbuffer);
   SetIndexStyle(1,DRAW_ARROW);
   SetIndexArrow(1,159);
   SetIndexBuffer(1,upAMA);
   SetIndexEmptyValue(1,0.0);
   SetIndexStyle(2,DRAW_ARROW);
   SetIndexArrow(2,159);
   SetIndexBuffer(2,downAMA);
   SetIndexEmptyValue(2,0.0);
   
   SetIndexBuffer(3,AbsBuffer);
   SetIndexBuffer(4,AMA2Buffer);
   SetIndexBuffer(5,SumAMABuffer);
   SetIndexBuffer(6,StdAMA);
   
   slowSC=(2.0 /(nslow+1));
   fastSC=(2.0 /(nfast+1));
   dFS=fastSC-slowSC;
   
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit()
  {
//----
   
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start()
  {
   int    counted_bars=IndicatorCounted();
//----
   int i,limit,limit2;
   double Noise,ER,SSC;
   double SredneeAMA,SumKvadratAMA;
   double val1,val2;
   if (counted_bars>0) 
      {
      limit=Bars-counted_bars; 
      limit2=limit;
      }
   if (counted_bars==0)
      {
      limit=Bars-1;
      /*
      for (i=limit;i>=0;i--)
         {
         AMAbuffer[i]=0;
         upAMA[i]=0;
         downAMA[i]=0;
         AbsBuffer[i]=0;
         NoiseBuffer[i]=0;
         ERBuffer[i]=0;
         SSCBuffer[i]=0;
         StdAMA[i]=0;
         }
      ArrayInitialize(,)
      */
      limit2=Bars-periodAMA-1;
      }
   limit--;
   limit2--;
   //Print("limit=",limit);
   //Print("Пошел Abs");
   for (i=limit;i>=0;i--)
      {
      AbsBuffer[i]=MathAbs(Price(i)-Price(i+1));
      }   
   //Print("Пошел Noise");
   for (i=limit2;i>=0;i--)
      {
      Noise=iMAOnArray(AbsBuffer,0,periodAMA,0,MODE_SMA,i)*periodAMA;
      if (Noise!=0) ER=MathAbs(Price(i)-Price(i+periodAMA))/Noise; else ER=0;
      SSC=MathPow(ER*dFS+slowSC,G);
      AMAbuffer[i]=Price(i)*SSC+AMAbuffer[i+1]*(1-SSC);
      AMA2Buffer[i]=AMAbuffer[i]*AMAbuffer[i]+AMA2Buffer[i+1];// накапливаем сумму квадратов АМы
      SumAMABuffer[i]=SumAMABuffer[i+1]+AMAbuffer[i];
      }   
   //Print("Пошел Std");
   for (i=limit2;i>=0;i--)
      {
      val1=0;
      val2=0;
      SredneeAMA=(SumAMABuffer[i]-SumAMABuffer[i+periodAMA])/periodAMA;
      SumKvadratAMA=AMA2Buffer[i]-AMA2Buffer[i+periodAMA];
      StdAMA[i]=MathSqrt(SumKvadratAMA/periodAMA-SredneeAMA*SredneeAMA);
      if (MathAbs(AMAbuffer[i]-AMAbuffer[i+1])>dK*Point)
         {
         if (AMAbuffer[i]-AMAbuffer[i+1]>0) val1=AMAbuffer[i];
         else val2=AMAbuffer[i];
         } 
      upAMA[i]=val1;
      downAMA[i]=val2;
      }
   //Print("Закончили");
 
//----
   return(0);
  }
//+------------------------------------------------------------------+
Рисунок подтверждает идентичность. Таким образом сделана полная копия неоптимизированного индикатора, которая ускорена на несколько порядков по времени расчета.




10:05:18 TestAMA for Expert: loaded successfully
10:05:18 TestAMA for Expert inputs: AMAtype=1;
10:05:18 2007.01.02 00:00 TestAMA for Expert EURUSD,H1: Используем оптимизированный индикатор
10:05:18 2007.01.02 00:00 TestAMA for Expert EURUSD,H1: Начало
10:05:18 2007.01.02 00:00 AMA for Expert3 EURUSD,H1: loaded successfully
10:05:40 2007.08.17 22:59 TestAMA for Expert EURUSD,H1: Финиш
Тестирование на интервале с 01 января 2007 года по 20 августа 2007 года по условиям приема экспертов на чемпионат заняло 22 секунды.


10:10:15 TestAMA for Expert: loaded successfully
10:10:15 TestAMA for Expert inputs: AMAtype=0;
10:10:15 2007.01.02 00:00 TestAMA for Expert EURUSD,H1: Используем оригинальный вариант индикатора
10:10:15 2007.01.02 00:00 TestAMA for Expert EURUSD,H1: Начало
10:10:15 2007.01.02 00:00 AMA EURUSD,H1: loaded successfully
10:12:46 2007.08.17 22:59 TestAMA for Expert EURUSD,H1: Финиш


А время тестирования неоптимизированного индикатора составило 2 минуты 31 секунда. Разница налицо.
 
Но если мы избавимся от вывода ошибок в лог индикатор преварительной иницаизацией буферов в значение 0, то тестирование проходит еще быстрее. :)

10:21:24 TestAMA for Expert inputs: AMAtype=1;
10:21:24 2007.01.02 00:00 TestAMA for Expert EURUSD,H1: Используем оптимизированный индикатор
10:21:24 2007.01.02 00:00 TestAMA for Expert EURUSD,H1: Начало
10:21:24 2007.01.02 00:00 AMA for Expert4 EURUSD,H1: loaded successfully
10:21:31 2007.08.17 22:59 TestAMA for Expert EURUSD,H1: Финиш

Таким образов видим: не оптимизированный вариант тестируется 2 минуты 31 секунда, а оптимизированный вариант потребовал всего 7 секунд! Больше чем в 10 раз.




Вот четвертый вариант AMA for Expert4.mq4
//+------------------------------------------------------------------+
//|                                              AMA for Expert2.mq4 |
//|                      Copyright © 2006, MetaQuotes Software Corp. |
//|                                Copyright © 2004, by konKop,wellx |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2006, MetaQuotes Software Corp."
#property link      "optimized by Rosh"
 
#property indicator_chart_window
#property indicator_buffers 3
#property indicator_color1 Lime
#property indicator_color2 Aqua
#property indicator_color3 Magenta
//---- input parameters
extern int       periodAMA=10;
extern double    nfast=2.0;
extern double    nslow=30.0;
extern double    G=2.0;
extern double    dK=2.0;
extern int       PriceType=0; // цена, от которой строится 
//PRICE_CLOSE 0 Цена закрытия 
//PRICE_OPEN 1 Цена открытия 
//PRICE_HIGH 2 Максимальная цена 
//PRICE_LOW 3 Минимальная цена 
//PRICE_MEDIAN 4 Средняя цена, (high+low)/2 
//PRICE_TYPICAL 5 Типичная цена, (high+low+close)/3 
//PRICE_WEIGHTED 6 Взвешенная цена закрытия, (high+low+close+close)/4 
 
//---- buffers
double AMAbuffer[];
double upAMA[];
double downAMA[];
double AbsBuffer[];
 
double AMA2Buffer[];
double SumAMABuffer[];
double StdAMA[];
 
double slowSC,fastSC,dFS;
 
//+------------------------------------------------------------------+
//| возвращает цену                                                  |
//+------------------------------------------------------------------+
double Price(int shift)
  {
//----
   double res;
//----
   switch (PriceType)
      {
      case PRICE_OPEN: res=Open[shift]; break;
      case PRICE_HIGH: res=High[shift]; break;
      case PRICE_LOW: res=Low[shift]; break;
      case PRICE_MEDIAN: res=(High[shift]+Low[shift])/2.0; break;
      case PRICE_TYPICAL: res=(High[shift]+Low[shift]+Close[shift])/3.0; break;
      case PRICE_WEIGHTED: res=(High[shift]+Low[shift]+2*Close[shift])/4.0; break;
      default: res=Close[shift];break;
      }
   return(res);
  }
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
  {
//---- indicators
   IndicatorBuffers(7);
   SetIndexStyle(0,DRAW_LINE);
   SetIndexBuffer(0,AMAbuffer);
   SetIndexStyle(1,DRAW_ARROW);
   SetIndexArrow(1,159);
   SetIndexBuffer(1,upAMA);
   SetIndexEmptyValue(1,0.0);
   SetIndexStyle(2,DRAW_ARROW);
   SetIndexArrow(2,159);
   SetIndexBuffer(2,downAMA);
   SetIndexEmptyValue(2,0.0);
   
   SetIndexBuffer(3,AbsBuffer);
   SetIndexBuffer(4,AMA2Buffer);
   SetIndexBuffer(5,SumAMABuffer);
   SetIndexBuffer(6,StdAMA);
   
   slowSC=(2.0 /(nslow+1));
   fastSC=(2.0 /(nfast+1));
   dFS=fastSC-slowSC;
   
   
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit()
  {
//----
   
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start()
  {
   int    counted_bars=IndicatorCounted();
//----
   int i,limit,limit2;
   double Noise,ER,SSC;
   double SredneeAMA,SumKvadratAMA;
   double val1,val2;
   if (counted_bars>0) 
      {
      limit=Bars-counted_bars; 
      limit2=limit;
      }
   if (counted_bars==0)
      {
      ArrayInitialize(AMAbuffer,0);
      ArrayInitialize(upAMA,0);
      ArrayInitialize(downAMA,0);
      ArrayInitialize(AbsBuffer,0);
      ArrayInitialize(AMA2Buffer,0);
      ArrayInitialize(SumAMABuffer,0);
      ArrayInitialize(StdAMA,0);
      
      limit=Bars-1;
      /*
      for (i=limit;i>=0;i--)
         {
         AMAbuffer[i]=0;
         upAMA[i]=0;
         downAMA[i]=0;
         AbsBuffer[i]=0;
         NoiseBuffer[i]=0;
         ERBuffer[i]=0;
         SSCBuffer[i]=0;
         StdAMA[i]=0;
         }
      ArrayInitialize(,)
      */
      limit2=Bars-periodAMA-1;
      }
   limit--;
   limit2--;
   //Print("limit=",limit);
   //Print("Пошел Abs");
   for (i=limit;i>=0;i--)
      {
      AbsBuffer[i]=MathAbs(Price(i)-Price(i+1));
      }   
   //Print("Пошел Noise");
   for (i=limit2;i>=0;i--)
      {
      Noise=iMAOnArray(AbsBuffer,0,periodAMA,0,MODE_SMA,i)*periodAMA;
      if (Noise!=0) ER=MathAbs(Price(i)-Price(i+periodAMA))/Noise; else ER=0;
      SSC=MathPow(ER*dFS+slowSC,G);
      AMAbuffer[i]=Price(i)*SSC+AMAbuffer[i+1]*(1-SSC);
      AMA2Buffer[i]=AMAbuffer[i]*AMAbuffer[i]+AMA2Buffer[i+1];// накапливаем сумму квадратов АМы
      SumAMABuffer[i]=SumAMABuffer[i+1]+AMAbuffer[i];
      }   
   //Print("Пошел Std");
   for (i=limit2;i>=0;i--)
      {
      val1=0;
      val2=0;
      SredneeAMA=(SumAMABuffer[i]-SumAMABuffer[i+periodAMA])/periodAMA;
      SumKvadratAMA=AMA2Buffer[i]-AMA2Buffer[i+periodAMA];
      StdAMA[i]=MathSqrt(SumKvadratAMA/periodAMA-SredneeAMA*SredneeAMA);
      if (MathAbs(AMAbuffer[i]-AMAbuffer[i+1])>dK*Point)
         {
         if (AMAbuffer[i]-AMAbuffer[i+1]>0) val1=AMAbuffer[i];
         else val2=AMAbuffer[i];
         } 
      upAMA[i]=val1;
      downAMA[i]=val2;
      }
   //Print("Закончили");
 
//----
   return(0);
  }
//+------------------------------------------------------------------+
 
Rosh:

Рад, что до сих пор это еще кому-то нужно :))
Я его делал в самом начале выхода МТ4 и об никакой оптимизации там и речи быть не могло.

Так что спасибj Rosh'u.





 
Rosh:
Но если мы избавимся от вывода ошибок в лог индикатор преварительной иницаизацией буферов в значение 0, то тестирование проходит еще быстрее. :)

10:21:24 TestAMA for Expert inputs: AMAtype=1;
10:21:24 2007.01.02 00:00 TestAMA for Expert EURUSD,H1: Используем оптимизированный индикатор
10:21:24 2007.01.02 00:00 TestAMA for Expert EURUSD,H1: Начало
10:21:24 2007.01.02 00:00 AMA for Expert4 EURUSD,H1: loaded successfully
10:21:31 2007.08.17 22:59 TestAMA for Expert EURUSD,H1: Финиш

Таким образов видим: не оптимизированный вариант тестируется 2 минуты 31 секунда, а оптимизированный вариант потребовал всего 7 секунд! Больше чем в 10 раз.

у меня к сожалению в лог выводиться вот эта ошибка, что я не так делаю

2007.09.08 13:54:51 2007.08.30 23:58 TestAMA GBPUSD,M1: Финиш
2007.09.08 13:54:51 2007.08.30 19:00 AMA_for_Expert4 GBPUSD,M1: negative argument for MathSqrt function

....................................

2007.09.08 13:54:44 2007.01.02 20:34 AMA_for_Expert4 GBPUSD,M1: negative argument for MathSqrt function
2007.09.08 13:54:44 2007.01.02 20:34 AMA_for_Expert4 GBPUSD,M1: negative argument for MathSqrt function
2007.09.08 13:54:43 2007.01.02 00:00 AMA_for_Expert4 GBPUSD,M1: loaded successfully
2007.09.08 13:54:43 2007.01.02 00:00 TestAMA GBPUSD,M1: Начало
2007.09.08 13:54:43 2007.01.02 00:00 TestAMA GBPUSD,M1: Используем оптимизированный индикатор
2007.09.08 13:54:43 TestAMA inputs: AMAtype=1;

 
Prival:

у меня к сожалению в лог выводиться вот эта ошибка, что я не так делаю

2007.09.08 13:54:51 2007.08.30 23:58 TestAMA GBPUSD,M1: Финиш
2007.09.08 13:54:51 2007.08.30 19:00 AMA_for_Expert4 GBPUSD,M1: negative argument for MathSqrt function

....................................

2007.09.08 13:54:44 2007.01.02 20:34 AMA_for_Expert4 GBPUSD,M1: negative argument for MathSqrt function
2007.09.08 13:54:44 2007.01.02 20:34 AMA_for_Expert4 GBPUSD,M1: negative argument for MathSqrt function
2007.09.08 13:54:43 2007.01.02 00:00 AMA_for_Expert4 GBPUSD,M1: loaded successfully
2007.09.08 13:54:43 2007.01.02 00:00 TestAMA GBPUSD,M1: Начало
2007.09.08 13:54:43 2007.01.02 00:00 TestAMA GBPUSD,M1: Используем оптимизированный индикатор
2007.09.08 13:54:43 TestAMA inputs: AMAtype=1;



Если Вы используете именно 4-ый вариант индикатора, то ошибок не будет. Сейчас еще раз прогнал советника на 2007.01.02-2007.08.20 и получил еще более лучшие результаты.

В четвертой версии AMA for Expert4.mq4 должен быть такой код:

   if (counted_bars==0)
      {
      ArrayInitialize(AMAbuffer,0);
      ArrayInitialize(upAMA,0);
      ArrayInitialize(downAMA,0);
      ArrayInitialize(AbsBuffer,0);
      ArrayInitialize(AMA2Buffer,0);
      ArrayInitialize(SumAMABuffer,0);
      ArrayInitialize(StdAMA,0);
 ....
12
Новый комментарий