Campeonato de Otimização de Algoritmos. - página 51

 

Não está claro sobre a segunda opção, precisamos de um exemplo do roteiro do participante, um balkan de algum tipo.

FFimportado, mas não será visível na função do participante e a variável MaxFFruns_P não será visível.

 
Dmitry Fedoseev:

Não está claro sobre a segunda opção, precisamos de um exemplo do roteiro do participante, um balkan de algum tipo.

FF importado, mas não será visível na função do participante e a variável MaxFFruns_P não será visível.

Você quer dizer o exemplo do algoritmo do participante?

Bem, o algoritmo já foi dito para não chamar FF mais do que tantas vezes

InitAO (paramCount, MaxFFruns_P);

De acordo com a segunda opção, o algoritmo de membro também importa FFs. Eu verifiquei, uma e a mesma cópia da biblioteca FF é usada no script e no algoritmo. Ou seja, o algoritmo acessa o FF por suas funções importadas, e o script por suas próprias funções, mas a contagem de chamadas do script está correta.

Andrey Dik:

Agora vou acrescentar exemplos dos próprios algoritmos para ambos os tipos de chamadas para o FF, no próprio MSF, nativo e amado. Por favor, ame e ame, especialmente para os iniciantes. Eles são fáceis de entender, um exemplo de como se pode construir um algoritmo elementar simples e, ao mesmo tempo, de otimização de trabalho.

 

Andrey Dik:

Você quer dizer o exemplo do algoritmo do participante?

Aqui, o algoritmo foi dito para não chamar o FF mais do que tantas vezes.

InitAO (paramCount, MaxFFruns_P);

De acordo com a segunda opção, o algoritmo de membro também importa FFs. Eu verifiquei, a mesma cópia da biblioteca FF é usada no script e no algoritmo.

É isso que você precisa para mostrar o modelo para o participante. O roteiro do verificador é mostrado.

O número de parâmetros é claro. Mas precisamos escrever instruções, pelo menos um par de palavras.

 
Não haverá necessidade de que variáveis globais parem. Basta adicionar um alerta ao FF quando o limite de execução for excedido, para que ele possa ser interrompido manualmente. O algoritmo deve acompanhar quantas vezes ele chama o FF.
 
Dmitry Fedoseev:

É aqui que deve ser mostrado o modelo para o participante. O roteiro do verificador é mostrado.

O número de parâmetros é claro. Mas precisamos escrever instruções, pelo menos um par de palavras.

Você deve. Haverá uma instrução, é claro.

Mas tudo é suficientemente simples, não precisaremos do OOP para participar e acreditamos que os participantes serão capazes de entender 20 linhas de código, eles não são crianças verdes desde que chegaram ao campeonato).

 
Andrey Dik:

Temos que fazê-lo. Haverá instruções, é claro.

Mas tudo é simples como é, você não precisará do OOP para participar, e os participantes provavelmente serão capazes de entender 20 linhas de código, já que não são verdes, já que vieram para o campeonato).

Pode ser simples, mas somente se você tiver que adivinhar, de alguma forma não é apresentável.
 

Um exemplo de algoritmo de um participante para a primeira variante da chamada 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 da execução de algoritmos:

2016.06.22 03:25:25.777 Variante 1 da OAC (GBPUSD,H1)

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

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

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

2016.06.22 03:25:21.874 Variante 1 da OAC (GBPUSD,H1)

2016.06.22 03:25:21.874 Variante OAC 1 (GBPUSD,H1) Hora: 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 Variante 1 da OAC (GBPUSD,H1) Max: 3.10159260

2016.06.22 03:20:32.249 Variante 1 da OAC (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 Variante 1 da OAC (GBPUSD,H1) Max: 3.06159260

2016.06.22 03:20:26.626 Variante 1 da OAC (GBPUSD,H1)

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

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

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

2016.06.22 03:20:19.071 Variante 1 da OAC (GBPUSD,H1)

2016.06.22 03:20:19.071 Variante OAC 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 Variante 1 da OAC (GBPUSD,H1) Max: 3.14159260

2016.06.22 03:20:13.407 Variante 1 da OAC (GBPUSD,H1)

2016.06.22 03:20:13.407 OAC variant 1 (GBPUSD,H1) Hora: 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 Variante 1 da OAC (GBPUSD,H1) Max: 2.64159260

Nada mal para um algoritmo sobre a GCF! Não é?

 

Não sei o que mais explicar aqui. Tudo parece claro, as funções são curtas, não há OOP como prometido. Os comentários estão presentes.

E ainda, um exemplo na segunda variante da chamada FF, se Morfeu não for dominado - ele será.

 
Andrey Dik:

Não sei o que mais explicar aqui. Tudo parece claro, as funções são curtas, não há OOP como prometido. Os comentários estão presentes.

E então um exemplo na segunda versão da chamada FF, se Morpheus não for dominado - ele será.

Também posso escrever dessa forma - o que não está claro sobre minha pergunta?

 
Por que uma pergunta tem que ser feita 10 vezes?