Preguntas sobre POO en MQL5 - página 91

Nuevo comentario
 
Dmitry Fedoseev:

¿Por qué no iba a funcionar de repente? Tres enumeraciones, ninguna de ellas superior a 10. Aritmética de segundo grado de secundaria.

3 enumeraciones más 2 int , se necesitan 4 bytes = int

int que necesito en el rango +1000 -... +1000 , pips, eso es sólo 2^10

vale la pena considerar los int, el paso de 1 pips no es importante, 2.5-...9 pips también es posible, es decir, la discreción no es muy crítica

 
Igor Makanu:

3 enumeraciones más 2 int, se necesitan en 4 bytes

int que necesito en el rango +1000 -... +1000 , pips, eso es sólo 2^10

Vale la pena considerar los int, los incrementos de 1 pip no son importantes, puedes tener 2.5-...9 pps, es decir, la discreción no es tan crítica

Hay espacio más que suficiente. INT_MAX=2147483647.

Podríamos ir a dieces en lugar de directamente y sin rodeos, y hacer 8*8*4 con moderación. Sólo tienes que pensar en ello))) Pero no es necesario, todo encaja de todos modos.

Y para comprobar - por qué no iniciar el ciclo hasta INT_MAX - el hardware lo comprobará, no para buscar a través del archivo con los resultados por sí mismo.

 
Dmitry Fedoseev:

Espacio más que suficiente. INT_MAX=2147483647.

También puede no estúpidamente y recta - decenas de ocupar, y económicamente, para hacer en un apuro - 8 * 8 * 4. Sólo tienes que pensar en ello))) Pero no es necesario, todo encaja de todos modos.

Y para comprobar - por qué no hacer el ciclo hasta INT_MAX - será comprobado por el hardware, no necesitaremos buscar en el archivo de resultados por nosotros mismos.

No me importa... Necesito el código para evaluar y la metodología es más importante que la forma de convertir

 
Igor Makanu:

No me importa... Necesito el código para evaluar, y la metodología de prueba es más importante que la forma de convertir

Primado a nivel de bits, ¿no? Es como convertir un número en una cadena con valores de bits. Uno para los números enteros y otro para los puntos y la verificación. Eso es sólo para fines de depuración.

 
Alexandr Andreev:

Desgrabación Bitwise, ¿no? Algo así como encadenar un número con valores de bits. Uno para los números enteros y otro para los puntos y la verificación. Eso es sólo para fines de depuración.

Sí, eso está claro, pero ¿cómo se automatiza la verificación?

el problema, no en mi ejemplo, sino en el hecho de que todavía necesito empaquetar 3 int's de otros datos, no quiero gastar demasiado tiempo en comprobar cada paquete


ZS: la idea es brillante, pero no los valores de bits, sino los hexadecimales - desde printf () puedes obtener, o más bien desde stringformat()

 
Igor Makanu:

Sí, todo está claro, pero ¿cómo automatizar la comprobación?

El problema, no en mi ejemplo, sino en el hecho de que todavía tengo que empaquetar 3 int de otros datos, no quiero gastar mucho tiempo en comprobar cada paquete


HH: buena idea, pero no son valores de bits, sino hexadecimales - podemos obtenerlos de printf() o más bien de stringformat()

)) no puede averiguar lo que se necesita

   v = (V)(data & 0x3);
   d = (D)((data >> 2) & 0x7);
   t = (T)((data >> 5) & 0x7);
   uint tmp = ((data >> 8) & 0xFFF);
   param2 = (tmp & 0x800) == 0x800 ? -(int)(tmp & 0x7FF) : (int)(tmp & 0x7FF);
   tmp = data >> 20;
   param1 = (tmp & 0x800) == 0x800 ? -(int)(tmp & 0x7FF) : (int)(tmp & 0x7FF);

¿Queremos automatizar una compensación o qué?

¿Qué es este cheque?

Y siempre podemos comprobar los valores de origen y los convertidos.

 
Igor Makanu:

No me importa... Se necesita el código para evaluar, y la metodología de verificación es más importante que la forma de convertir

Si la metodología de conversión es clara y comprensible, no hace falta comprobarlo mucho.

  
...
   static int        sign;
   static int        _sign;
   static int        mean;
public:
...
   int               Get() const;
   static void       Print(int val);
private:
   int               GetInt12(int val) const {return ((val&sign)>>20)|(val&mean);}
   static int        GetInt(int val) {return (val&_sign)<<20|(val&mean);}
  };
...
//------------------------------------------------------------------------
int CSetting::Get() const{
   return t<<29|d<<26|v<<24|GetInt12(param1)<<12|GetInt12(param2);
}
//------------------------------------------------------------------------
void CSetting::Print(int val){
   PrintFormat("%s, %s, %s, %i, %i",EnumToString(T(val>>29)),EnumToString(D(val>>26)),EnumToString(V(val>>24)),GetInt(val>>12),GetInt(val));
}
int CSetting::sign=1<<31;
int CSetting::_sign=1<<11;
int CSetting::mean=0xFFFFFFFF>>21;

void OnStart(void)
  {
   CSetting test(Input_p1,Input_p2,Input_T,Input_D,Input_V);
   int res=test.Get();
   Print ("int=",res);
   CSetting::Print(res);
 }
 
Vladimir Simakov:

Bueno, es obvio que habrá más variables para mí es mejor sólo para utilizar la copia de bytes de las estructuras (probablemente el proceso no requiere una fuerte optimización de la velocidad, pero la comodidad será en un premio)

  
void OnStart()
  {

   int a=9;
   int b=8;
   int c=7;
   int d=12345;

   int v=pack(a,b,c,d);
   
   int a2,b2,c2,d2;
   unpack(v,a2,b2,c2,d2);
   
   Alert(a2," ",b2," ",c2," ",d2);

}

void unpack(int val,int & a,int & b,int & c,int & d){
   d=val/1000;
   val%=1000;
   c=val/100;
   val%=100;   
   b=val/10;
   a=val%10;
}

int pack(int a,int b,int c,int d){
   return(a+b*10+c*100+d*1000);
}

Barato y barato

1...84858687888990919293949596
Nuevo comentario