Campeonato de optimización de algoritmos.

Dmitry Fedoseev 2016.06.21 21:05 #501

No está claro lo de la segunda opción, necesitamos un ejemplo de guión de participante, un balcánico de algún tipo.

Importado FF, pero no será visible en la función del participante y la variable MaxFFruns_P no será visible.

Andrey Dik 2016.06.21 21:11 #502

Dmitry Fedoseev:

No está claro lo de la segunda opción, necesitamos un ejemplo de guión de participante, un balcánico de algún tipo.

Importado FF, pero no será visible en la función del participante y la variable MaxFFruns_P no será visible.

¿Te refieres al ejemplo del algoritmo de los participantes?

Bueno, al algoritmo se le ha dicho que no llame a FF más de tantas veces

InitAO (paramCount, MaxFFruns_P);

Según la segunda opción, el algoritmo de los miembros también importa FFs. Lo he comprobado, se utiliza una misma copia de la biblioteca FF en el script y en el algoritmo. Es decir, el algoritmo accede al FF por sus funciones importadas, y el script por las suyas propias, pero la cuenta de llamadas del script es correcta.

Andrey Dik:

Ahora añadiré ejemplos de los propios algoritmos para ambos tipos de llamadas a la FF, a la propia, nativa y querida MSF. Por favor, amor y amor, especialmente para los principiantes. Son fáciles de entender, un ejemplo de cómo se puede construir un algoritmo de optimización elemental sencillo y a la vez funcional.

Pregunta sobre la optimización Cualquier pregunta de los Preguntas de los principiantes

Dmitry Fedoseev 2016.06.21 21:15 #503

Andrey Dik:

¿Te refieres al ejemplo del algoritmo del participante?

En este caso, el algoritmo se dijo que no debía llamar a la FF más de tantas veces.

InitAO (paramCount, MaxFFruns_P);

Según la segunda opción, el algoritmo de los miembros también importa FFs. Lo he comprobado, se utiliza la misma copia de la biblioteca FF en el script y en el algoritmo.

Eso es lo que necesita para mostrar la plantilla del participante. Se muestra el guión del verificador.

El número de parámetros está claro. Pero tenemos que escribir las instrucciones, al menos un par de palabras.

Predicción del futuro con ¡aprender a ganar dinero Deseos para MT5

Andrey Dik 2016.06.21 21:18 #504

No será necesario que las variables globales se detengan. Sólo hay que añadir una alerta al FF cuando se sobrepasa el límite de ejecución, para que se pueda detener manualmente. El algoritmo debe llevar la cuenta de las veces que llama al FF.

FOREX - Tendencias, previsiones ¿Cómo se mide el Cualquier pregunta de un

Andrey Dik 2016.06.21 21:23 #505

Dmitry Fedoseev:

Aquí es donde debe aparecer la plantilla del participante. Se muestra el guión del verificador.

El número de parámetros está claro. Pero tenemos que escribir las instrucciones, al menos un par de palabras.

Deberías hacerlo. Habrá una instrucción, por supuesto.

Pero todo es bastante sencillo, no necesitaremos OOP para participar, y creemos que los participantes serán capaces de entender 20 líneas de código, no son niños verdes desde que llegaron al campeonato).

Econometría: por qué es ¿Qué pasó con el El lado legal del

Dmitry Fedoseev 2016.06.21 21:25 #506

Andrey Dik:

Tenemos que hacerlo. Habrá instrucciones, por supuesto.

Pero todo es sencillo, no se necesita OOP para participar, y los participantes probablemente podrán entender 20 líneas de código, ya que no son verdes, ya que vinieron al campeonato).

Puede ser simple, pero sólo si tiene que adivinar, de alguna manera no es presentable.

Andrey Dik 2016.06.21 22:28 #507

Un ejemplo de algoritmo de un participante para la primera variante de la llamada 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)));
}
//————————————————————————————————————————————————————————————————————

Resultados de la ejecución del algoritmo:

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

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

2016.06.22 03:25:25.777 OAC variante 1 (GBPUSD,H1) FF corre: 1000

2016.06.22 03:25:25.777 OAC variante 1 (GBPUSD,H1) Max: 3.14159260

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

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

2016.06.22 03:25:21.874 OAC variante 1 (GBPUSD,H1) FF corre: 1000

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

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

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

2016.06.22 03:20:32.249 OAC variante 1 (GBPUSD,H1) FF corre: 1000

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

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

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

2016.06.22 03:20:26.626 OAC variante 1 (GBPUSD,H1) FF corre: 1000

2016.06.22 03:20:26.626 OAC variante 1 (GBPUSD,H1) Max: 3.09159260

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

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

2016.06.22 03:20:19.071 OAC variante 1 (GBPUSD,H1) FF corre: 1000

2016.06.22 03:20:19.071 OAC variante 1 (GBPUSD,H1) Max: 3.14159260

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

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

2016.06.22 03:20:13.407 OAC variante 1 (GBPUSD,H1) FF corre: 1000

2016.06.22 03:20:13.407 OAC variante 1 (GBPUSD,H1) Max: 2.64159260

¡No está mal para un algoritmo en el GCF! ¿No es así?

Algorithm Optimisation Championship. Filtros FIR Análisis de los resultados

Andrey Dik 2016.06.21 22:32 #508

No sé qué más explicar aquí. Todo parece claro, las funciones son cortas, no hay OOP como se prometió. Los comentarios están presentes.

Y, además, un ejemplo sobre la segunda variante de la llamada FF, si Morfeo no está sobrepasado - lo estará.

Cualquier pregunta de los FOREX - Tendencias, previsiones El esplendor y la

Dmitry Fedoseev 2016.06.21 23:47 #509

Andrey Dik:

No sé qué más explicar aquí. Todo parece claro, las funciones son cortas, no hay OOP como se prometió. Los comentarios están presentes.

Y luego un ejemplo en la segunda versión de la llamada FF, si Morfeo no está sobrepasado - lo estará.

Yo también puedo escribirlo así, ¿qué es lo que no está claro en mi pregunta?

Dmitry Fedoseev 2016.06.21 23:49 #510

¿Por qué hay que hacer una pregunta 10 veces?

Campeonato de optimización de algoritmos. - página 51