Discussion :

[marcandre]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[NoSmoking]

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

[marcandre]

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 .

[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

[NoSmoking]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[SpaceFrog]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

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

[NoSmoking]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

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

[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 .

[marcandre]

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 .

[Willpower]

heu ...

réponse :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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. ^^

[Willpower]

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

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)

[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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

demo:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[Willpower]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

demo:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 ...


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 ! "

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[SpaceFrog]

heu ????

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[Willpower]

heu ????

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

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

.9999 et non pas .999

[SpaceFrog]

mouarf pas fait exprès en plus ...

mais du coup :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

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

[Willpower]

mouarf pas fait exprès en plus ...

mais du coup :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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".

[SpaceFrog]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[Willpower]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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)

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


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

[SpaceFrog]

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