Comunidad de expertos - página 3

 
komposter<br / translate="no">
He echado un vistazo rápido (no he investigado todavía), he encontrado la referencia del punto que estás calculando.
Prueba a "tirarlo" y a poner el estúpido Punto. Tal vez ese sea el problema (el punto a través de MarketInfo no siempre sale como uno quiere).

Siempre se supone que...
aunque también puedes intentar normalizarlo =)

y no siempre es aceptable - el experto puede operar en varios pares, y el punto puede ser diferente...
 
El problema es tan antiguo como el primer chip de ordenador -
es triste, claro... pero tiene que haber una forma de evitarlo, ¿no? Espero que Renat diga algo...
 
if ( orderstoploss == 0.0 || (  orderstoploss < ( bid - TrailingStop * point ) ) )


Supongamos que ordertoploss = 1.29211 (5 dígitos después del punto decimal)
bid=1.29716 (también 5 dígitos )
TrailingStop = 50
point =0.001
entonces (bid - TrailingStop * point)=1.29216>1.29211
Verdadero, esto requiere que los dígitos se conviertan de repente en 5
Y también

if ( orderstoploss == 0.0 || (  orderstoploss < ( bid - TrailingStop * point ) ) )


puede ser sustituido sin problemas por

if ( orderstoploss < ( bid - TrailingStop * point )) )


Creo que no es necesario comprobar la ausencia de nivel de stop loss cuando se hace trailing.
En realidad lo es, me corrijo. Si establecemos un stop loss sólo cuando hay beneficios, y si no estamos dispuestos a esperar un ajuste de márgenes.
No he encontrado nada más. ¿En qué par funcionó mal su trailing stop y hubo algún movimiento fuerte?

 
Hola.
Estoy convirtiendo todo a valores enteros para fines de comparación. Almaceno y utilizo los valores dados siempre que puedo (en el array).
utilizar los valores dados (en matrices, variables, etc.)
Es decir, las variables de tipo int pueden tomar valores de -2147483648 a 2147483647.
Esta dimensionalidad es muy adecuada para los cruces.
De la misma manera, 1,2999 y 1,3000 se pueden convertir en 12999 y 13000, y entonces se pueden comparar con seguridad,
sin preocuparse por las meteduras de pata periódicas.

He esbozado un ejemplo aquí :)
int Normalize(double double_value, int digits) - приводит double в int  (1.2999 в 12999)
double Restore(int int_value, int digits) - приводит полученный ранее int в double (12999 в 1.2999)


aquí

//+------------------------------------------------------------------+
//|                                                   ShiftPoint.mq4 |
//|                                                            Begun |
//+------------------------------------------------------------------+
#property indicator_chart_window
#property indicator_buffers 1
#property indicator_color1 Blue
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
{
   return(0);
}
//+------------------------------------------------------------------+
int Normalize(double double_value, int digits)
{
	return (NormalizeDouble(double_value,digits)*MathPow(10,digits));
}
double Restore(int int_value, int digits)
{
	return (NormalizeDouble((int_value/MathPow(10,digits)),digits));
}
//+------------------------------------------------------------------+
int start()
{
	double	Test_Value =  1.29999999;
	int	Test_int;
	double	Test_double;

	Test_int         = Normalize(Test_Value,Digits);
	Test_double   = Restore(Test_int,Digits);
	Print("-----------------------------");
	Print("Restored value    = ",DoubleToStr(Test_double,Digits));
	Print("Shift Point Value = ",Test_int);
	Print("Real Double Value = ",DoubleToStr(Test_Value,8));
}
//+------------------------------------------------------------------+



de salida:
shiftpoint EURUSD,H1: Valor doble real = 1.29999999
shiftpoint EURUSD,H1: Valor del punto de desplazamiento = 13000
shiftpoint EURUSD,H1: Valor restaurado = 1.3000

 
En general, se sustituye por
if ( orderstoploss < ( bid - TrailingStop * point )) )


en

if ( TrailingStop < ( bid -orderstoploss)/ point  )


Alternativamente.

 
Gracias a todos por su participación.
Rosh 17.04.05 22:29 <br / translate="no"> No creo que el trailing sea necesario.
No estoy de acuerdo, el arrastre debería ser inequívoco: si está activado, significa que la SL está expuesta.

¿En qué par no funcionó correctamente su trailing y no hubo un movimiento fuerte?
ahora el experto funciona en eu - errores ocasionales... a lo largo del día... No creo que sea el caso...

En general, sustitúyalo.
ahora lo voy a probar, tal vez me sirva de algo ;) mañana te cuento...

Iniciado el 17.04.05 22:46
Hola.
Llevo todo a números enteros para comparar
Hola =) es ciertamente una opción... pero no pensé que tendría que pasar por todo este problema... Me gustaría haber escuchado a los desarrolladores, ellos saben más que yo...
 
Disculpas, no estaba involucrado en la discusión.

2dev:
El problema es tan antiguo como el primer chip de ordenador:

Tienes razón: es un problema fundamental, es peligroso comparar números en coma flotante.
En los lugares importantes, lleve siempre los números a una determinada precisión mediante Normalize().

¿qué implementación de la aritmética utiliza?

Estandarizar el tipo doble (8 bytes).

Por cierto, forzamos la normalización de todos los precios pasados en las consultas comerciales para evitar errores.
Puede enviar una solicitud de stop loss como 1,2932461, pero se establecerá como 1,2932.
Por favor, compruebe si este es el error al intentar reajustar el stop al mismo precio.
 
Por favor, compruebe si este es el error al intentar reajustar el stop al mismo precio.

3 personas estaban mirando =)) Renat vino y acaba de señalar el error con el dedo =)))
Voy a comprobar ahora, por supuesto, pero lo más probable es que este es el caso ... No he normalizado "bid - TrailingStop * point", y esta misma construcción está implicada en la modificación de la orden...
no estamos atentos, señores ;)
 
En los lugares importantes, siempre hay que llevar los números a una cierta precisión mediante Normalize().

¿te refieres a la función Normalize() que sugirió Begun?
 
В важных местах постоянно приводите числа к определенной точности через Normalize().

¿te refieres a la función Normalize() que sugirió Begun?

Perdón, me refería a la norma NormalizeDouble.