Può il prezzo != prezzo ? - pagina 4

Nuovo commento
 
rfb:
Uguale a "intCheck", ma assegnato al valore prima della funzione, come altre vars.

Quindi questo funzionerà?

intCheck = 1.1000000000001 /point;
intRecord = 1.0999999999999 /point;

if (intRecord > intCheck) Print("Prices are the same.");
 
RaptorUK:

Quindi questo funzionerà?

Naturalmente NO, è solo per calcoli semplici per i mercati parziali o simili con meno cifre. Niente funzionerà se più di 10 cifre contate su entrambi i lati del punto decimale insieme, limiti. Solo un giocattolo.
 
rfb:
Naturalmente NO, è solo per calcoli semplici per i mercati parziali o simili con meno cifre. Niente funzionerà se più di 10 cifre contate su entrambi i lati del punto decimale insieme, limiti. Solo un giocattolo.
Il mio codice funziona bene.
 
WHRoeder:

Non complicare troppo le cose

Se qualcosa (o qualche idea) è complicata o complessa è, credo, una questione di interpretazione individuale.

Una divisione fluttuante, un'addizione fluttuante, una conversione in int, una chiamata di funzione (copia, salto, ritorno = 3,) * 2 tutte volte due. (18) E questo supponendo che dividere e convertire siano alla pari con le altre operazioni - non lo sono.

Non ho mai voluto suggerire che la soluzione che ho creato e uso sia la più efficiente - mi rendo conto che potrebbe non esserlo, ma la cosa importante è che (1) capisco (e, in questo momento, posso tollerare) il suo overhead aggiuntivo e il costo di calcolo e (2) risolve il problema (almeno per me) di confrontare due prezzi che sono in formato a virgola mobile a doppia precisione.

In definitiva, capisco il problema inerente al confronto per l'uguaglianza di due numeri reali che sono in un formato a virgola mobile a doppia precisione, ma penso che tu ed io abbiamo affrontato il problema in un modo leggermente diverso in questo contesto. Tu usi quello che potrei chiamare un "confronto epsilon" per determinare se due doppi sono abbastanza vicini da essere intesi come uguali - cioè, se la differenza tra due doppi è entro la tua deviazione massima (Punto / 2.), allora i due doppi sono uguali. D'altra parte, ho scelto di trasformare i prezzi in ints per il confronto dividendo per Point, arrotondare al numero intero più vicino, salvare il risultato come int, e poi confrontare i due ints. Ho usato una chiamata di funzione, piuttosto che codice in linea, perché è più naturale per me - tendo a raggruppare il codice in subroutine/funzioni - e perché è potenzialmente riutilizzabile (forse da quella piccola parte di me che pensa in termini OOP). Ho preso molto da quello che hai detto il 16 febbraio 2012:

Il valore doppio dal broker potrebbe essere ovunque da 1.23457500000000 a 1.23458499999999999 ed essere ancora considerato lo stesso prezzo 1.23458.

Ecco perché ho deciso di arrotondare al numero intero più vicino invece di troncare la parte decimale dopo la divisione per Point ma prima di convertire il doppio in un int.

Tutto questo non è per dire che non sono d'accordo con quello che hai postato, piuttosto è un riconoscimento che ho rivisto quello che hai postato e lo salverò per riferimento futuro (e per un potenziale uso successivo, se necessario). :)

Come sempre, i commenti istruttivi/costruttivi sono benvenuti. :)

 
Thirteen:

Se qualcosa (o qualche idea) è complicata o complessa è, credo, una questione di interpretazione individuale.

Non ho mai voluto suggerire che la soluzione che ho creato e che uso sia la più efficiente - mi rendo conto che potrebbe non esserlo, ma la cosa importante è che (1) capisco (e, in questo momento, posso tollerare) il suo sovraccarico aggiuntivo e il costo di calcolo e (2) risolve il problema (almeno per me) di confrontare due prezzi che sono in formato a virgola mobile a doppia precisione.


Sono d'accordo con te. . e sono anche d'accordo conWHRoeder

Il mio codice è stato scritto con la necessità di qualcosa da inserire nel codice esistente senza romperlo o dover passare molte ore a trovare bug, quindi ha raggiunto il suo scopo. Vorrei anche prendere in considerazione ciò cheWHRoeder ha postato almeno in parte e venire con una versione migliore di ciò che sto facendo pur mantenendolo leggibile per il mio uso. Se riesco a fare tutto questo lo posterò in questo thread.

 
RaptorUK:

Se riesco a fare qualcosa di tutto questo, lo posterò in questo thread.

La mia funzione Flat() era 17 volte più lenta della soluzionedi WHRoeder, ho una proposta che penso sia più leggibile e solo 3 o 4 volte più lenta, a seconda del tipo di confronto. 3 o 4 volte più lenta non è una grande cosa da ottenere ma rispetto a 17 volte più lenta è un grande miglioramento. L'ho testata un po', non ancora estensivamente.

Utilizzo:

bool Compare(double FirstPrice, int ComparisonType, double SecondPrice)


for example:

if(Compare(Bid, LT, Ask)) Print("Bid is less than Ask");

if(Compare(Price, EQ, Price)) Print("Price does equal Price");

I tipi di confronto sono EQ per uguale, NEQ per non uguale, GT per maggiore di e LT per minore di.

#define LT    0
#define GT    1
#define EQ    2
#define NEQ   4


bool Compare(double FirstPrice, int ComparisonType, double SecondPrice)
   {
   double HalfAPoint = Point / 2.0;
   

   switch(ComparisonType)
      {
      case LT: if ( SecondPrice - FirstPrice > HalfAPoint)
                  return(true);
               else return(false); 
      
      case GT: if ( FirstPrice - SecondPrice > HalfAPoint)
                  return(true);
               else return(false); 
      
      case EQ: if (MathAbs(FirstPrice - SecondPrice) > HalfAPoint)
                  return(false);
               else return(true); 
      
      case NEQ: if (MathAbs(FirstPrice - SecondPrice) > HalfAPoint)
                  return(true);
               else return(false);
      }
   }
 
Semplicemente i tuoi bools
case GT: if ( FirstPrice - SecondPrice > HalfAPoint)
                  return(true);
               else return(false); 
case GT: 
   return(FirstPrice - SecondPrice > HalfAPoint);
 
WHRoeder:
Semplicemente i tuoi bools

Buon punto.

bool Compare(double FirstPrice, int ComparisonType, double SecondPrice)
   {
   double HalfAPoint = Point / 2.0;
   

   switch(ComparisonType)
      {
      case LT: return( SecondPrice - FirstPrice > HalfAPoint);
      
      case GT: return( FirstPrice - SecondPrice > HalfAPoint);
      
      case EQ: return(!MathAbs(FirstPrice - SecondPrice) > HalfAPoint);
      
      case NEQ: return(MathAbs(FirstPrice - SecondPrice) > HalfAPoint);
      
      }
   }

Le prestazioni non sono cambiate in modo significativo.

  
  case EQ:  return(!MathAbs(FirstPrice - SecondPrice) > HalfAPoint); // Initially missed the !
  case NEQ: return( MathAbs(FirstPrice - SecondPrice) > HalfAPoint);
Regole di precedenza Non (!) è quasi la più alta: quando primo != secondo esattamente, (!ABS(non zero) > nz) == (0 > nz) == falso. Se f==s allora (!0 > nz) == (1 > p/2) == vero se punto < 1
 
WHRoeder:
Regole di precedenza Non (!) è quasi il massimo: quando primo != secondo esattamente, (!ABS(non zero) > nz) == (0 > nz) == falso. Se f==s allora (!0 > nz) == (1 > p/2) == vero se punto < 1

Sì, buona cattura . . .

bool Compare(double FirstPrice, int ComparisonType, double SecondPrice)
   {
   double HalfAPoint = Point / 2.0;
   

   switch(ComparisonType)
      {
      case LT: return( SecondPrice - FirstPrice > HalfAPoint );
      
      case GT: return( FirstPrice - SecondPrice > HalfAPoint );
      
      case EQ: return(!( MathAbs(FirstPrice - SecondPrice) > HalfAPoint ) );
      
      case NEQ: return( MathAbs(FirstPrice - SecondPrice) > HalfAPoint );
      
      }
   }
12345678
Nuovo commento