Campionato di ottimizzazione degli algoritmi.

Dmitry Fedoseev 2016.06.21 23:05 #501

Non è chiaro riguardo alla seconda opzione, abbiamo bisogno di un esempio di script del partecipante, un balkan di qualche tipo.

Importato FF, ma non sarà visibile nella funzione del partecipante e la variabile MaxFFruns_P non sarà visibile.

Andrey Dik 2016.06.21 23:11 #502

Dmitry Fedoseev:

Non è chiaro riguardo alla seconda opzione, abbiamo bisogno di un esempio di script del partecipante, un balkan di qualche tipo.

Importato FF, ma non sarà visibile nella funzione del partecipante e la variabile MaxFFruns_P non sarà visibile.

Intendi l'esempio dell'algoritmo del partecipante?

Beh, all'algoritmo è stato detto di non chiamare FF più di tante volte

InitAO (paramCount, MaxFFruns_P);

Secondo la seconda opzione, l'algoritmo membro importa anche i FF. Ho controllato, una stessa copia della libreria FF è usata nello script e nell'algoritmo. Cioè, l'algoritmo accede al FF con le sue funzioni importate e lo script con le sue, ma il conteggio delle chiamate dello script è corretto.

Andrey Dik:

Ora aggiungerò degli esempi degli algoritmi stessi per entrambi i tipi di chiamate al FF, al massimo, nativo e amato MSF. Per favore, amore e amore, specialmente per i principianti. Sono facili da capire, un esempio di come si può costruire un algoritmo di ottimizzazione elementare semplice e allo stesso tempo funzionante.

Domande da un "manichino" Aiutami a imparare a Tutte le domande dei

Dmitry Fedoseev 2016.06.21 23:15 #503

Andrey Dik:

Intende l'esempio dell'algoritmo del partecipante?

Qui, all'algoritmo è stato detto di non chiamare le FF più di tante volte.

InitAO (paramCount, MaxFFruns_P);

Secondo la seconda opzione, l'algoritmo membro importa anche i FF. Ho controllato, la stessa copia della libreria FF è usata nello script e nell'algoritmo.

Questo è ciò di cui avete bisogno per mostrare il modello per il partecipante. Viene mostrato lo script del controllore.

Il numero di parametri è chiaro. Ma dobbiamo scrivere delle istruzioni, almeno un paio di parole.

Andrey Dik 2016.06.21 23:18 #504

Non ci sarà bisogno di fermare le variabili globali. Basta aggiungere un avviso al FF quando il limite di esecuzione viene superato, in modo che possa essere fermato manualmente. L'algoritmo dovrebbe tenere traccia di quante volte chiama il FF.

Auguri per MQL5 Errori, bug, domande Aiuto per la codifica

Andrey Dik 2016.06.21 23:23 #505

Dmitry Fedoseev:

Qui è dove dovrebbe essere mostrato il modello del partecipante. Viene mostrato lo script del controllore.

Il numero di parametri è chiaro. Ma dobbiamo scrivere delle istruzioni, almeno un paio di parole.

Dovresti. Ci sarà un'istruzione, naturalmente.

Ma tutto è abbastanza semplice, non avremo bisogno di OOP per partecipare, e crediamo che i partecipanti saranno in grado di capire 20 linee di codice, non sono bambini verdi da quando sono venuti al campionato).

L'apprendimento automatico nel trading: Martingala: la massima catena FOREX - Tendenze, previsioni

Dmitry Fedoseev 2016.06.21 23:25 #506

Andrey Dik:

Dobbiamo farlo. Ci saranno delle istruzioni, naturalmente.

Ma tutto è semplice così com'è, non avrete bisogno di OOP per partecipare, e i partecipanti saranno probabilmente in grado di capire 20 linee di codice, dato che non sono verdi, dato che sono venuti al campionato).

Può essere semplice, ma solo se si deve indovinare, non è in qualche modo presentabile.

Andrey Dik 2016.06.22 00:28 #507

Un esempio di algoritmo di un partecipante per la prima variante della chiamata FF:

#property library
#property strict

//+------------------------------------------------------------------+
void InitAO (int paramCount, int maxFFruns) export
{ 
}
//+------------------------------------------------------------------+
//
//+------------------------------------------------------------------+
void ServiceFunc1 () export
{ 
}
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
void ServiceFunc2 () export
{ 
}
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
void ServiceFunc3 () export
{ 
}
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
int GetReplaysCount () export
{ 
  return (1);
}
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
void GetOptParam (double &param []) export
{ 
  GenerateParam (param);
}
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
void   SendFFvolue (double volue) export
{ 
  if(volue > maxFFvolue) 
    maxFFvolue = volue;
}
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
double GetMaxFF () export
{ 
  return (maxFFvolue);
}
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
bool StopAlgo () export
{ 
  return (false);
}
//+------------------------------------------------------------------+

//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
// Все функции выше этой строки - обязательны! Именно они будут импортированы 
// и использованы тестовым скриптом. Они нужны для доступа к алгоритму оптимизации.
// Содержимое - произвольное, на усмотрение участника
//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!



//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
// Ниже этой строки пример алгоритма оптимизации участника
//————————————————————————————————————————————————————————————————————
double maxFFvolue = - DBL_MAX;
double minParam   = -10.0;
double maxParam   = 10.0;
double stepParam  = 0.1;
//————————————————————————————————————————————————————————————————————

//————————————————————————————————————————————————————————————————————
// Генерация значений оптимизируемых параметров
void GenerateParam (double &param[])
{
  int size = ArraySize (param);
  double paramVolue = 0.0;
  for(int i = 0; i < size; i++) 
  {
    paramVolue = RNDfromCI (minParam, maxParam);
    param [i] = SeInDiSp (paramVolue, minParam, maxParam, stepParam);
  }
}
//————————————————————————————————————————————————————————————————————

//————————————————————————————————————————————————————————————————————
// Выбор в дискретном пространстве
double SeInDiSp (double in, double inMin, double inMax, double step) 
{ 
  if(in <= inMin) 
    return (inMin); 
  if(in >= inMax) 
    return (inMax); 
  if(step == 0.0) 
    return (in); 
  else 
    return (inMin + step * (double)MathRound ((in - inMin) / step));
}
//————————————————————————————————————————————————————————————————————

//————————————————————————————————————————————————————————————————————
// ГСЧ в заданном интервале
double RNDfromCI (double min, double max) 
{ 
  if(min == max) 
    return (min); 
  double Min, Max; 
  if(min > max) 
  {
    Min = max; 
    Max = min;
  }
  else 
  {
    Min = min; 
    Max = max;
  }
  return (double(Min + ((Max - Min) * (double)MathRand () / 32767.0)));
}
//————————————————————————————————————————————————————————————————————

Risultati dell'esecuzione dell'algoritmo:

2016.06.22 03:25:25.777 OAC variant 1 (GBPUSD,H1) ---------------------------------

2016.06.22 03:25:25.777 OAC variant 1 (GBPUSD,H1) Tempo: 146 µs; 0.00014600 c

2016.06.22 03:25:25.777 OAC variant 1 (GBPUSD,H1) FF runs: 1000

2016.06.22 03:25:25.777 Max: 3.14159260

2016.06.22 03:25:21.874 OAC variant 1 (GBPUSD,H1) ---------------------------------

2016.06.22 03:25:21.874 OAC variant 1 (GBPUSD,H1) Tempo: 148 µs; 0.00014800 c

2016.06.22 03:25:21.874 OAC variant 1 (GBPUSD,H1) FF runs: 1000

2016.06.22 03:25:21.874 OAC variant 1 (GBPUSD,H1) Max: 3.10159260

2016.06.22 03:20:32.249 OAC variant 1 (GBPUSD,H1) ---------------------------------

2016.06.22 03:20:32.249 OAC variant 1 (GBPUSD,H1) Tempo: 149 µs; 0.00014900 c

2016.06.22 03:20:32.249 OAC variant 1 (GBPUSD,H1) FF runs: 1000

2016.06.22 03:20:32.249 OAC variant 1 (GBPUSD,H1) Max: 3.06159260

2016.06.22 03:20:26.626 OAC variant 1 (GBPUSD,H1) ---------------------------------

2016.06.22 03:20:26.626 OAC variant 1 (GBPUSD,H1) Tempo: 153 µs; 0.00015300 c

2016.06.22 03:20:26.626 OAC variant 1 (GBPUSD,H1) FF runs: 1000

2016.06.22 03:20:26.626 Max: 3.09159260

2016.06.22 03:20:19.071 OAC variant 1 (GBPUSD,H1) ---------------------------------

2016.06.22 03:20:19.071 OAC variant 1 (GBPUSD,H1) Tempo: 154 µs; 0.00015400 c

2016.06.22 03:20:19.071 OAC variant 1 (GBPUSD,H1) FF runs: 1000

2016.06.22 03:20:19.071 Max: 3.14159260

2016.06.22 03:20:13.407 OAC variant 1 (GBPUSD,H1) ---------------------------------

2016.06.22 03:20:13.407 OAC variant 1 (GBPUSD,H1) Tempo: 152 µs; 0.00015200 c

2016.06.22 03:20:13.407 OAC variant 1 (GBPUSD,H1) FF runs: 1000

2016.06.22 03:20:13.407 Max: 2.64159260

Non male per un algoritmo sulla GCF! Non è vero?

Algorithm Optimisation Championship. Valanga MetaTrader 5 su Intel

Andrey Dik 2016.06.22 00:32 #508

Non so cos'altro spiegare qui. Tutto sembra chiaro, le funzioni sono brevi, non c'è OOP come promesso. I commenti sono presenti.

E, inoltre, un esempio sulla seconda variante della chiamata di FF, se Morpheus non è overpowered - lo sarà.

FOREX - Tendenze, previsioni DICIAMO CHE ... Tutte le domande dei

Dmitry Fedoseev 2016.06.22 01:47 #509

Andrey Dik:

Non so cos'altro spiegare qui. Tutto sembra chiaro, le funzioni sono brevi, non c'è OOP come promesso. I commenti sono presenti.

E poi un esempio sulla seconda versione di FF call, se Morpheus non è overpowered - lo sarà.

Posso scrivere anche così - cosa c'è di poco chiaro nella mia domanda?

Dmitry Fedoseev 2016.06.22 01:49 #510

Perché una domanda deve essere fatta 10 volte?

Campionato di ottimizzazione degli algoritmi. - pagina 51