Campeonato de Otimização de Algoritmos.

Dmitry Fedoseev 2016.06.21 21:05 #501

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.

Andrey Dik 2016.06.21 21:11 #502

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.

Qualquer pergunta de novato, Ajuda na codificação Existe prova de lucro

Dmitry Fedoseev 2016.06.21 21:15 #503

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.

Andrey Dik 2016.06.21 21:18 #504

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.

Qualquer pergunta de novato, Erros, bugs, perguntas Teoria da aceleração da

Andrey Dik 2016.06.21 21:23 #505

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).

O mercado é um Ajuda na codificação Uma pergunta para os

Dmitry Fedoseev 2016.06.21 21:25 #506

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.

Andrey Dik 2016.06.21 22:28 #507

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 é?

Algorithm Optimisation Championship. Avalanche MetaTrader 5 em Intel

Andrey Dik 2016.06.21 22:32 #508

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á.

O Graal existe? Quaisquer perguntas de recém-chegados O que acontecerá com

Dmitry Fedoseev 2016.06.21 23:47 #509

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?

Dmitry Fedoseev 2016.06.21 23:49 #510

Por que uma pergunta tem que ser feita 10 vezes?

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