troncage d'un montant avec floor et écart de centime.

Bonjour à tous,

J'utilise une fonction permettant de tronquer (Math.floor()) un nombre représentant le montant TTC . Seulement voilà pour le cas d'un nombre étant égal à 60, lorsque je muliplie ce dernier par 1.196 en utilisant la fonction Floor pour tronquer. J'obtiens 71,75 en effectuant le code suivant :

Code:

---

1 2 3 4

montantHT = 60; montantTTC = Math.floor(montantHT*1.196*100)/100; Response.write(montantTTC);

---

au lieu de 71,76 que je devrais avoir. Y a t'il une fonction permettant de résoudre ce problème d'écart de centime ?

Le code que j'utilise est sous environnement ASP Javascript .


Cordialement.

Bonsoir,
pourquoi ne pas utiliser Math.round?
<EDIT>
ou toFixed(2)
</EDIT>

Je ne voudrais pas utiliser d'arrondi, c'est pour des raisons de comptabilités et ne souhaite que tronquer les nombres .

Par exemple pour 15.148855 je voudrais obtenir un nombre 15.14 mais pas 15.15 .

Cordialement .

Le souci provient de la virgule flottante en javascript
pour javascript
60 * 1.196 = 71.75999999999


il te faut donc corriger ceci pour js:
Math.round(ht*1.196*100)/100)

et en y ajoutant ton floor:
Math.floor(Math.round(ht*1.196*100))/100

Citation:

---

Envoyé par SpaceFrog

Le souci provient de la virgule flottante en javascript

---

pas seulement en javascript d'ailleurs

Le rajout de Math.round ne répondra pas au problème, il existe une alternative, pour tronquer s'entends, et de diviser la division faisant "moins" d'erreur, mais comme elle en fait aussi il suffit de garder la plus grande des valeurs.

Petit code d'exemple

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

var Mul = 1.196; var Div = 1 / Mul; var valMul; var valDiv; var valMax; var Html ='<table><tr><th>valeur<\/th><th>Multiplication<\/th><th>Division<\/th><th>Garde<\/th><\/tr>'; for( var i = 1; i < 100; i +=1){ valMul = i*Mul; valDiv = i/Div; valMax = valMul > valDiv ? valMul : valDiv; valMax = Math.floor( valMax *100)/100; // Methode calcul SpaceFrog //valMax = Math.floor(Math.round( valMul*100))/100; Html += '<tr><td>' +i +'<\/td><td>'+ valMul +'<\/td><td>' +valDiv +'<\/td><td>'+ valMax +'<\/td><\/tr>'; } Html +='<\/table>'; document.write( Html);

---

Code:

---

Math.round ne répondra pas au problème,

---

ben en l'occurrence avec un *100 /100 ça recitifie au centième

Citation:

---

Envoyé par SpaceFrog

Code:

---

Math.round ne répondra pas au problème,

---

ben en l'occurrence avec un *100 /100 ça recitifie au centième

---

certes mais ce n'est visiblement pas le souhait de marcandre

Citation:

---

Par exemple pour 15.148855 je voudrais obtenir un nombre 15.14 mais pas 15.15 .

---

Attention NoSMo il y a deux niveaux
son souhait de troncage ne concerne pas la virgule flottante ...
il faut d'abord parer au souci de virgule flottante avec d'appliquer son troncage, enfin d'après ce que j'ai compris de sa demande .

Merci à vous .

C'est bien celà NoSmoking le but est d'avoir une fonction permettant de tronquer un montant par exemple :

12.34999 => 12.34 .

J'opte pour la solution de NoSmoking .

A bientôt .

heu ...

réponse :

Code:

---

1 2 3

montantHT = 60; montantTTC = Math.floor(100*montantHT*1.196)/100; Response.write(montantTTC);// 71,76

---

;)


explications : pour éviter les problèmes des virgules flottantes et mauvais arrondis, effectuez toujours vos multiplications entières avant vos divisions et multiplications non-entières. les lignes de codes sont toujours interprétées de gauche à droite (pour les opérateurs de même poid) donc voila ! il suffisait de permettuer 2 éléments dans ton opération. ^^

Citation:

---

Envoyé par SpaceFrog

Le souci provient de la virgule flottante en javascript
pour javascript
60 * 1.196 = 71.75999999999


il te faut donc corriger ceci pour js:
Math.round(ht*1.196*100)/100)

et en y ajoutant ton floor:
Math.floor(Math.round(ht*1.196*100))/100

---

Citation:

---

Envoyé par SpaceFrog

Attention NoSMo il y a deux niveaux
son souhait de troncage ne concerne pas la virgule flottante ...
il faut d'abord parer au souci de virgule flottante avec d'appliquer son troncage, enfin d'après ce que j'ai compris de sa demande .

---

noSmoking à raison, dans ton code tu fais

floor(round(value));

le floor n'aura plus aucun effet après ton round qui renverra un nombre entier(sans virgule). ce que tu fais, reviens donc à un simple "round".

Quant à la solution de noSmoking, elle est un peu "longue". (CMB) :mrgreen:

en fait j'ai omis un niveau de parenthèses
la correction de la virgule flottante peut se faire avec le round en fonction du nombre de décimales voulues :

Code:

---

1 2	montantTTC = Math.floor( X *100)/100;

---

le but etant de corriger le souci de virgule flottante sur X

Code:

---

montantTTC = Math.floor( (math.round(montantHT*1.196*100)/100) *100)/100;

---

demo:

Code:

---

1 2 3 4

var montantHT=60 var foo= Math.floor( (Math.round(montantHT*1.196*100)/100) *100)/100;   alert((foo))

---

Citation:

---

Envoyé par SpaceFrog

en fait j'ai omis un niveau de parenthèses
la correction de la virgule flottante peut se faire avec le round en fonction du nombre de décimales voulues :

Code:

---

1 2	montantTTC = Math.floor( X *100)/100;

---

le but etant de corriger le souci de virgule flottante sur X

Code:

---

montantTTC = Math.floor( (math.round(montantHT*1.196*100)/100) *100)/100;

---

demo:

Code:

---

1 2 3 4

var montantHT=60 var foo= Math.floor( (Math.round(montantHT*1.196*100)/100) *100)/100;   alert((foo))

---

---

toujours pas :

Code:

---

1 2 3

var montantHT=10; var foo= Math.floor( (Math.round(montantHT*0.9999*100)/100) *100)/100; alert((foo)) // 10

---

d'après ce qu'il explique, il voudrait obtenir "9.99" dans mon exemple ici : "10*0.9999" pourtant ton code affichera 10 !

honnêtement y'avait de l'idée ! mon cerveau aussi tente de me convaincre qu'il existe une solution dans le genre de ce que tu proposes ... :mrgreen:


ps: de toute façon, il n'y aura pas de solution plus optimale que la mienne : "placer les opérations dans le bon ordre ! " :P

Code:

---

1 2 3 4 5 6 7

var montantHT=10; var foo= Math.floor(100*montantHT*0.9999)/100; alert((foo)) // 9.99   var montantHT=60; var foo= Math.floor(100*montantHT*1.196)/100; alert((foo)) // 71.76

---

heu ????

Code:

---

1 2 3 4

var montantHT=10 var foo= Math.floor( (Math.round(montantHT*.999*100)/100) *100)/100;   alert((foo))

---

moi il m'affiche 9.99 :lol:

Citation:

---

Envoyé par SpaceFrog

heu ????

Code:

---

1 2 3 4

var montantHT=10 var foo= Math.floor( (Math.round(montantHT*.999*100)/100) *100)/100;   alert((foo))

---

moi il m'affiche 9.99 :lol:

---

tricheur ! t'as supprimé une décimale ! :D

.9999 et non pas .999

mouarf pas fait exprès en plus ...

mais du coup :

Code:

---

var foo= Math.floor( (Math.round(montantHT*.9999*1000)/1000) *100)/100;

---

suffit de faire l'arrondi au niveau de la décimale voulue

Citation:

---

Envoyé par SpaceFrog

mouarf pas fait exprès en plus ...

mais du coup :

Code:

---

var foo= Math.floor( (Math.round(montantHT*.9999*1000)/1000) *100)/100;

---

suffit de faire l'arrondi au niveau de la décimale voulue

---

et si je rajoute un "9" ça redevient faux, tu es obligé de rajouter un zéro.
et si tu mets le nombre maximum de zéros dès le départ, ça ne gère plus les erreurs de virgules flottantes :
1.196*60 = 71.76 // et non pas 71.75999999999999999

voici un exemple de tous les cas. :ccool:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

var test1 = 1.196; var test2 = 0.9999999999999999; var montantHT=60; var decimal,foo;     decimal = 10000000000000; // 13 foo= Math.floor( (Math.round(montantHT*test1*decimal)/decimal) *100)/100; alert(foo); // 71.76 -> juste car arrondi en dessous de 14 décimal foo= Math.floor( (Math.round(montantHT*test2*decimal)/decimal) *100)/100; alert(foo); // 60 -> faux car arrondi en dessous de 14 décimal   decimal = 100000000000000; // 14 foo= Math.floor( (Math.round(montantHT*test1*decimal)/decimal) *100)/100; alert(foo); // 71.75 -> faux car non arrondi au dessus de 13 décimal foo= Math.floor( (Math.round(montantHT*test2*decimal)/decimal) *100)/100; alert(foo); // 59.99 -> juste car non arrondi au dessus de 13 décimal       // willpower foo= Math.floor(100*montantHT*test1)/100; alert(foo); // 71.76 -> juste foo= Math.floor(100*montantHT*test2)/100; alert(foo); // 59.99 -> juste

---

en fait, tu ne peux pas différencier quand c'est le moteur js qui génére un "71.75999999999999999" par erreur et donc arrondir à 71.76 et quand c'est l’utilisateur qui fourni un nombre comme par exemple "0.99999999".

Code:

---

1 2 3 4 5 6

var montantHT=10 var test2=0.999999999 var power=test2.toString().match(/\.(\d+)$/)[1].length var foo= Math.round( montantHT*test2*Math.pow(10,power-1))/Math.pow(10,power-1)   alert((foo))

---

Citation:

---

Envoyé par SpaceFrog

Code:

---

1 2 3 4 5 6

var montantHT=10 var test2=0.999999999 var power=test2.toString().match(/\.(\d+)$/)[1].length var foo= Math.round( montantHT*test2*Math.pow(10,power-1))/Math.pow(10,power-1)   alert((foo))

---

---

oui, cette fois ça me semble bon (du moins, je n'ai pas le courage de chercher un contre exemple) :ccool:

mais ça devient presque aussi tordu que la solution de noSmoking :aie:


edit: sinon simple curiosité de ma part : pq des doubles parenthèses pour le alert(foo) ?

Citation:

---

mon cerveau aussi tente de me convaincre qu'il existe une solution dans le genre de ce que tu proposes ...

---

La solution était là ...
il suffisait juste de la formaliser jusqu'au bout ;)