오류, 버그, 질문 - 페이지 2504

[Igor Makanu]

Francuz :
여러분, 정보를 공유하세요. 무엇을 위해 얼라인먼트를 사용하고 있습니까?

너구리 지향 프로그래밍 입니다!

아아, 어떤 식 으로든없이;)

[Francuz]

Igor Makanu :

너구리 지향 프로그래밍 입니다!

아아, 어떤 식 으로든없이;)

알아요. OOP를 가르쳐달라는 것이 아닙니다. 누가 어떤 목적으로 얼라인먼트를 사용하는지 물었습니다.

[[삭제]]

Francuz :
여러분, 정보를 공유하세요. 무엇을 위해 얼라인먼트를 사용하고 있습니까?

내가 보기에 이것은 모두 다중 스레드 환경에서 매우 유용합니다. 여기서 MKL은 어느 쪽입니까? 예 hz, 질문을 받았으므로 붙였습니다.

글쎄, 일반적으로 - 이것들은 기본 사항이며 모든 괜찮은 프로그래머에게는 기본적인 이해가 필요합니다.

추신: 글쎄요, 속도를 좋아하는 팬이 많이 있습니다. 그들이 마음에 따라 모든 것을 평준화하기 시작하면 최소한 이론상으로는 훨씬 더 빨리 날 수 있을 것입니다.

[Alexey Navoykov]

Francuz :
여러분, 정보를 공유하세요. 무엇을 위해 얼라인먼트를 사용하고 있습니까?

이것은 구조를 외부 라이브러리에 전달할 때 필요할 수 있습니다.

[[삭제]]

Vict :

추신: 글쎄요, 속도를 좋아하는 팬이 많이 있습니다. 그들이 마음에 따라 모든 것을 평준화하기 시작하면 최소한 이론상으로는 훨씬 더 빨리 날 수 있을 것입니다.

일반적으로 나는 이것을 기대하지도 않았습니다.

 #define WRONG_ALIGNED
#define CACHE_LINE_SIZE 64

struct Data {
#ifdef WRONG_ALIGNED
   short bad_pad;
#endif
   uint ar[CACHE_LINE_SIZE/ sizeof ( int )];
};

#import "msvcrt.dll"
   long memcpy(Data &, Data &, long );
#import
#define getaddr(x) memcpy(x, x, 0 )

void OnStart ()
{
   Data data[ 32768 ];
   if (getaddr(data[ 0 ])% 4 != 0 ) {
       Alert ( "error" );
       return ;
   }
   ZeroMemory (data);
   int index = int (CACHE_LINE_SIZE - getaddr(data[ 0 ]) % CACHE_LINE_SIZE) / sizeof ( int ) - 1 ;
   
   srand ( GetTickCount ());
   
   ulong start_time = GetMicrosecondCount ();
   for ( unsigned i = 0 ; i < 10000 ; ++ i) {
       int rndnum = rand ();
       while (++rndnum < 32768 )
         for ( int j = ArraySize (data[rndnum].ar)- 1 ; j >= 0 ;  -- j)
            ++ data[rndnum].ar[j];
   }
      
   Alert ( GetMicrosecondCount () - start_time);
   
   for ( int j = ArraySize (data[ 100 ].ar)- 1 ; j >= 0 ;  -- j)
       Print (data[ 100 ].ar[j]);
}
/*
WRONG_ALIGNED:
6117940
6104068
6047416

RIGHT_ALIGNED
3341823
2565150
2565150
*/

코드가 약간 복잡합니다. 캐시 라인에 맞지 않는 요소를 쳐서 직접 두드려 보았지만 잘 되지 않았습니다. 그 중), 그러나 나는 코드를 많이 편집하지 않았습니다. 그러나 이 방법은 훨씬 더 인상적입니다. 캐시 라인에 속하지 않는 요소에 대해 16개의 추가 중 하나만 수행되지만 가시적인 결과를 제공합니다.

추신: 이 경우 하나의 단락을 삭제하지 않고 두 개의 단락을 삽입하여 RIGHT_ALIGNED를 수행하는 것이 더 객관적입니다(이렇게 하면 두 경우 모두에 대해 두 개의 캐시 라인 업데이트를 달성할 수 있음). 따라서 가속은 더 완만하지만 여전히 약 1.5배 중요합니다.

[TheXpert]

그건 그렇고, mql에서 pack의 기본값은 일종의 1입니다.

이전 게시물로 판단하면 모든 구조체와 클래스에 대해 8을 명시적으로 규정하는 것이 합리적일 수 있습니다.

[Eugeni Neumoin]

오류를 극복할 수 없습니다.

오류를 보여주기 위해 메타 트레이더의 전달에서 지그재그로 가져갔습니다. 내 프로그램에서 코드로 가져온 추가 버퍼를 추가했습니다. 이 코드에서는 추가 버퍼를 사용한 조작이 제공되지 않습니다. 그들은 단지 오류를 보여주기 위한 것입니다.

나는 이 지그재그를 EURUSD 차트, H1 시간대에 가져왔습니다. 터미널을 닫았습니다. 생성된 모든 EURUSD 시계열을 기록에서 삭제했습니다. 즉, EURUSD 통화 쌍에 대한 모든 *.hcc 및 *.hc 파일을 삭제했습니다. 이것은 터미널이 부팅될 때 .hcc 파일이 로드되기 시작하고 .hc 파일이 깨끗한 슬레이트에서 생성되도록 수행됩니다.

터미널을 실행 한 후 EURUSD 차트에 많은 아티팩트가 있습니다. 그리고 이러한 유물은 극복할 수 없습니다.

수정된 지그재그의 코드를 텍스트 형태로 파일로 첨부합니다.

#propert를 사용하여 ZigZag 매개변수 설정을 떠났다는 것을 경고합니다.

지그재그용 버퍼를 포함한 모든 것이 프로그래밍 방식으로 동적으로 변경되기 때문에 #propert를 통해 다른 모든 버퍼를 설정하지 않습니다.

 //+------------------------------------------------------------------+
//|                                                       ZigZag.mq5 |
//|                   Copyright 2009-2017, MetaQuotes Software Corp. |
//|                                              http://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "2009-2017, MetaQuotes Software Corp."
#property link        "http://www.mql5.com"
#property version    "1.00"
#property indicator_chart_window
#property indicator_buffers 29
#property indicator_plots 17
//---- plot Zigzag

#property indicator_label17   "Zigzag"
#property indicator_type17   DRAW_SECTION
#property indicator_color17  Red
#property indicator_style17   STYLE_SOLID
#property indicator_width17   1

//--- input parameters
input int       ExtDepth= 12 ;
input int       ExtDeviation= 5 ;
input int       ExtBackstep= 3 ;
//--- indicator buffers
double          ZigzagBuffer[];       // main buffer
double          HighMapBuffer[];     // highs
double          LowMapBuffer[];       // lows
int             level= 3 ;             // recounting depth
double          deviation;           // deviation in points

double Hmzz1[],      Hmzz2[],  Hmzz3[], Hmzz4[],     Hmzz5[],   Hmzz6[], Hmzz7[], Hmzz8[],      Hmzz9[],  Hmzz10[];
double Lmzz1[],      Lmzz2[],  Lmzz3[], Lmzz4[],     Lmzz5[],   Lmzz6[], Lmzz7[], Lmzz8[],      Lmzz9[],  Lmzz10[];
double nen_ZigZagL[], nen_ZigZagH[];
double ha[], la[], ham[], lam[];
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit ()
  {
//--- indicator buffers mapping

   SetIndexBuffer ( 0 ,Lmzz1, INDICATOR_DATA );   // Plot = 0
   SetIndexBuffer ( 1 ,Hmzz1, INDICATOR_DATA );
   SetIndexBuffer ( 2 ,Lmzz2, INDICATOR_DATA );   // Plot = 1
   SetIndexBuffer ( 3 ,Hmzz2, INDICATOR_DATA );
   SetIndexBuffer ( 4 ,Lmzz3, INDICATOR_DATA );   // Plot = 2
   SetIndexBuffer ( 5 ,Hmzz3, INDICATOR_DATA );
   SetIndexBuffer ( 6 ,Lmzz4, INDICATOR_DATA );   // Plot = 3
   SetIndexBuffer ( 7 ,Hmzz4, INDICATOR_DATA );
   SetIndexBuffer ( 8 ,Lmzz5, INDICATOR_DATA );   // Plot = 4
   SetIndexBuffer ( 9 ,Hmzz5, INDICATOR_DATA );
   SetIndexBuffer ( 10 ,Lmzz6, INDICATOR_DATA );   // Plot = 5
   SetIndexBuffer ( 11 ,Hmzz6, INDICATOR_DATA );
   SetIndexBuffer ( 12 ,Lmzz7, INDICATOR_DATA );   // Plot = 6
   SetIndexBuffer ( 13 ,Hmzz7, INDICATOR_DATA );
   SetIndexBuffer ( 14 ,Lmzz8, INDICATOR_DATA );   // Plot = 7
   SetIndexBuffer ( 15 ,Hmzz8, INDICATOR_DATA );
   SetIndexBuffer ( 16 ,Lmzz9, INDICATOR_DATA );   // Plot = 8
   SetIndexBuffer ( 17 ,Hmzz9, INDICATOR_DATA );
   SetIndexBuffer ( 18 ,Lmzz10, INDICATOR_DATA );   // Plot = 9
   SetIndexBuffer ( 19 ,Hmzz10, INDICATOR_DATA );
   
   PlotIndexSetDouble ( 0 , PLOT_EMPTY_VALUE , 0.0 );
   PlotIndexSetDouble ( 1 , PLOT_EMPTY_VALUE , 0.0 );
   PlotIndexSetDouble ( 2 , PLOT_EMPTY_VALUE , 0.0 );
   PlotIndexSetDouble ( 3 , PLOT_EMPTY_VALUE , 0.0 );
   PlotIndexSetDouble ( 4 , PLOT_EMPTY_VALUE , 0.0 );
   PlotIndexSetDouble ( 5 , PLOT_EMPTY_VALUE , 0.0 );
   PlotIndexSetDouble ( 6 , PLOT_EMPTY_VALUE , 0.0 );
   PlotIndexSetDouble ( 7 , PLOT_EMPTY_VALUE , 0.0 );
   PlotIndexSetDouble ( 8 , PLOT_EMPTY_VALUE , 0.0 );
   PlotIndexSetDouble ( 9 , PLOT_EMPTY_VALUE , 0.0 );

   ArraySetAsSeries (Lmzz1, true );
   ArraySetAsSeries (Hmzz1, true );
   ArraySetAsSeries (Lmzz2, true );
   ArraySetAsSeries (Hmzz2, true );
   ArraySetAsSeries (Lmzz3, true );
   ArraySetAsSeries (Hmzz3, true );
   ArraySetAsSeries (Lmzz4, true );
   ArraySetAsSeries (Hmzz4, true );   
   ArraySetAsSeries (Lmzz5, true );
   ArraySetAsSeries (Hmzz5, true );
   ArraySetAsSeries (Lmzz6, true );
   ArraySetAsSeries (Hmzz6, true );
   ArraySetAsSeries (Lmzz7, true );
   ArraySetAsSeries (Hmzz7, true );
   ArraySetAsSeries (Lmzz8, true );
   ArraySetAsSeries (Hmzz8, true );
   ArraySetAsSeries (Lmzz9, true );
   ArraySetAsSeries (Hmzz9, true );
   ArraySetAsSeries (Lmzz10, true );
   ArraySetAsSeries (Hmzz10, true );
   ArraySetAsSeries (nen_ZigZagH, true );
   ArraySetAsSeries (nen_ZigZagL, true );
   ArraySetAsSeries (ham, true );
   ArraySetAsSeries (lam, true );
   ArraySetAsSeries (ha, true );
   ArraySetAsSeries (la, true );

   PlotIndexSetInteger ( 0 , PLOT_DRAW_TYPE , DRAW_ZIGZAG ); 
   PlotIndexSetInteger ( 1 , PLOT_DRAW_TYPE , DRAW_ZIGZAG );
   PlotIndexSetInteger ( 2 , PLOT_DRAW_TYPE , DRAW_ZIGZAG ); 
   PlotIndexSetInteger ( 3 , PLOT_DRAW_TYPE , DRAW_ZIGZAG ); 
   PlotIndexSetInteger ( 4 , PLOT_DRAW_TYPE , DRAW_ZIGZAG );
   PlotIndexSetInteger ( 5 , PLOT_DRAW_TYPE , DRAW_ZIGZAG ); 
   PlotIndexSetInteger ( 6 , PLOT_DRAW_TYPE , DRAW_ZIGZAG );
   PlotIndexSetInteger ( 7 , PLOT_DRAW_TYPE , DRAW_ZIGZAG ); 
   PlotIndexSetInteger ( 8 , PLOT_DRAW_TYPE , DRAW_ZIGZAG );
   PlotIndexSetInteger ( 9 , PLOT_DRAW_TYPE , DRAW_ZIGZAG );

   PlotIndexSetInteger ( 0 , PLOT_LINE_STYLE , STYLE_SOLID );
   PlotIndexSetInteger ( 1 , PLOT_LINE_STYLE , STYLE_SOLID );
   PlotIndexSetInteger ( 2 , PLOT_LINE_STYLE , STYLE_SOLID );
   PlotIndexSetInteger ( 3 , PLOT_LINE_STYLE , STYLE_SOLID );
   PlotIndexSetInteger ( 4 , PLOT_LINE_STYLE , STYLE_SOLID );
   PlotIndexSetInteger ( 5 , PLOT_LINE_STYLE , STYLE_SOLID );
   PlotIndexSetInteger ( 6 , PLOT_LINE_STYLE , STYLE_SOLID );
   PlotIndexSetInteger ( 7 , PLOT_LINE_STYLE , STYLE_SOLID );
   PlotIndexSetInteger ( 8 , PLOT_LINE_STYLE , STYLE_SOLID );
   PlotIndexSetInteger ( 9 , PLOT_LINE_STYLE , STYLE_SOLID );

   PlotIndexSetInteger ( 0 , PLOT_LINE_COLOR , clrDarkOrange );
   PlotIndexSetInteger ( 1 , PLOT_LINE_COLOR , clrRoyalBlue );
   PlotIndexSetInteger ( 2 , PLOT_LINE_COLOR , clrForestGreen );
   PlotIndexSetInteger ( 3 , PLOT_LINE_COLOR , clrSienna );
   PlotIndexSetInteger ( 4 , PLOT_LINE_COLOR , clrDodgerBlue );
   PlotIndexSetInteger ( 5 , PLOT_LINE_COLOR , clrGreen );
   PlotIndexSetInteger ( 6 , PLOT_LINE_COLOR , clrBrown );
   PlotIndexSetInteger ( 7 , PLOT_LINE_COLOR , clrMediumBlue );
   PlotIndexSetInteger ( 8 , PLOT_LINE_COLOR , clrTeal );
   PlotIndexSetInteger ( 9 , PLOT_LINE_COLOR , clrMaroon );

   PlotIndexSetInteger ( 0 , PLOT_LINE_WIDTH , 0 );
   PlotIndexSetInteger ( 1 , PLOT_LINE_WIDTH , 0 );
   PlotIndexSetInteger ( 2 , PLOT_LINE_WIDTH , 0 );
   PlotIndexSetInteger ( 3 , PLOT_LINE_WIDTH , 0 );
   PlotIndexSetInteger ( 4 , PLOT_LINE_WIDTH , 0 );
   PlotIndexSetInteger ( 5 , PLOT_LINE_WIDTH , 0 );
   PlotIndexSetInteger ( 6 , PLOT_LINE_WIDTH , 0 );
   PlotIndexSetInteger ( 7 , PLOT_LINE_WIDTH , 0 );
   PlotIndexSetInteger ( 8 , PLOT_LINE_WIDTH , 0 );
   PlotIndexSetInteger ( 9 , PLOT_LINE_WIDTH , 0 );

   SetIndexBuffer ( 20 ,nen_ZigZagH, INDICATOR_DATA );   // Plot = 10
   SetIndexBuffer ( 21 ,nen_ZigZagL, INDICATOR_DATA );   // Plot = 11
   PlotIndexSetInteger ( 10 , PLOT_DRAW_TYPE , DRAW_ARROW ); 
   PlotIndexSetInteger ( 10 , PLOT_ARROW , 159 ); 
   PlotIndexSetInteger ( 10 , PLOT_LINE_STYLE , STYLE_SOLID );
   PlotIndexSetInteger ( 10 , PLOT_LINE_WIDTH , 0 );
   PlotIndexSetInteger ( 10 , PLOT_LINE_COLOR , clrMagenta );
   PlotIndexSetInteger ( 11 , PLOT_DRAW_TYPE , DRAW_ARROW ); 
   PlotIndexSetInteger ( 11 , PLOT_ARROW , 159 ); 
   PlotIndexSetInteger ( 11 , PLOT_LINE_STYLE , STYLE_SOLID );
   PlotIndexSetInteger ( 11 , PLOT_LINE_WIDTH , 0 );
   PlotIndexSetInteger ( 11 , PLOT_LINE_COLOR , clrMagenta );

   SetIndexBuffer ( 22 ,ham, INDICATOR_DATA );   // Plot = 12
   SetIndexBuffer ( 23 ,lam, INDICATOR_DATA );   // Plot = 13
   PlotIndexSetInteger ( 12 , PLOT_DRAW_TYPE , DRAW_LINE );
   PlotIndexSetInteger ( 12 , PLOT_LINE_STYLE , STYLE_DOT );
   PlotIndexSetInteger ( 12 , PLOT_LINE_WIDTH , 0 );
   PlotIndexSetInteger ( 12 , PLOT_LINE_COLOR , clrGreen );
   PlotIndexSetInteger ( 13 , PLOT_DRAW_TYPE , DRAW_LINE );
   PlotIndexSetInteger ( 13 , PLOT_LINE_STYLE , STYLE_DOT );
   PlotIndexSetInteger ( 13 , PLOT_LINE_WIDTH , 0 );
   PlotIndexSetInteger ( 13 , PLOT_LINE_COLOR , clrOrange );

   SetIndexBuffer ( 24 ,ha, INDICATOR_DATA );   // Plot = 14
   SetIndexBuffer ( 25 ,la, INDICATOR_DATA );   // Plot = 15
   PlotIndexSetInteger ( 14 , PLOT_DRAW_TYPE , DRAW_LINE );
   PlotIndexSetInteger ( 14 , PLOT_LINE_STYLE , STYLE_DOT );
   PlotIndexSetInteger ( 14 , PLOT_LINE_WIDTH , 0 );
   PlotIndexSetInteger ( 14 , PLOT_LINE_COLOR , clrGreen );
   PlotIndexSetInteger ( 15 , PLOT_DRAW_TYPE , DRAW_LINE );
   PlotIndexSetInteger ( 15 , PLOT_LINE_STYLE , STYLE_DOT );
   PlotIndexSetInteger ( 15 , PLOT_LINE_WIDTH , 0 );
   PlotIndexSetInteger ( 15 , PLOT_LINE_COLOR , clrRed );

   SetIndexBuffer ( 26 ,ZigzagBuffer, INDICATOR_DATA );
   SetIndexBuffer ( 27 ,HighMapBuffer, INDICATOR_CALCULATIONS );
   SetIndexBuffer ( 28 ,LowMapBuffer, INDICATOR_CALCULATIONS );
   PlotIndexSetInteger ( 16 , PLOT_DRAW_TYPE , DRAW_SECTION ); 
   PlotIndexSetInteger ( 16 , PLOT_LINE_STYLE , STYLE_SOLID );
   PlotIndexSetInteger ( 16 , PLOT_LINE_WIDTH , 1 );
   PlotIndexSetInteger ( 16 , PLOT_LINE_COLOR , clrRed );

//--- set short name and digits   
   PlotIndexSetString ( 16 , PLOT_LABEL , "ZigZag(" +( string )ExtDepth+ "," +( string )ExtDeviation+ "," +( string )ExtBackstep+ ")" );
   IndicatorSetInteger ( INDICATOR_DIGITS , _Digits );
//--- set empty value
   PlotIndexSetDouble ( 16 , PLOT_EMPTY_VALUE , 0.0 );
//--- to use in cycle
   deviation=ExtDeviation* _Point ;
//---
   return ( 0 );
  }
//+------------------------------------------------------------------+
//|  searching index of the highest bar                              |
//+------------------------------------------------------------------+
int iHighest ( const double &array[],
             int depth,
             int startPos)
  {
   int index=startPos;
//--- start index validation
   if (startPos< 0 )
     {
       Print ( "Invalid parameter in the function iHighest, startPos =" ,startPos);
       return 0 ;
     }
   int size= ArraySize (array);
//--- depth correction if need
   if (startPos-depth< 0 ) depth=startPos;
   double max=array[startPos];
//--- start searching
   for ( int i=startPos;i>startPos-depth;i--)
     {
       if (array[i]>max)
        {
         index=i;
         max=array[i];
        }
     }
//--- return index of the highest bar
   return (index);
  }
//+------------------------------------------------------------------+
//|  searching index of the lowest bar                               |
//+------------------------------------------------------------------+
int iLowest ( const double &array[],
             int depth,
             int startPos)
  {
   int index=startPos;
//--- start index validation
   if (startPos< 0 )
     {
       Print ( "Invalid parameter in the function iLowest, startPos =" ,startPos);
       return 0 ;
     }
   int size= ArraySize (array);
//--- depth correction if need
   if (startPos-depth< 0 ) depth=startPos;
   double min=array[startPos];
//--- start searching
   for ( int i=startPos;i>startPos-depth;i--)
     {
       if (array[i]<min)
        {
         index=i;
         min=array[i];
        }
     }
//--- return index of the lowest bar
   return (index);
  }
//+------------------------------------------------------------------+
//| 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 i= 0 ;
   int limit= 0 ,counterZ= 0 ,whatlookfor= 0 ;
   int shift= 0 ,back= 0 ,lasthighpos= 0 ,lastlowpos= 0 ;
   double val= 0 ,res= 0 ;
   double curlow= 0 ,curhigh= 0 ,lasthigh= 0 ,lastlow= 0 ;
//--- auxiliary enumeration
   enum looling_for
     {
      Pike= 1 ,   // searching for next high
      Sill=- 1    // searching for next low
     };
//--- initializing
   if (prev_calculated== 0 )
     {
       ArrayInitialize (ZigzagBuffer, 0.0 );
       ArrayInitialize (HighMapBuffer, 0.0 );
       ArrayInitialize (LowMapBuffer, 0.0 );
     }
//--- 
   if (rates_total< 100 ) return ( 0 );
//--- set start position for calculations
   if (prev_calculated== 0 ) limit=ExtDepth;

//--- ZigZag was already counted before
   if (prev_calculated> 0 )
     {
      i=rates_total- 1 ;
       //--- searching third extremum from the last uncompleted bar
       while (counterZ<level && i>rates_total- 100 )
        {
         res=ZigzagBuffer[i];
         if (res!= 0 ) counterZ++;
         i--;
        }
      i++;
      limit=i;

       //--- what type of exremum we are going to find
       if (LowMapBuffer[i]!= 0 )
        {
         curlow=LowMapBuffer[i];
         whatlookfor=Pike;
        }
       else
        {
         curhigh=HighMapBuffer[i];
         whatlookfor=Sill;
        }
       //--- chipping
       for (i=limit+ 1 ;i<rates_total && ! IsStopped ();i++)
        {
         ZigzagBuffer[i]= 0.0 ;
         LowMapBuffer[i]= 0.0 ;
         HighMapBuffer[i]= 0.0 ;
        }
     }

//--- searching High and Low
   for (shift=limit;shift<rates_total && ! IsStopped ();shift++)
     {
      val=low[ iLowest (low,ExtDepth,shift)];
       if (val==lastlow) val= 0.0 ;
       else
        {
         lastlow=val;
         if ((low[shift]-val)>deviation) val= 0.0 ;
         else
           {
             for (back= 1 ;back<=ExtBackstep;back++)
              {
               res=LowMapBuffer[shift-back];
               if ((res!= 0 ) && (res>val)) LowMapBuffer[shift-back]= 0.0 ;
              }
           }
        }
       if (low[shift]==val) LowMapBuffer[shift]=val; else LowMapBuffer[shift]= 0.0 ;
       //--- high
      val=high[ iHighest (high,ExtDepth,shift)];
       if (val==lasthigh) val= 0.0 ;
       else
        {
         lasthigh=val;
         if ((val-high[shift])>deviation) val= 0.0 ;
         else
           {
             for (back= 1 ;back<=ExtBackstep;back++)
              {
               res=HighMapBuffer[shift-back];
               if ((res!= 0 ) && (res<val)) HighMapBuffer[shift-back]= 0.0 ;
              }
           }
        }
       if (high[shift]==val) HighMapBuffer[shift]=val; else HighMapBuffer[shift]= 0.0 ;
     }

//--- last preparation
   if (whatlookfor== 0 ) // uncertain quantity
     {
      lastlow= 0 ;
      lasthigh= 0 ;
     }
   else
     {
      lastlow=curlow;
      lasthigh=curhigh;
     }

//--- final rejection
   for (shift=limit;shift<rates_total && ! IsStopped ();shift++)
     {
      res= 0.0 ;
       switch (whatlookfor)
        {
         case 0 : // search for peak or lawn
             if (lastlow== 0 && lasthigh== 0 )
              {
               if (HighMapBuffer[shift]!= 0 )
                 {
                  lasthigh=high[shift];
                  lasthighpos=shift;
                  whatlookfor=Sill;
                  ZigzagBuffer[shift]=lasthigh;
                  res= 1 ;
                 }
               if (LowMapBuffer[shift]!= 0 )
                 {
                  lastlow=low[shift];
                  lastlowpos=shift;
                  whatlookfor=Pike;
                  ZigzagBuffer[shift]=lastlow;
                  res= 1 ;
                 }
              }
             break ;
         case Pike: // search for peak
             if (LowMapBuffer[shift]!= 0.0 && LowMapBuffer[shift]<lastlow && HighMapBuffer[shift]== 0.0 )
              {
               ZigzagBuffer[lastlowpos]= 0.0 ;
               lastlowpos=shift;
               lastlow=LowMapBuffer[shift];
               ZigzagBuffer[shift]=lastlow;
               res= 1 ;
              }
             if (HighMapBuffer[shift]!= 0.0 && LowMapBuffer[shift]== 0.0 )
              {
               lasthigh=HighMapBuffer[shift];
               lasthighpos=shift;
               ZigzagBuffer[shift]=lasthigh;
               whatlookfor=Sill;
               res= 1 ;
              }
             break ;
         case Sill: // search for lawn
             if (HighMapBuffer[shift]!= 0.0 && HighMapBuffer[shift]>lasthigh && LowMapBuffer[shift]== 0.0 )
              {
               ZigzagBuffer[lasthighpos]= 0.0 ;
               lasthighpos=shift;
               lasthigh=HighMapBuffer[shift];
               ZigzagBuffer[shift]=lasthigh;
              }
             if (LowMapBuffer[shift]!= 0.0 && HighMapBuffer[shift]== 0.0 )
              {
               lastlow=LowMapBuffer[shift];
               lastlowpos=shift;
               ZigzagBuffer[shift]=lastlow;
               whatlookfor=Pike;
              }
             break ;
         default : return (rates_total);
        }
     }

//--- return value of prev_calculated for next call
   return (rates_total);
  }
//+------------------------------------------------------------------+

터미널 개발자가 이 오류를 수정하도록 도와주세요.

유물이 있는 그림:

[Artyom Trishkin]

Eugeni Neumoin :

오류를 극복할 수 없습니다.

오류를 보여주기 위해 메타 트레이더의 전달에서 지그재그로 가져갔습니다. 내 프로그램에서 코드로 가져온 추가 버퍼를 추가했습니다. 이 코드에서는 추가 버퍼를 사용한 조작이 제공되지 않습니다. 그들은 단지 오류를 보여주기 위한 것입니다.

나는 이 지그재그를 EURUSD 차트, H1 시간대에 가져왔습니다. 터미널을 닫았습니다. 생성된 모든 EURUSD 시계열을 기록에서 삭제했습니다. 즉, EURUSD 통화 쌍에 대한 모든 *.hcc 및 *.hc 파일을 삭제했습니다. 이것은 터미널이 부팅될 때 .hcc 파일이 로드되기 시작하고 .hc 파일이 깨끗한 슬레이트에서 생성되도록 수행됩니다.

터미널을 실행 한 후 EURUSD 차트에 많은 아티팩트가 있습니다. 그리고 이러한 아티팩트는 극복할 수 없습니다.

수정된 지그재그의 코드를 텍스트 형태로 파일로 첨부합니다.

#propert를 사용하여 ZigZag 매개변수 설정을 떠났다는 것을 경고합니다.

지그재그용 버퍼를 포함한 모든 것이 프로그래밍 방식으로 동적으로 변경되기 때문에 #propert를 통해 다른 모든 버퍼를 설정하지 않습니다.

터미널 개발자가 이 오류를 수정하도록 도와주세요.

유물이 있는 그림:

모든 버퍼를 초기화해야 합니다.

막대의 버퍼에 값이 없으면 버퍼에 명시적으로 기록해야 합니다. 즉, 계산된 값을 버퍼에 출력해야 하는 경우 버퍼에 쓰고, 그렇지 않으면 빈 값을 씁니다.

[fxsaber]

Vict :

일반적으로 나는 이것을 기대하지도 않았습니다.

집에서의 발사는 눈에 띄는 차이를 보이지 않았습니다.

대신에

거래, 자동 거래 시스템 및 거래 전략 테스트에 관한 포럼

오류, 버그, 질문

빅트 , 2019.07.09 07:17

   Data data[ 32768 ];

하다

   Data data[];
   
   ArrayResize (data, 32768 );

그러면 6배 느려집니다!

[Eugeni Neumoin]

Artyom Trishkin :

모든 버퍼를 초기화해야 합니다.

막대의 버퍼에 값이 없으면 버퍼에 명시적으로 기록해야 합니다. 즉, 계산된 값을 버퍼에 출력해야 하는 경우 버퍼에 쓰고, 그렇지 않으면 빈 값을 씁니다.

죄송합니다. 초기화를 놓쳤습니다. 나는 프로그램에 그것을 가지고 있지만 나는 예제에서 그것을 놓쳤다.

초기화된 첨부파일입니다. 효과는 동일합니다.

개발자에게 질문이 남아 있습니다. 이 오류를 수정하십시오.

----------

제 생각에는 다음과 같은 일이 일어나고 있습니다. 터미널과 함께 프로그램을 실행할 때 시계열 크기는 0과 같거나 최소값을 갖습니다.

초기화는 기존 기록에 대해 수행됩니다. 그리고 시계열 크기가 증가하면 버퍼 배열은 초기화를 거치지 않은 메모리 섹션을 사용합니다. 결과적으로 우리는 그러한 효과를 얻습니다.

터미널 이벤트를 통해 이 효과를 제거하려고 했습니다. 마찬가지로 아티팩트가 잠시 동안 나타납니다. 나쁜거야? 그러한 프로그램은 대중에게 공개되어서는 안됩니다.

이렇게 고칠 수 있습니다. 버퍼에 메모리를 할당한 후 즉시 이 메모리를 지웁니다. 하지만 어떻게 해야 할까요? 터미널용 애플리케이션 개발자 입장에서는 그런 기회를 찾지 못했습니다.