Can price != price ? - page 4

Nouveau commentaire
 
rfb:
Comme "int intCheck" mais avec une valeur assignée avant la fonction, comme les autres variables.

Cela va-t-il fonctionner ?

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

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

Cela va donc fonctionner ?

Bien sûr que NON, c'est seulement pour des calculs simples pour les prix du marché ou similaires avec moins de chiffres. Rien ne fonctionnera si plus de 10 chiffres sont comptés des deux côtés du point décimal, limites. C'est juste un jouet.
 
rfb:
Bien sûr que NON, c'est seulement pour des calculs simples pour les prix du marché ou similaires avec moins de chiffres. Rien ne fonctionnera si plus de 10 chiffres comptés des deux côtés du point décimal ensemble, limites. Juste un jouet.
Mon code fonctionne très bien.
 
WHRoeder:

Ne pas trop compliquer les choses

Que quelque chose (ou une idée) soit compliqué ou complexe est, je crois, une question d'interprétation individuelle.

Une division flottante, une addition flottante, une conversion en int, un appel de fonction (copie, saut, retour = 3,) * 2 tous les temps deux. (18) Et cela en supposant que la division et la conversion sont sur un pied d'égalité avec les autres opérations - ce n'est pas le cas.

Je n'ai jamais voulu suggérer que la solution que j'ai créée et que j'utilise est la plus efficace - je me rends compte qu'elle ne l'est peut-être pas. Mais l'important, c'est que (1) je comprends (et, pour l'instant, je peux tolérer) ses frais généraux et son coût de calcul supplémentaires et (2) elle résout le problème (du moins pour moi) de la comparaison de deux prix qui sont dans un format à virgule flottante en double précision.

En fin de compte, je comprends le problème inhérent à la comparaison pour l'égalité de deux nombres réels qui sont dans un format à virgule flottante en double précision, mais je pense que vous et moi avons abordé le problème d'une manière légèrement différente dans ce contexte. Vous utilisez ce que je pourrais appeler une "comparaison epsilon" pour déterminer si deux doubles sont suffisamment proches pour être compris comme étant égaux - c'est-à-dire, si la différence entre deux doubles est dans votre écart maximal (Point / 2.), alors les deux doubles sont égaux. D'autre part, j'ai choisi de transformer les prix en ints pour la comparaison en divisant par Point, en arrondissant au nombre entier le plus proche, en sauvegardant le résultat sous forme d'un int, puis en comparant les deux ints. J'ai utilisé un appel de fonction, plutôt que du code en ligne, parce que c'est plus naturel pour moi - j'ai tendance à regrouper le code en sous-routines/fonctions - et parce que c'est potentiellement réutilisable (peut-être par cette petite partie de moi qui pense en termes de POO). J'ai pris beaucoup de ce que vous avez dit le 16 février 2012 :

La double valeur du courtier pourrait être n'importe où entre 1,23457500000000 et 1,23458499999999999 et être toujours considérée comme le même prix de 1,23458.

C'est pourquoi j'ai décidé d'arrondir au nombre entier le plus proche au lieu de tronquer la partie décimale après avoir divisé par Point mais avant de convertir le double en un int.

Tout ceci ne veut pas dire que je ne suis pas d'accord avec ce que vous avez publié, mais plutôt que j'ai pris connaissance de ce que vous avez publié et que je le conserverai pour m' y référer ultérieurement (et pour une utilisation potentielle plus tard, si nécessaire) :)

Comme toujours, les commentaires instructifs/constructifs sont les bienvenus. :)

 
Thirteen:

Que quelque chose (ou une idée) soit compliqué ou complexe est, je crois, une question d'interprétation individuelle.

Je n'ai jamais voulu suggérer que la solution que j'ai créée et que j'utilise est la plus efficace - je me rends compte qu'elle ne l'est peut-être pas. Mais l'important, c'est que (1) je comprends (et, pour l'instant, je peux tolérer) ses frais généraux et son coût de calcul supplémentaires et (2) elle résout le problème (du moins pour moi) de la comparaison de deux prix qui sont en format de double précision à virgule flottante.


Je suis d'accord avec vous . ... et je suis également d'accord avecWHRoeder.

Mon code a été écrit avec un besoin de quelque chose à brancher dans le code existant sans le casser ou avoir à passer de nombreuses heures à chercher des bogues, donc il a atteint son but. J'aimerais aussi prendre en compte ce queWHRoeder a posté au moins partiellement et arriver à une meilleure version de ce que je fais tout en le gardant encore lisible pour mon utilisation. Si je réussis à faire cela, je le posterai dans ce fil.

 
RaptorUK:

Si j'y arrive, je le posterai dans ce fil.

Ma fonction Flat() était 17 fois plus lente que la solutionde WHRoeder, j'ai une proposition qui je pense est plus lisible et seulement 3 ou 4 fois plus lente, selon le type de comparaison. 3 ou 4 fois plus lente n'est pas une grande chose à réaliser mais comparée à 17 fois plus lente est une grande amélioration. Je l'ai testé un peu, pas encore de manière extensive.

Utilisation :

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

Les types de comparaison sont, EQ pour égal, NEQ pour non égal, GT pour plus grand que et LT pour moins que.

#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);
      }
   }
 
Simplement vos bools
case GT: if ( FirstPrice - SecondPrice > HalfAPoint)
                  return(true);
               else return(false); 
case GT: 
   return(FirstPrice - SecondPrice > HalfAPoint);
 
WHRoeder:
Il suffit que vos bools

Bon point.

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

Les performances n'ont pas changé de manière significative.

  
  case EQ:  return(!MathAbs(FirstPrice - SecondPrice) > HalfAPoint); // Initially missed the !
  case NEQ: return( MathAbs(FirstPrice - SecondPrice) > HalfAPoint);
Règles de précédence Pas ( !) est presque le plus élevé : lorsque premier != second exactement, (!ABS(non-zéro) > nz) == (0 > nz) == faux. Si f==s alors (!0 > nz) == (1 > p/2) == vrai si point < 1
 
WHRoeder:
Règles de précédence Pas ( !) est presque le plus élevé : lorsque premier != second exactement, (!ABS(non-zéro) > nz) == (0 > nz) == faux. Si f==s alors (!0 > nz) == (1 > p/2) == true si point < 1

Oui, bien vu...

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
Nouveau commentaire