Erros, bugs, perguntas - página 443

Novo comentário
 
voix_kas:

Resultado:

Ou estou a fazer algo errado (por favor, corrigir), ou o MetaDriver cometeu um erro em teoria (ao conceber o algoritmo).

:)

Bem, considerando o facto de o algoritmo "concepção" ter demorado cerca de 3 minutos (e 7 minutos de implementação), fiz bastante bem :) O objectivo era mostrar uma ideia de trabalho e clarificar a declaração do problema.

E tudo isto se revelou útil - os criadores tiveram uma oportunidade real de melhorar a função MathFloor() - obviamente que não é inteiramente implementado de forma limpa.

No final, tiveram de mexer com ela. Foi divertido. Só consegui obter uma função estável (quero dizer CountSignedDigits(duplo x)) após quase uma hora de experiências.

E mesmo agora não tenho a certeza se vai funcionar correctamente com todos os valores de entrada. Não desenvolvi um teste de stress automatizado, fiz um teste manual. Por favor, teste-o.

Espero uma operação estável até 10 casas decimais após a vírgula flutuante.

int CountSignedDigits(double x)
{
  for(int i=0; i<1000; i++,x*=10)
  {
    if(x-MathFloor(x+0.000000000005)<double(0.000000000005)) return i;
  }
  return -1;
}
O teste de stress anexado. // Não removi algumas realizações intermédias do código. Deixei-o em comentários para que tentasse/pensasse. Incluindo os criadores.
Arquivos anexados:
CSDigitTest.mq5  2 kb
 
komposter:
1. não é preciso definir cavar por muito, basta normalizá-lo para o passo certo:

2. mesmo que haja algum lixo na variável do lote ao enviar um pedido comercial (na casa decimal), este deve ser descartado pelo próprio terminal.

Pelo menos, não tive quaisquer problemas durante vários anos de utilização de uma tal construção.

4. se quiser segurar, pode normalizá-lo até 8 casas decimais (com uma margem) - se houver lixo após a normalização "correcta", será muito mais longe.

A primeira ideia é correcta, as outras são suspeitas. :)

A implementação é exequível para a prática, mas para as condições artificiais definidas por "iniciador de problemas" (c) é imprecisa. Para passos discretos gera não em relação ao lote_min, mas em relação ao zero. :)

No entanto, pode ser facilmente reparado se o notar.

double komposterNormalizeLot(double lot, double lot_step, double lot_min, double lot_max)
{
   lot = NormalizeDouble( lot / lot_step, 0 ) * lot_step;
   if ( lot < lot_min ) lot = lot_min;
   if ( lot > lot_max ) lot = lot_max;
   return lot;
}
double metadriverNormalizeLot(double lot, double lot_step, double lot_min, double lot_max)
{
   lot = NormalizeDouble((lot-lot_min) / lot_step, 0) * lot_step + lot_min;
   if ( lot > lot_max ) lot = lot_max;
   return lot;
}

// Por favor, não leve todas estas pérolas demasiado a sério. Os esclarecimentos são puramente teóricos, para a formação do cérebro, porque na prática nunca vi o lote_step igual a, digamos, 0.0231....

;)

  
metadriverNormalizeLot

a opção está correcta. Correctamente contabilizado por lot_min como no meu NL().

 

A minha variante também está disponível. Note-se que para alguns instrumentos a etapa de mudança de preço é maior do que o ponto.

//---------------------------------------------------------------------
//  Нормализация цены:
//---------------------------------------------------------------------
double
NormalizePrice( string _symbol, double _org_price )
{
  double  norm_price = _org_price;

  double  min_price_step = NormalizeDouble( current_tick_size / current_point, 0 );

  norm_price = NormalizeDouble( NormalizeDouble(( NormalizeDouble( _org_price / current_point, 0 )) / min_price_step, 0 ) * min_price_step * current_point, current_digits );

  return( norm_price );
}

//---------------------------------------------------------------------
//  Вычисление лота:
//---------------------------------------------------------------------
double
NormalizeLot( double _required_lot )
{
  double        lot, k;

  if( current_min_lot_step > 0 )
  {
    k = 1.0 / current_min_lot_step;
  }
  else
  {
    k = 1.0 / current_min_permitted_lot;
  }

  lot = MathFloor( _required_lot * k ) / k;

  if( lot < current_min_permitted_lot )
  {
   lot = current_min_permitted_lot;
  }

  if( lot > current_max_permitted_lot )
  {
    lot = current_max_permitted_lot;
  }

  lot = NormalizeDouble( lot, 2 );
  return( lot );
}
 

Se assumirmos como axioma que os passos "vão" não de zero, mas do lote mínimo, o algoritmo correcto é o seguinte:

double voixkasNormalizeLot(double lot, double lot_step, double lot_min, double lot_max)
{
  if ( lot < lot_min ) lot = lot_min;
  else lot = NormalizeDouble((lot-lot_min) / lot_step, 0) * lot_step + lot_min;

  if ( lot > lot_max ) lot = lot_max;
  return NormalizeDouble(Lot, 8);
}

Na versão Composter, os passos "vão" a partir do zero. O que não me parece correcto.
Na variante MetaDriver, o código salta um valor negativo. =Р

 
voix_kas:
...

Na variante MetaDriver, o código salta um valor negativo. =Р

:)) ..... Ah, sim! Não vai trabalhar de todo! ;-R ;-b ;-R

double voixkasNormalizeLot(double lot, double lot_step, double lot_min, double lot_max)
{
  if ( lot < lot_min ) lot = lot_min;
  else lot = NormalizeDouble((lot-lot_min) / lot_step, 0) * lot_step + lot_min;

  if ( lot > lot_max ) lot = lot_max;
  return NormalizeDouble(L ot, 8);
}

Bem, se alguma coisa, a variante mais curta e ao mesmo tempo "mais ou menos precisa" é esta:

double mdNormalizeLot(double lot, double lot_step, double lot_min, double lot_max)
{
  lot = MathMin(lot, lot_min);
  lot = NormalizeDouble((lot-lot_min) / lot_step, 0) * lot_step + lot_min;
  return NormalizeDouble(MathMin(lot, lot_max), MathMax(CountSignedDigits(lot_min),CountSignedDigits(lot_step));
}

E isso sem verificar a nulidade e negatividade de lote_step, lote_min e lote_max!! ......

:))))

 

Uh.... atingir um nervo. :)) A última linha foi corrigida à mão num post do fórum, por isso, perdoem-me. =)
A propósito, o seu código também não foi compilado (esqueci-me de colocar um parêntese de fecho na última linha). :-Р
Além disso, é 2-3 vezes mais lento (agora verifiquei-o no guião), mas a qualidade do controlo é a mesma. :-Р

De qualquer modo, enquanto não houver um código adequado para determinar o inteiro significativo, vou seguir o conselho do Composter: normalizar o volume para 8 casas decimais.
Esperemos que não haja armadilhas.

Obrigado a todos pela vossa ajuda.

 

vocês são engraçados, estou a ver.

no seu primeiro post deu NL() o que só chegou a duas páginas mais tarde ;)

 

Há outra questão para os gurus. Quando testo a moeda múltipla, recebo erros (imagem do ecrã anexada).
Estou a tentar fazer uma operação comercial, mas recebo uma resposta: Sem preço. De acordo com o testador pode ser visto que as citações para este par começam a chegar em 2011.01.0301:00:00, enquanto EURUSD também é citado a partir de 2011.01.0300:00:00 Existe alguma maneira de descobrir a hora do início das citações para contornar este erro?

Captura de ecrã com erro

 
voix_kas:

Há outra questão para os gurus. Quando testo a moeda múltipla, recebo erros (imagem do ecrã anexada).
Estou a tentar fazer uma operação comercial, mas recebo uma resposta: Sem preço. De acordo com o testador pode ser visto que as citações para este par começam a chegar em 2011.01.0301:00:00, enquanto EURUSD também é citado a partir de 2011.01.0300:00:00 Existealguma forma de descobrir a hora do início das citações para evitar este erro?

As sessões de negociação e de cotação não ajudarão a resolver o problema?
1...436437438439440441442443444445446447448449450...3184
Novo comentário