Características da linguagem mql5, subtilezas e técnicas - página 220

Novo comentário
 
Nikolai Semko #:

significa que em modo de combate deve desligar todos os disparates gráficos sem minimização. Deixar os gráficos congelados se a janela permanecer visível mas não activa.
E é mais fácil e melhor, parece-me, desligar e remover automaticamente todos os gráficos quando o rato está inactivo, por exemplo 1 minuto. Assim que o rato estiver activo - os gráficos são retomados.

Isto não é de todo bom. Aqui, olha-se para o gráfico durante 2 minutos, e o gráfico morreu há um minuto. Qual é então a sua necessidade?

 
Vitaly Muzichenko #:

Isto não é de todo bom. Olhamos para o gráfico durante dois minutos e o gráfico morreu há um minuto. Então para que serve?

Bem, claro, é necessário um interruptor "Auto-hide" para esse modo.

 
Nikolai Semko #:

significa que em modo de combate todas as despesas gerais gráficas devem ser desligadas sem minimização.

A kanvas da própria carta é desenhada sem minimização. Foi encontrado o modo de operação do Terminal, quando o VPS é carregado minimamente.

 

Espero estar a escrever no assunto certo.

1. Realização de um teste em vários pares ao mesmo tempo, multi-moeda

Pergunta: Como obter o resultado para cada par?

2Realizamos a optimização para vários pares ao mesmo tempo

Pergunta: como obter um resultado para cada par?

---

Há algum tempo, há cerca de 3 anos, prometeram incluir isto no testador, mas até agora não há nada. Ou não o estou a encontrar?

 

Existe uma forma legal de parar o trabalho do Market Advisor ou do Signal Service, por exemplo. Digamos que não há acesso a eles por uma razão ou outra - VPS.

O método funcionará se houver uma restrição no servidor de negociação. Basta preencher tudo com ordens pendentes, mas com cuidado, caso contrário será impossível fechar as posições em aberto.


Talvez alguém escreva um produto de mercado tão urgente...

 

MQL5. A CAIXA DE MENSAGENS duplica mensagens no registo "Especialistas". Aconselhar como desactivá-lo. ***

Obrigado!

 

Fórum sobre comércio, sistemas automatizados de comércio e teste de estratégias comerciais

Características da linguagem mql5, subtilezas e truques

fxsaber, 2017.09.22 20:43

POSITION_TIME_UPDATE só é relevante para alterar o lote de uma posição. Por exemplo, um encerramento parcial de uma posição em qualquer tipo de conta ou um add-on de rede.

As alterações nos níveis SL/TP não afectam POSITION_TIME_UPDATE.

Parafraseando, POSITION_TIME_UPDATE é apenas afectado por modificações reflectidas na História do Comércio - comércios. Os níveis SL/TP não se aplicam a tais modificações, pelo que não são afectados.

Pode haver situações em que POSITION_TIME_UPDATE_MSC == POSITION_TIME_UPDATE apesar das alterações no tamanho do lote.

 
Comentários não relacionados com este tópico foram movidos para"Quaisquer perguntas de novatos sobre MQL4 e MQL5, ajuda e discussão sobre algoritmos e códigos".
 
fxsaber #:
Classificar manualmente um conjunto de estruturas


Aplicação


Resultado

Olá e obrigado por partilharem!

Isto seria perfeito se funcionasse. No entanto, quando colado num script .mq5 e executado infelizmente o seu código atira o(s) seguinte(s) erro(s):

  • modelos de declarações não são permitidos nas classes locais ArraySortStruct.mq5 87 4
  • (depois de alterar ligeiramente o seu código): as declarações modelo são permitidas apenas no âmbito global, namespace ou de classe ArraySortStruct.mq5 90 4 )

Poderia, por favor, resolver isto? Para si é provavelmente fácil, enquanto eu não saberia por onde começar :-)

 
Bodolino #:

Olá e obrigado por partilharem!

Isto seria perfeito se funcionasse. No entanto, quando colado num script .mq5 e executado infelizmente o seu código atira o(s) seguinte(s) erro(s):

  • modelos de declarações não são permitidos nas classes locais ArraySortStruct.mq5 87 4
  • (depois de alterar ligeiramente o seu código): as declarações modelo são permitidas apenas no âmbito global, namespace ou de classe ArraySortStruct.mq5 90 4 )

Poderia, por favor, resolver isto? Para si é provavelmente fácil, enquanto eu não saberia por onde começar :-)

Não sei como manter a funcionalidade (subcampo e método) e a usabilidade. Talvez esta se adapte às suas necessidades.

// Сортировка массива структур и указателей на объекты 
по полю.
#define  ArraySortStruct_Define(TYPE, FIELD)                                      \
namespace TYPE##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);                                              \
                                                                                 \
      SORT::QuickSort(Array, Start, Start + Count - 1);                          \
                                                                                 \
      return;                                                                    \
    }                                                                            \
  };                                                                             \
}

#define  ArraySortStruct(TYPE, ARRAY, FIELD) TYPE##FIELD::SORT::Sort(ARRAY)


Aplicação.

ArraySortStruct_Define(MqlRates, open)
ArraySortStruct_Define(MqlRates, high)
ArraySortStruct_Define(MqlRates, time)

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

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

  Print("\nСортируем по времени.");
  ArraySortStruct(MqlRates, Rates, time);
  ArrayPrint(Rates);
}
1...213214215216217218219220221222223224225226227...247
Novo comentário
Razão: