Errori, bug, domande - pagina 443

Nuovo commento
 
voix_kas:

Risultato:

O sto facendo qualcosa di sbagliato (per favore correggete), o MetaDriver ha fatto un errore in teoria (quando ha progettato l'algoritmo).

:)

Beh, considerando il fatto che la "progettazione" dell'algoritmo ha richiesto circa 3 minuti (e 7 minuti di implementazione), ho fatto abbastanza bene :) L'obiettivo era quello di mostrare l'idea di lavoro e di chiarire la dichiarazione del problema.

E tutto questo si è rivelato utile - gli sviluppatori hanno avuto una reale opportunità di migliorare la funzione MathFloor() - ovviamente non è completamente implementata in modo pulito.

Alla fine hanno dovuto armeggiare. È stato divertente. Sono riuscito ad ottenere una funzione stabile (intendo CountSignedDigits(double x)) solo dopo quasi un'ora di esperimenti.

E anche ora non sono sicuro che funzionerà correttamente con tutti i valori di input. Non ho sviluppato uno stress-test automatico, ne ho fatto uno manuale, per favore testatelo.

Mi aspetto un funzionamento stabile fino a 10 cifre decimali dopo la virgola mobile.

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;
}
Stress-test allegato. // Non ho rimosso alcune realizzazioni intermedie dal codice. L'ho lasciato nei commenti per farvi provare/pensare. Compresi gli sviluppatori.
File:
CSDigitTest.mq5  2 kb
 
komposter:
1. non c'è bisogno di definire lo scavo per un lotto, basta normalizzarlo al passo giusto:

2. anche se c'è un po' di spazzatura nella variabile del lotto quando si invia una richiesta di trading (nella posizione decimale), dovrebbe essere scartata dal terminale stesso.

Per lo meno, non ho avuto alcun problema durante diversi anni di utilizzo di un tale costrutto.

4. Se vuoi assicurare, puoi normalizzarlo a 8 cifre decimali (con un margine) - se c'è della spazzatura dopo la normalizzazione "corretta", sarà molto più lontano.

La prima idea è corretta, le altre sono sospette. :)

L'implementazione è fattibile per la pratica, ma per le condizioni artificiali definite da "problem-starter" (c) è imprecisa. Per i passi discreti genera non relativi a lot_min, ma relativi a zero. :)

Tuttavia, può essere facilmente risolto se lo si nota.

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

// Per favore, non prendete tutte queste perle troppo sul serio. I chiarimenti sono puramente teorici, per l'allenamento del cervello, perché in pratica non ho mai visto lot_step uguale a, diciamo, 0,0231....

;)

  
metadriverNormalizeLot

l'opzione è corretta. Correttamente contabilizzato da lot_min come nel mio NL().

 

Anche la mia variante è disponibile. Si noti che per alcuni strumenti il passo di variazione del prezzo è più grande del 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 );
}
 

Se prendiamo come assioma che i passi "vanno" dal lotto minimo piuttosto che da zero, l'algoritmo corretto è il seguente:

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

Nella versione Composter, i passi "vanno" da zero. Il che non mi sembra giusto.
Nella variante MetaDriver, il codice salta un valore negativo. =Р

 
voix_kas:
...

Nella variante MetaDriver, il codice salta un valore negativo. =Р

:)) ..... Oh così! Non lavorerai affatto! ;-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);
}

Beh, semmai la variante più breve e allo stesso tempo "più o meno accurata" è questa:

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 questo senza controllare la nullità e la negatività di lot_step, lot_min e lot_max!!......

:))))

 

Uh... ha colpito un nervo scoperto. :)) L'ultima riga è stata corretta a mano in un post del forum, quindi perdonatemi. =)
A proposito, anche il tuo codice non ha compilato (ho dimenticato di mettere una parentesi di chiusura nell'ultima riga). :-Р
Inoltre è 2-3 volte più lento (ora l'ho controllato su script), ma la qualità del controllo è la stessa. :-Р

Comunque, finché non c'è un codice adeguato per determinare il numero intero significativo, seguirò il consiglio di Composter: normalizzare il volume a 8 cifre decimali.
Speriamo che non ci siano insidie.

Grazie a tutti per il vostro aiuto.

 

Vedo che siete divertenti.

nel tuo primo post hai dato a NL() quello che sei arrivato solo a due pagine dopo ;)

 

C'è un'altra domanda per i guru. Quando sto testando la multicurrency, ottengo degli errori (screenshot allegato).
Sto cercando di fare un'operazione commerciale, ma ottengo una risposta: nessun prezzo. Secondo il tester si può vedere che le quotazioni per questa coppia iniziano ad arrivare nel 2011.01.0301:00:00, mentre EURUSD è quotato anche dal 2011.01.0300:00:00 C'è un modo per scoprire il tempo di inizio delle quotazioni per aggirare questo errore?

Screenshot con errore

 
voix_kas:

C'è un'altra domanda per i guru. Quando provo il multicurrency, ottengo degli errori (screenshot allegato).
Sto cercando di fare un'operazione commerciale, ma ottengo una risposta: nessun prezzo. Secondo il tester si può vedere che le quotazioni per questa coppia iniziano ad arrivare nel 2011.01.0301:00:00, mentre EURUSD è quotato anche dal 2011.01.0300:00:00 C'è un modo per trovare il tempo di inizio delle quotazioni per evitare questo errore?

Le sessioni di trading e di quotazione non aiuteranno a risolvere il problema?
1...436437438439440441442443444445446447448449450...3184
Nuovo commento