Caratteristiche del linguaggio mql5, sottigliezze e tecniche - pagina 220

Nuovo commento
 
Nikolai Semko #:

significa che in modalità di combattimento si dovrebbe spegnere tutte le sciocchezze grafiche senza minimizzare. Lascia che la grafica sia congelata se la finestra rimane visibile ma non attiva.
Ed è più facile e meglio, mi sembra, spegnere e rimuovere automaticamente tutta la grafica quando il mouse è inattivo, per esempio 1 minuto. Non appena il mouse è attivo - la grafica riprende.

Questo non è affatto buono. Qui si guarda il grafico per 2 minuti, e il grafico è morto un minuto fa. Che bisogno c'è allora?

 
Vitaly Muzichenko #:

Questo non è affatto buono. Si guarda il grafico per due minuti e il grafico è morto un minuto fa. A cosa serve allora?

Beh, ovviamente, hai bisogno di un interruttore "Auto-hide" per questa modalità.

 
Nikolai Semko #:

significa che in modalità di combattimento tutti gli overhead grafici devono essere spenti senza minimizzazione.

Il kanvas del grafico stesso è disegnato senza minimizzazione. In modo sperimentale è stato trovato il modo di funzionamento del terminale, quando il VPS è caricato al minimo.

 

Spero di scrivere nell'argomento giusto.

1. Eseguire un test su diverse coppie allo stesso tempo, multi-valuta

Domanda: come ottengo il risultato per ogni coppia?

2Conduciamo l'ottimizzazione per diverse coppie allo stesso tempo

Domanda: come ottenere un risultato per ogni coppia?

---

Qualche tempo fa, circa 3 anni fa, hanno promesso di includere questo nel tester, ma finora non c'è nulla. O non lo trovo?

 

C'è un modo legale per fermare il funzionamento di Market Advisor o Signal Service, per esempio. Diciamo che non c'è accesso ad essi per una ragione o per l'altra - VPS.

Il metodo funziona se c'è una restrizione sul server di trading. Devi solo riempire tutto con ordini pendenti, ma con attenzione, altrimenti sarà impossibile chiudere le posizioni aperte.


Forse qualcuno scriverà un tale prodotto di emergenza del mercato...

 

MQL5. MESSAGE BOX duplica i messaggi nel registro "Experts". Per favore, consigliate come disabilitarlo. ***

Grazie!

 

Forum sul trading, sistemi di trading automatico e test di strategie di trading

Caratteristiche del linguaggio mql5, sottigliezze e trucchi

fxsaber, 2017.09.22 20:43

POSITION_TIME_UPDATE è rilevante solo per cambiare il lotto di una posizione. Per esempio, una chiusura parziale di una posizione su qualsiasi tipo di conto o un'aggiunta di netting.

I cambiamenti nei livelli SL/TP non influiscono su POSITION_TIME_UPDATE.

Parafrasando, POSITION_TIME_UPDATE è influenzato solo dalle modifiche riflesse nel Trade History - trades. I livelli SL/TP non si applicano a tali modifiche, quindi non sono interessati.

Ci possono essere situazioni in cui POSITION_TIME_UPDATE_MSC == POSITION_TIME_UPDATE nonostante i cambiamenti nella dimensione del lotto.

 
I commenti non relativi a questo argomento sono stati spostati in "Tutte le domande dei neofiti su MQL4 e MQL5, aiuto e discussione su algoritmi e codici".
 
fxsaber #:
Ordinamento pratico di una serie di strutture


Applicazione


Risultato

Ciao e grazie per aver condiviso!

Questo sarebbe perfetto se funzionasse. Tuttavia, quando viene incollato in uno script .mq5 ed eseguito, purtroppo il tuo codice genera il seguente errore:

  • le dichiarazioni di template non sono permesse nelle classi locali ArraySortStruct.mq5 87 4
  • (dopo aver modificato leggermente il tuo codice): le dichiarazioni di template sono permesse solo nello scopo globale, nello spazio dei nomi o nella classe ArraySortStruct.mq5 90 4 )

Potresti per favore risolvere questo problema? Per te è probabilmente facile, mentre io non saprei da dove cominciare :-)

 
Bodolino #:

Ciao e grazie per aver condiviso!

Questo sarebbe perfetto se funzionasse. Tuttavia, quando viene incollato in uno script .mq5 ed eseguito, purtroppo il tuo codice genera il seguente errore:

  • le dichiarazioni di template non sono permesse nelle classi locali ArraySortStruct.mq5 87 4
  • (dopo aver modificato leggermente il tuo codice): le dichiarazioni di template sono permesse solo nello scopo globale, nello spazio dei nomi o nella classe ArraySortStruct.mq5 90 4 )

Potresti per favore risolvere questo problema? Per te è probabilmente facile, mentre io non saprei da dove cominciare :-)

Non sono sicuro di come mantenere la funzionalità (sottocampo e metodo) e l'usabilità. Forse questo farà al caso vostro.

// Сортировка массива структур и указателей на объекты 
по полю.
#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)


Applicazione.

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
Nuovo commento