Entiers et Réels

real
integer

Il existe deux catégories de nombres, les entiers (integer) et les réels (real).

Les entiers sont des nombres qui ne contiennent pas de partie décimale,
les plages de valeurs reconnues sont :
+2147483647 à -2147483648 pour les entiers signés à 32 bits et
+32767 à -32768 pour les entiers signés à 16 bits.

En littéral ça donne pour les positifs :
plus deux milliards cent quarante sept millions quatre cent quatre-vingt trois mille six cent quarante sept
et pour les négatifs:
moins deux milliards cent quarante sept millions quatre cent quatre-vingt trois mille six cent quarante huit, limites assez éloignées vous en conviendrez.


La fonction (getint) est configurée pour n'accueillir que des entiers signés à 16 bits autrement dit à l'appel de cette fonction il ne sera pas possible de stocker dans une variable un nombre plus grand que 32767 ni plus petit que -32768 .
Pour rappel les entiers en système binaire codés à 16 bits sont dans cette plage car (2 puissance 16) donne 65536 ce qui explique la plage des nombres qu'on ventile en -32768, 0 et +32767 représente bien le nombre 65536.

L'aide officielle AutoDesk contient une coquille : only accept 16-bit numbers ranging from +32767 to -32678. (vérifié en mai 2018)

Cette  ligne de code va renvoyer une erreur  si l'utilisateur entre un nombre hors limites dans les entiers (integer) ou autre chose qu'un nombre entier :

(setq var1 (getint "\nEntrez un nombre ENTIER\n"))

qui va se présenter ainsi et qui relance la fonction (getint) en attendant un nombre dans la plage attendue :

; Nécessite un entier entre -32768 et 32767.

Si on doit dépasser les limites spécifiées plus haut il faut passer en nombres réels.
Une opération arithmétique avec deux entiers donne un résultat sous forme d'entier, mais une opération avec entiers et réels mélangés donne un résultat sous forme de réel

(+ 10 20 30) ;renvoie 60, entier
(+ 10 20 30.0) ;renvoie 60.0, réel

Lorsque la limite des entiers (64 bits) est atteinte lors d'une opération arithmétique le résultat est faussé :

(+ 2147483647 2)

renvoie -2147483647 ce qui est faux

 (* 1000000000 5)

renvoie 705032704 ce qui est aussi faux


En introduisant un nombre réel dans l'opération tout rentre dans l'ordre :

(+ 2147483647 2.0)

renvoie 2.14748e+009 en notation scientifique soit 2147483649.0 et c'est juste

(* 1000000000 5.0)

renvoie 5.0e+009 en notation scientifique soit 5000000000.0


Les réels sont les nombres contenant une partie décimale, ils sont stockés en double précision à virgule flottante mais la précision s'arrête à la quatorzième décimale,
Nous avons déjà vu ailleurs qu'AutoLISP ne montre pas toujours la totalité des décimales lors de l'interrogation d'une variable mais il en est bien tenu compte dans les calculs.

Les nombres compris entre -1 et 1 doivent être explicitement rentrés avec le zéro puis le point décimal pour être reconnus sans erreur :

(+ 0.2 1.0)

renvoie 1.2 ce qui est correct

( + .2 1.0)

renvoie ;erreur: placement incorrect d'un point en entrée


Si AutoLISP convertit implicitement les entiers en réels quand la valeur doit être réelle, c'est une bonne habitude de spécifier explicitement les nombre réels (ça évite à l'interpréteur une opération de conversion de type et ça rend le code plus explicite).
Par exemple, il est préférable d'écrire :

(setq normal '(0.0 0.0 1.0))

ou (setq normal '(0. 0. 1.)) ; écriture tolérée pour les réels : 1. pour 1.0

plutôt que :

(setq normal '(0 0 1))

 


haut de page

revenir au menu NOMBRES


7 juillet 2017
mise à jour le 07 mai 2018