Bonjour à tous !

A ma grande surprise, j'ai découvert que Javascript ne sait pas faire une simple addition.

Le script suivant additionne 7 nombres décimaux dont le total fait TOUJOURS 82.5, SAUF pour Javascript.

<script language="JavaScript" type="text/javascript">
<!--
largeur = new Array();
largeur[1] = 6.5; largeur[2] = 8  ; largeur[3] = 9.3; largeur[4] =10  ; largeur[5] =10.1; largeur[6] =10.4;
largeur[7] =13.6; largeur[8] =14.7; largeur[9] =14.9; largeur[10]=16.1; largeur[11]=16.7; largeur[12]=17.2;
largeur[13]=17.9; largeur[14]=18.6; largeur[15]=19.4; largeur[16]=19.6; largeur[17]=24.3; largeur[18]=24.4;

car = new Array();
for (i=0;i<20;i++) {
  car [i] = new Array(7);
}

car[0][1]= 1; car[0][2]= 6; car[0][3]= 1; car[0][4]= 6; car[0][5]= 1; car[0][6]=17; car[0][7]=13;
car[1][1]= 1; car[1][2]= 6; car[1][3]= 1; car[1][4]= 6; car[1][5]=13; car[1][6]=17; car[1][7]= 1;
car[2][1]= 1; car[2][2]= 4; car[2][3]= 1; car[2][4]=18; car[2][5]= 1; car[2][6]= 4; car[2][7]=14;
car[3][1]=13; car[3][2]=17; car[3][3]= 1; car[3][4]= 6; car[3][5]= 1; car[3][6]= 6; car[3][7]= 1;
car[4][1]= 1; car[4][2]= 6; car[4][3]=13; car[4][4]= 6; car[4][5]= 1; car[4][6]=17; car[4][7]= 1;
car[5][1]=13; car[5][2]= 6; car[5][3]= 1; car[5][4]= 6; car[5][5]= 1; car[5][6]=17; car[5][7]= 1;
car[6][1]= 1; car[6][2]=17; car[6][3]= 1; car[6][4]= 6; car[6][5]= 1; car[6][6]= 6; car[6][7]=13;
car[7][1]= 1; car[7][2]=17; car[7][3]= 1; car[7][4]= 6; car[7][5]=13; car[7][6]= 6; car[7][7]= 1;
car[8][1]= 1; car[8][2]=17; car[8][3]=13; car[8][4]= 6; car[8][5]= 1; car[8][6]= 6; car[8][7]= 1;
car[9][1]=14; car[9][2]= 4; car[9][3]= 1; car[9][4]=18; car[9][5]= 1; car[9][6]= 4; car[9][7]= 1;
car[10][1]= 1; car[10][2]= 4; car[10][3]=14; car[10][4]=18; car[10][5]= 1; car[10][6]= 4; car[10][7]= 1;
car[11][1]= 1; car[11][2]= 4; car[11][3]= 1; car[11][4]=18; car[11][5]=14; car[11][6]= 4; car[11][7]= 1;
car[12][1]=11; car[12][2]= 3; car[12][3]= 1; car[12][4]= 3; car[12][5]=11; car[12][6]= 3; car[12][7]= 8;
car[13][1]= 8; car[13][2]= 3; car[13][3]=11; car[13][4]= 3; car[13][5]= 1; car[13][6]= 3; car[13][7]=11;
car[14][1]= 7; car[14][2]= 5; car[14][3]= 9; car[14][4]= 5; car[14][5]=12; car[14][6]= 5; car[14][7]= 1;
car[15][1]= 1; car[15][2]= 5; car[15][3]=12; car[15][4]= 5; car[15][5]= 9; car[15][6]= 5; car[15][7]= 7;


for( i=0;i<16 ; i++) {
	tot=0;
	for( j=1;j<8 ;j++ ) {
		document.write(largeur[car[i][j]] + " ");
		if (j!=7) document.write("+");
		tot+=largeur[car[i][j]];
	}
	document.write("=" + tot + "<br>");
}

//-->
</script>

Je puis admettre que divisions et multiplications conduisent à des arrondis approximatifs, mais une simple addition...

Avez-vous une explication

Que ce soit multiplication, division, ou même une simple addition, quand on travaille en "float" dans tout langage de programmation il faut arrondir le résultat final sinon il n'est pas utilisable.

Il y a même des langages où un simple print 1.0 va afficher 1.00000000000000001. C'est aussi bête que ça, les float et le binaire ne sont pas faits pour aller bien ensemble voilà tout

Ce problème se pose à l'identique dans tous les langages. Rarement de manière aussi flagrante, mais il y a toujours des exemples de ce gout là où on conclut "ce langage ne permet même pas de faire une addition". Les float en programmation, c'est l'horreur