ForumSezioni

Domande su OOP in MQL5 - pagina 91

Nuovo commento
Dmitry Fedoseev:

Perché non dovrebbe funzionare all'improvviso? Tre enumerazioni, nessuna delle quali superiore a 10. Aritmetica da scuola media di secondo grado.

3 enumerazioni più 2 int, avete bisogno di 4 byte = int

int mi serve nell'intervallo +1000 -... +1000 , pips, che è solo 2^10

Vale la pena considerare gli int int, il passo di 1 pips non è importante, 2,5-...9 pips è anche possibile, cioè la discrezione non è molto critica

Igor Makanu:

3 enumerazioni più 2 int, hanno bisogno di 4 byte

int mi serve nell'intervallo +1000 -... +1000 , pips, che è solo 2^10

Gli int int sono ancora da considerare, gli incrementi di 1 pip non sono importanti, si possono avere 2,5-...9 pps, cioè la discrezione non è così critica

Lo spazio è più che sufficiente. INT_MAX=2147483647.

Potremmo andare a decine invece che in modo diretto e schietto, e fare 8*8*4 con parsimonia. Devi solo pensarci))) Ma non ce n'è bisogno, tutto si adatta comunque.

E per controllare - perché non iniziare il ciclo fino a INT_MAX - l'hardware lo controllerà, non guardare attraverso il file con i risultati da solo.

Dmitry Fedoseev:

Spazio più che sufficiente. INT_MAX=2147483647.

Si può anche non stupidamente e dritto - decine di occupare, ed economicamente, per fare in un pizzico - 8*8*4. Solo tu devi pensare))) Ma non ce n'è bisogno, tutto si adatta comunque.

E per controllare - perché non fare il ciclo fino a INT_MAX - sarà controllato dall'hardware, non avremo bisogno di guardare nel file dei risultati da soli.

Non mi dispiace... Ho bisogno del codice da valutare e la metodologia è più importante di come convertire

Igor Makanu:

Non mi dispiace... Ho bisogno del codice da valutare, e la metodologia di test è più importante di come convertire

Innesco bitwise, no? È come convertire un numero in una stringa con valori bitwise. Uno per i numeri interi e uno per i punti e il controllo. Questo è solo per scopi di debug.

Alexandr Andreev:

Scrittura bitwise, no? Qualcosa come stringere un numero con valori bitwise. Uno per i numeri interi e uno per i punti e il controllo. Questo è solo per scopi di debug.

Sì, questo è chiaro, ma come si automatizza la verifica?

il problema, non nel mio esempio, ma nel fatto che ho ancora bisogno di impacchettare 3 int di altri dati, non voglio spendere troppo tempo per controllare ogni pacchetto


ZS: l'idea è brillante, ma non valori bitwise, ma esadecimali - da printf() si può ottenere, o meglio da stringformat()

Igor Makanu:

Sì, è tutto chiaro, ma come automatizzare il controllo?

Il problema, non nel mio esempio, ma nel fatto che ho ancora bisogno di impacchettare 3 int di altri dati, non voglio spendere molto tempo per controllare ogni pacchetto


HH: buona idea, ma non valori bitwise, ma esadecimali - possiamo ottenerli da printf() o piuttosto da stringformat()

)) non riesce a capire cosa serve

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

Vogliamo automatizzare un offset o cosa?

Cos'è questo controllo?

E possiamo sempre controllare i valori sorgente e convertiti.

Igor Makanu:

Non mi dispiace... Avete bisogno del codice da valutare, e la metodologia di verifica è più importante di come convertire

Se la metodologia di conversione è chiara e comprensibile, non c'è bisogno di molti controlli.

...
   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:

Beh, è ovvio che ci saranno più variabili per me è meglio usare semplicemente la copia in byte delle strutture (probabilmente il processo non richiede una forte ottimizzazione della velocità ma la convenienza sarà al massimo)

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

Economico ed economico

1...84858687888990919293949596
Nuovo commento