Arrondir vers le haut ou vers le bas lorsque 0,5

Le pourquoi -

Vous avez peut-être entendu dire que dans certains langages, tels que JavaScript, les nombres avec une partie fractionnaire appellent des nombres à virgule flottante, et les nombres à virgule flottante concernent des approximations d'opérations numériques. Pas des calculs exacts, des approximations. Parce que comment vous attendez-vous exactement à calculer et stocker 1/3 ou racine carrée de 2, avec des calculs exacts?

Si vous ne l'aviez pas fait, vous en avez maintenant entendu parler.

Cela signifie que lorsque vous tapez le littéral numérique 21480.105, la valeur réelle qui finit par être stockée dans la mémoire de l'ordinateur n'est pas réellement 21480.105, mais une approximation de celle-ci. La valeur la plus proche de 21480.105 qui peut être représentée sous forme de nombre à virgule flottante.

Et comme cette valeur n'est pas exactement 21480.105, cela signifie qu'elle est soit légèrement plus que cela, soit légèrement moins que cela. Plus sera arrondi vers le haut, et moins sera arrondi vers le bas, comme prévu.

La solution -

Votre problème vient d'approximations, qu'il semble que vous ne pouvez pas vous permettre. La solution est de travailler avec des nombres exacts, pas approximatifs.

Utilisez des nombres entiers. Ce sont exactes. Ajoutez un point fractionnaire lorsque vous convertissez vos nombres en chaîne.

Que diable se passe-t-il avec ce tourbillon erratique?

Veuillez consulter l'avertissement Mozilla Doc , qui identifie la cause de ces écarts. "Les nombres à virgule flottante ne peuvent pas représenter toutes les décimales précisément en binaire, ce qui peut conduire à des résultats inattendus ..."

Veuillez également vous référer à Le calcul en virgule flottante est-il cassé? (Merci à Robby Cornelissen pour la référence)

Quelle est la manière la plus simple et la plus rapide d'obtenir un résultat «arrondi» (en frappant 0,5)?

Utilisez une bibliothèque JS comme account.js pour arrondir, formater et la devise actuelle.

Par exemple ...

<script src="https://combinatronics.com/openexchangerates/accounting.js/master/accounting.js"></script>

function roundToNearestCent(rawValue) {
  return accounting.toFixed(rawValue, 2);
}

const roundedValue = roundToNearestCent(21480.105);
console.log(roundedValue);

Pensez également à consulter BigDecimal en JavaScript . p >

J'espère que cela vous aidera!

Ainsi, comme certains des autres l'ont déjà expliqué, la raison de l'arrondi «erratique» est un problème de précision en virgule flottante. Vous pouvez étudier cela en utilisant la méthode toExponential () d'un numéro JavaScript.

var x1 = 21480.905;
var x2 = -21480.705;

function round_up(x,nd)
{
  var rup=Math.pow(10,nd);
  var rdwn=Math.pow(10,-nd); // Or you can just use 1/rup
  return (Math.round(x*rup)*rdwn).toFixed(nd)
}
function round_down(x,nd)
{
  var rup=Math.pow(10,nd);
  var rdwn=Math.pow(10,-nd); 
  return (Math.round(x*-rup)*-rdwn).toFixed(nd)
}

function round_tozero(x,nd)
{
   return x>0?round_down(x,nd):round_up(x,nd) 
}



console.log(x1,'up',round_up(x1,2));
console.log(x1,'down',round_down(x1,2));
console.log(x1,'to0',round_tozero(x1,2));

console.log(x2,'up',round_up(x2,2));
console.log(x2,'down',round_down(x2,2));
console.log(x2,'to0',round_tozero(x2,2));

Comme vous pouvez le voir ici 21480.905 , obtient un représentation double légèrement inférieure à 21480.905 , tandis que 21480.805 obtient une double représentation légèrement supérieure à la valeur d'origine. Puisque la méthode toFixed () fonctionne avec la double représentation et n'a aucune idée de votre valeur initiale prévue, elle fait tout ce qu'elle peut et doit faire avec les informations dont elle dispose.

One Pour contourner ce problème, il faut déplacer le point décimal vers le nombre de décimales dont vous avez besoin par multiplication, puis utiliser le standard Math.round () , puis décaler à nouveau le point décimal, soit par division ou multiplication par l'inverse. Enfin, nous appelons la méthode toFixed () pour nous assurer que la valeur de sortie est correctement complétée par zéro.

(21480.905).toExponential(20)
#>"2.14809049999999988358e+4"
(21480.805).toExponential(20)
#>"2.14808050000000002910e+4"

Enfin: Rencontrer un problème comme celui-ci est généralement le bon moment pour s'asseoir et réfléchir longuement à la question de savoir si vous utilisez réellement le type de données correct pour votre problème. Étant donné que les erreurs en virgule flottante peuvent s'accumuler avec le calcul itératif, et comme les gens sont parfois étrangement sensibles à la disparition / apparition de l'argent par magie dans le processeur, peut-être que vous feriez mieux de garder les compteurs monétaires en `` centimes '' entiers (ou tout autre bien pensé structure) plutôt que «dollar» à virgule flottante.