Algoritmos, métodos de solução, comparação de seu desempenho

Sergey Dzyublik 2017.12.11 10:21 #191

Реter Konow:

Não sei por que você acrescentaria entidades a uma solução ideal. Não vejo qual é o objetivo.

Você não usa dois chapéus ao mesmo tempo. E por que isso acontece?

Primeiro, explique isto. ))

"Você está torturando as pessoas e fazendo-as sofrer, baixando-as moralmente e psicologicamente...."

Mundo Amaldiçoado (Recolhido)Autores: Dmitri Ganin

Реter Konow 2017.12.11 10:37 #192

Sergey Dzyublik:

"Você tortura as pessoas e as faz sofrer, você as abaixa moralmente e psicologicamente...."

The Cursed World (coleção)Autores: Dmitry Ganin

Peço sinceramente desculpas a todos aqueles que inadvertidamente fiz sofrer moral e psicologicamente.

Não tenho outra finalidade que não seja encontrar a solução perfeita para um problema em particular, não tenho buscado.

Pelo contrário, eu mesmo sofri ataques incompreensíveis e agressões desmotivadas.

Aparentemente, este é o preço pago por qualquer pessoa que não queira "acompanhar" a sociedade.

Bem, eu fiz minha escolha e não estou culpando ninguém.

Da teoria à prática Alguém tentou negociar índices? FOREX - Tendências, previsões

Alexandr Andreev 2017.12.11 10:40 #193

Реter Konow:

Não sei por que você acrescentaria entidades a uma solução ideal.

Talvez seja muito cedo para falar de seu código como uma solução ideal.

E aqui está a coleção real de chapéus

Реter Konow 2017.12.11 10:47 #194

Alexandr Andreev:

Talvez seja muito cedo para falar de seu código como uma solução perfeita

Eu estava falando em termos gerais, por assim dizer...

"Por que, para uma solução ideal (qualquer solução), acrescentar entidades".

Devo dizer que muitas pessoas me deram idéias muito valiosas e apontaram os erros certos:

1. um erro de contagem de caracteres.

2. erro causado por colisões de substratos dentro de um cordão comum.

3. Excesso de memória alocada para cada fio em particular. 4.

(4) Falsa crença de que mudar o tamanho de uma matriz leva ao apagamento de dados.

Muito obrigado a todos vocês por apontarem estes erros!

Versão beta do livro Erros, bugs, perguntas Usando inteligência artificial na

Реter Konow 2017.12.11 10:56 #195

Реter Konow:
...

Muito obrigado a todos vocês por apontarem esses erros!

Para ser objetivo, a última, a solução ideal, pertence a todos, pois, eu cheguei a ela graças a apontar erros, comunicando e interagindo com as pessoas.

Alexandr Andreev 2017.12.11 11:00 #196

Реter Konow:

Para ser objetivo, a última, a solução ideal, pertence a todos, porque, cheguei a ela apontando erros, comunicando e interagindo com as pessoas.

Mais uma vez, a última opção é apenas uma opção, o que veio antes não era de todo uma opção! E o fato de ser perfeito é um ponto discutível

Реter Konow 2017.12.11 11:02 #197

Alexandr Andreev:

Mais uma vez, a última opção é apenas uma opção, o que veio antes não era de todo uma opção! E o fato de ser perfeito é um ponto discutível.

(risadinhas) Ótimo. Que seja perfeito apenas para mim. Todos podem julgá-lo em sua própria escala.

Alexandr Andreev 2017.12.11 11:05 #198

Sugiro que passemos às impressões e cometas DEBAG - quem tem alguma idéia?

Igor Makanu 2019.10.12 08:48 #199

testou o tempo de funcionamento se a função é:

1. envoltos em uma classe

2. envolto em uma classe, uma instância da classe é criada utilizando o novo operador

3. Basta chamar a função sem usar um invólucro

//+------------------------------------------------------------------+

#define    SpeedTest(count_x10,msg,EX)        {uint mss=GetTickCount(); ulong count=(ulong)pow(10,count_x10);for(ulong i=0;i<count&&!_StopFlag;i++){EX;} \
                                              printf("%s: loops=%i ms=%u",msg,count,GetTickCount()-mss);}
//+------------------------------------------------------------------+
class COpen
{
private:
   string            m_symbol;
public:
                     COpen(const string symbol): m_symbol(symbol) {}
   double            getOpen(const int bar) const                 { return(iOpen(m_symbol, 0, bar)); }

};
//+------------------------------------------------------------------+
void OnStart()
{  #define  loop_x10 9
//1.
   COpen sym1(_Symbol);
   srand(GetTickCount());
   SpeedTest(loop_x10, "1. COpen", sym1.getOpen(rand()));
//2.
   srand(GetTickCount());
   SpeedTest(loop_x10, "2. new COpen",
             COpen *sym2 = new COpen(_Symbol);
             sym2.getOpen(rand());
             delete sym2;
            );
//3.            
   srand(GetTickCount());
   SpeedTest(loop_x10, "3. iOpen",iOpen(NULL,0,rand()););            
}
//_______________________________________________________________________

2019.10.12:39:29.802 SpeedTst_class (EURUSD,M1) 1. COpen: loops=1000000000 ms=41016

2019.10.12:41:05.352 SpeedTst_class (EURUSD,M1) 2. novo COpen: loops=1000000000 ms=95562

2019.10.12:41:45.939 SpeedTst_class (EURUSD,M1) 3. iOpen: loops=1000000000 ms=40578

Os testes 1 e 3 estão lado a lado em termos de desempenho, ou seja, o envolvimento da chamada de função na classe não é crítico, o teste 2 acrescentou tempo por causa das chamadas do construtor e do destruidor

Algorithms, solution methods, comparison Perguntas de Iniciantes MQL5 Perguntas sobre OOP em

Igor Makanu 2019.12.11 16:19 #200

SymbolInfoDouble() teste de velocidade de execução

#property version   "1.00"
// количество итераций теста
#define  LOOPx10 8

#define    SpeedTest(count_x10,msg,EX)        {uint mss=GetTickCount(); ulong count=(ulong)pow(10,count_x10);for(ulong i=0;i<count&&!_StopFlag;i++){EX;} \
                                              printf("%s: loops=%i ms=%u",msg,count,GetTickCount()-mss);}
//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
{
   double lot;

   srand(GetTickCount());
   SpeedTest(LOOPx10, "calcNormVol_my()", lot = rand() / 1000.0; calcNormVol_my(lot))

   srand(GetTickCount());
   SpeedTest(LOOPx10, "calcNormVol_alexeyvik()", lot = rand() / 1000.0; calcNormVol_alexeyvik(lot))
   
   srand(GetTickCount());
   SpeedTest(LOOPx10, "calcNormVol_fxsaber()", lot = rand() / 1000.0; calcNormVol_fxsaber(lot))
   
   srand(GetTickCount());
   SpeedTest(LOOPx10, "calcNormVol_my_2()", lot = rand() / 1000.0; calcNormVol_my_2(lot))

}
//+------------------------------------------------------------------+
double calcNormVol_my(const double value)
{
   const static string sym = _Symbol;
   return(NormalizeDouble(fmax(fmin(SymbolInfoDouble(sym, SYMBOL_VOLUME_STEP) * round(value / SymbolInfoDouble(sym, SYMBOL_VOLUME_STEP)), SymbolInfoDouble(sym, SYMBOL_VOLUME_MAX)),
                               SymbolInfoDouble(sym, SYMBOL_VOLUME_MIN)),  2));
}
//+------------------------------------------------------------------+
double calcNormVol_alexeyvik(const double value)
{
//   const string sym = _Symbol;
   return(
            NormalizeDouble(fmax(fmin(SymbolInfoDouble(Symbol(), SYMBOL_VOLUME_STEP) * round(value / SymbolInfoDouble(Symbol(), SYMBOL_VOLUME_STEP)),
                                      SymbolInfoDouble(Symbol(), SYMBOL_VOLUME_MAX)),  SymbolInfoDouble(Symbol(), SYMBOL_VOLUME_MIN)), 2)
         );
}
//+------------------------------------------------------------------+
const double VolumeStep = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_STEP);
const double VolumeMax = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MAX);
const double VolumeMin = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
const int O_DigitsInVolumeStep = 2;
double calcNormVol_fxsaber( const double value )
{
   return((value > VolumeMax) ? VolumeMax
          : ((value < VolumeMin) ? VolumeMin
             : NormalizeDouble(VolumeStep * (int)(value / VolumeStep + 0.5), O_DigitsInVolumeStep)));
}
//+------------------------------------------------------------------+
double calcNormVol_my_2( const double value )
{
   const static double volumeStep = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_STEP);
   const static double volumeMax = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MAX);
   const static double volumeMin = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
   const static int o_digitsInVolumeStep = 2;
   return((value > volumeMax) ? volumeMax
          : ((value < volumeMin) ? volumeMin
             : NormalizeDouble(volumeStep * (int)(value / volumeStep + 0.5), o_digitsInVolumeStep)));
}
//+------------------------------------------------------------------+

2019.12.11 21:13:08.896 tst_volum (EURUSD,W1) calcNormVol_my(): loops=100000000 ms=173406

2019.12.11 21:15:45.425 tst_volum (EURUSD,W1) calcNormVol_alexeyvik(): loops=100000000 ms=156531

2019.12.11 21:15:45.533 tst_volum (EURUSD,W1) calcNormVol_fxsaber(): loops=100000000 ms=110

2019.12.11 21:15:45.916 tst_volum (EURUSD,W1) calcNormVol_my_2(): loops=100000000 ms=390

Algorithms, solution methods, comparison Declarando variáveis atrás do Declaring variables behind the

Algoritmos, métodos de solução, comparação de seu desempenho - página 20