Errores, fallos, preguntas - página 443

Nuevo comentario
 
voix_kas:

Resultado:

O bien estoy haciendo algo mal (por favor, corrige), o MetaDriver cometió un error en la teoría (al diseñar el algoritmo).

:)

Bueno, teniendo en cuenta que el "diseño" del algoritmo me llevó unos 3 minutos (y 7 minutos de implementación), lo hice bastante bien :) El objetivo era mostrar la idea de trabajo y aclarar el planteamiento del problema.

Y todo esto resultó ser útil - los desarrolladores tuvieron una oportunidad real de mejorar la función MathFloor() - obviamente no está implementada de forma totalmente limpia.

Al final tuvieron que retocarlo. Fue divertido. He conseguido una función estable (me refiero a CountSignedDigits(double x)) sólo después de casi una hora de experimentos.

Y aún ahora no estoy seguro de que funcione correctamente con todos los valores de entrada. No he desarrollado una prueba de estrés automatizada, he hecho una manual. Por favor, pruébala.

Espero un funcionamiento estable hasta 10 decimales después de la coma flotante.

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;
}
Prueba de estrés adjunta. // No he eliminado algunas realizaciones intermedias del código. Lo he dejado en los comentarios para que lo pruebes/pienses. Incluyendo a los desarrolladores.
Archivos adjuntos:
CSDigitTest.mq5  2 kb
 
komposter:
1. no es necesario definir la excavación para un lote, sólo hay que normalizarla al paso correcto:

2. incluso si hay alguna basura en la variable de lote al enviar una solicitud de operación (en el lugar decimal), debería ser descartada por el propio terminal.

Al menos, yo no he tenido ningún problema durante varios años de uso de dicha construcción.

4. Si quieres asegurar, puedes normalizarlo a 8 decimales (con un margen) - si hay basura después de la normalización "correcta", estará mucho más lejos.

La primera idea es correcta, las otras son sospechosas. :)

La aplicación es viable para la práctica, pero para las condiciones artificiales definidas por el "problema-inicio" (c) es inexacta. Para los pasos discretos genera no relativo a lot_min, sino relativo a cero. :)

Sin embargo, se puede arreglar fácilmente si lo notas.

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, no te tomes todas estas perlas demasiado en serio. Las aclaraciones son puramente teóricas, para el entrenamiento del cerebro, porque en la práctica nunca he visto lot_step igual a, por ejemplo, 0,0231....

;)

  
metadriverNormalizeLot

es correcta. Se ha contabilizado correctamente por lot_min como en mi NL().

 

Mi variante también está disponible. Tenga en cuenta que para algunos instrumentos el paso de cambio de precio es mayor que el punto.

//---------------------------------------------------------------------
//  Нормализация цены:
//---------------------------------------------------------------------
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 );
}
 

Si tomamos como axioma que los pasos "van" no desde cero, sino desde el lote mínimo, el algoritmo correcto es el siguiente:

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);
}

En la versión Composter, los pasos "van" desde cero. Lo cual no me parece correcto.
En la variante MetaDriver, el código omite un valor negativo. =Р

 
voix_kas:
...

En la variante MetaDriver, el código omite un valor negativo. =Р

:)) ..... ¡Ah, sí! ¡No trabajarás en absoluto! ;-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);
}

En todo caso, la variante más corta y al mismo tiempo "más o menos precisa" es ésta:

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));
}

Y eso sin comprobar la nulidad y negatividad de lot_step, lot_min y lot_max!!......

:))))

 

Uh... que tocó un nervio. :)) La última línea fue corregida a mano en un mensaje del foro, así que perdóname. =)
Por cierto, tu código tampoco compiló (olvidé poner un paréntesis de cierre en la última línea). :-Р
Además es 2-3 veces más lento (ahora lo he comprobado en el script), pero la calidad de la comprobación es la misma. :-Р

De todos modos, mientras no haya un código adecuado para determinar el número entero significativo, seguiré el consejo de Composter: normalizar el volumen a 8 decimales.
Esperemos que no haya trampas.

Gracias a todos por su ayuda.

 

veo que sois graciosos.

en tu primer post diste a NL() lo que sólo llegaste a dos páginas después ;)

 

Hay otra pregunta para los gurús. Cuando pruebo la multidivisa, me salen errores (se adjunta captura de pantalla).
Intento hacer una operación comercial, pero recibo una respuesta: No hay precio. Según el probador se puede ver que las cotizaciones para este par comienzan a llegar en 2011.01.0301:00:00, mientras que el EURUSD también se cotiza desde 2011.01.0300:00:00 ¿Hay alguna forma de averiguar la hora de inicio de las cotizaciones para evitar este error?

Captura de pantalla con error

 
voix_kas:

Hay otra pregunta para los gurús. Cuando pruebo la multidivisa, me salen errores (se adjunta captura de pantalla).
Intento hacer una operación comercial, pero recibo una respuesta: No hay precio. Según el probador se puede ver que las cotizaciones para este par comienzan a llegar en 2011.01.0301:00:00, mientras que el EURUSD también se cotiza desde 2011.01.0300:00:00¿Hay alguna forma de averiguar la hora de inicio de las cotizaciones para evitar este error?

¿Las sesiones de negociación y cotización no ayudarán a resolver el problema?
1...436437438439440441442443444445446447448449450...3187
Nuevo comentario