mql5语言的特点、微妙之处以及技巧 - 页 165

新评论
 
fxsaber:

是的，我有历史读本。

你当时写道，我的指标很慢。
我找到了那件事的原因。当我给账户装上30,000笔交易时。
我设法减少刹车。我重新设计了一下历史阅读，并优化了代码。但它仍然有它们。原因是有过滤器，当我点击一个过滤器时，所有的东西都被重新计算。
尽管一切都从数组中读取。
在有5000次交易的账户上，一切都很好。但对于大型的来说，这是个问题。
它不仅涉及该指标。

我做了一个 干净的历史阅读项目。
也许，这可能是由于互联网的关系。毕竟，整个历史是大量的数据。

 

关于交易、自动交易系统和策略测试的论坛

图书馆：Easy Canvas

Nikolai Semko, 2020.02.17 05:15

我想为感兴趣的程序员在测试器模式下操作kanvas时澄清一个重要问题。
这个社区的一个知名程序员带着这个问题来找我。

- 为什么在测试模式下，我在对象上创建的面板的重绘速度比在画布上的快得多，而在正常模式下，我的面板是以正常速度在画布上绘制的？

我已经明白了其中的原因，并找到了解决问题的办法。

问题是，对象的重绘与整个屏幕的重绘同时进行，而测试器中的屏幕重绘频率不超过每秒30帧。

对象最终是同一个画布（内部），但是当你改变对象的属性 时，对象的画布并没有生成（没有重新计算），而是在屏幕更新时才生成（ChartRedraw），这在测试者中发生的频率（在正常模式下也是如此）不超过我们眼睛能够分辨的变化，即不超过每秒~32帧的频率。

假设面板每一个刻度都在变化。然后，默认画布也会在每一次勾选中重绘，但在测试器中重绘的频率仍然不超过~30毫秒（~30帧）。

换句话说，画布被重新计算的次数将远远多于它在屏幕上实际显示的次数，这导致了资源的不相称的使用。

解决这个问题的办法是确保画布的重新计算和重新绘制的频率不超过每15-30毫秒的计算机时间，然后就不会出现不必要的空的重新计算周期。

例如，像这样。

void OnTick()
  {
  static uint lastCalc=0;
  uint cur=GetTickCount();
  if (cur-lastCalc>15) {
    ReDrawMyCanvas();
    lastCalc=cur;
   }
  }

 
例如，如果你想创建一个文件 "EURUSD.txt"（大字符），而磁盘上已经有 "eurusd.txt"（小字符），该文件的名称将与之前相同。
 
fxsaber:
例如，如果我想创建文件 "EURUSD.txt"（大符号），而磁盘上已经有 "eurusd.txt"（小符号），该文件的名称将与之前相同。

此外，当我保存EURUSD TicksLongOpt.set时，eurusd tickslongopt.set被保存。我必须在事后重新命名。有很多像这样令人讨厌的小事。

 
Edgar Akhmadeev:

此外，当我保存EURUSD TicksLongOpt.set时，eurusd tickslongopt.set被保存。我必须在事后重新命名。之后我还得给它重新命名。 有很多这样恼人的小事。

我想如果我先删除它，然后再创建它，一切都会好起来。

 
fxsaber:

我想，如果你先删除，然后再创建，你就会没事。

不，我说的是创建一个新文件，特别是在从终端对话框保存时。如果它对每个人都不起作用，那么就取决于其他方面。我有Win7，如果有的话。

 
Edgar Akhmadeev:

不，我的意思是创建一个新的文件，正是从终端对话框中保存时。如果它对每个人都不起作用，那么就取决于其他方面。我有Win7，如果有的话。

我是指FileOpen 和FileSave函数。

 
fxsaber:

我是指FileOpen和FileSave函数。

是的，现在我才意识到这是不合时宜的，这个话题是关于语言的...

 
fxsaber:
易于对结构阵列进行排序


应用


结果

它不工作，你能更新它吗？在本地类中不允许设置模板声明 TestarrSort.mq5 81 3

// Сортировка массива структур и указателей на объекты по (под-) полю/методу.
#define  ArraySortStruct(ARRAY, FIELD)                                            \
{                                                                                \
  class SORT                                                                     \
  {                                                                              \
  private:                                                                       \
    template <typename T>                                                        \
    static void Swap( T &Array[], const int i, const int j )                     \
    {                                                                            \
      const T Temp = Array[i];                                                   \
                                                                                 \
      Array[i] = Array[j];                                                       \
      Array[j] = Temp;                                                           \
                                                                                 \
      return;                                                                    \
    }                                                                            \
                                                                                 \
    template <typename T>                                                        \
    static int Partition( T &Array[], const int Start, const int End )           \
    {                                                                            \
      int Marker = Start;                                                        \
                                                                                 \          
      for (int i = Start; i <= End; i++)                                         \
        if (Array[i].##FIELD <= Array[End].##FIELD)                              \
        {                                                                        \
          SORT::Swap(Array, i, Marker);                                          \
                                                                                 \
          Marker++;                                                              \
        }                                                                        \
                                                                                 \
       return(Marker - 1);                                                       \
    }                                                                            \
                                                                                 \
    template <typename T>                                                        \
    static void QuickSort( T &Array[], const int Start, const int End )          \
    {                                                                            \
      if (Start < End)                                                           \
      {                                                                          \
        const int Pivot = Partition(Array, Start, End);                          \
                                                                                 \
        SORT::QuickSort(Array, Start, Pivot - 1);                                \
        SORT::QuickSort(Array, Pivot + 1, End);                                  \
      }                                                                          \
                                                                                 \
      return;                                                                    \
    }                                                                            \
                                                                                 \
  public:                                                                        \
    template <typename T>                                                        \ 
    static void Sort( T &Array[], int Count = WHOLE_ARRAY, const int Start = 0 ) \
    {                                                                            \
      if (Count == WHOLE_ARRAY)                                                  \
        Count = ::ArraySize(Array)- Start; ;                                     \
                                                                                 \
      SORT::QuickSort(Array, Start, Start + Count - 1);                          \
                                                                                 \
      return;                                                                    \
    }                                                                            \
  };                                                                             \
                                                                                 \
  SORT::Sort(ARRAY);                                                             \
}                                                                                \


void OnStart()
{
  MqlRates Rates[];
  
  CopyRates(_Symbol, PERIOD_CURRENT, 0, 5, Rates); // Взяли бары
  
  Print("\nБары без сортировки - как получили.");
  ArrayPrint(Rates);
  
  Print("\nСортируем по open-цене.");
  ArraySortStruct(Rates, open);
  ArrayPrint(Rates);

  Print("\nСортируем по high-цене.");
  ArraySortStruct(Rates, high);
  ArrayPrint(Rates);

  Print("\nСортируем по времени.");
  ArraySortStruct(Rates, time);
  ArrayPrint(Rates);
}

 
Vladimir Pastushak:

不工作，你能更新吗？在本地类中不允许写模板声明 TestarrSort.mq5 81 3

不幸的是，这些语言 已经被切断了。这个代码不起作用。

void OnStart()
{
  class A
  {
    template <typename T> // template declarations are not allowed in local classes
    void f() {}
  };
}


但你可以尝试另一种变体。

template <typename T>                                       
void ArrayReindex( T &Array[], const double &TmpSort[][2] )
{                         
  T TmpArray[];
  
  for (int i = ::ArrayResize(TmpArray, ::ArrayRange(TmpSort, 0)) - 1; i >= 0; i--)
    TmpArray[i] = Array[(int)(TmpSort[i][1] + 0.1)];
    
  ::ArraySwap(Array, TmpArray);
              
  return;     
}             

// Сортировка массива структур и указателей на объекты по (под-) полю/методу.
#define  ArraySortStruct(ARRAY, FIELD)                                      \
{                                                                          \
  double TmpSort[][2];                                                     \
                                                                           \
  for (int i =::ArrayResize(TmpSort, ::ArraySize(ARRAY)) - 1; i >= 0; i--) \
  {                                                                        \
    TmpSort[i][0] = (double)ARRAY[i].FIELD;                                \
    TmpSort[i][1] = i;                                                     \
  }                                                                        \
                                                                           \
  ::ArraySort(TmpSort);                                                    \
  ::ArrayReindex(ARRAY, TmpSort);                                          \
}                                         

void OnStart()
{
  MqlRates Rates[];
  
  CopyRates(_Symbol, PERIOD_CURRENT, 0, 5, Rates); // Взяли бары
  
  Print("\nБары без сортировки - как получили.");
  ArrayPrint(Rates);
  
  Print("\nСортируем по open-цене.");
  ArraySortStruct(Rates, open);
  ArrayPrint(Rates);

  Print("\nСортируем по high-цене.");
  ArraySortStruct(Rates, high);
  ArrayPrint(Rates);

  Print("\nСортируем по времени.");
  ArraySortStruct(Rates, time);
  ArrayPrint(Rates);
}


SZZ这里 是另一个用法的例子。

1...158159160161162163164165166167168169170171172...247
新评论