Suivez-nous sur X
|
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z,
ALL
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z
|
|
A propos d'Obligement
|
|
David Brunet
|
|
|
|
Programmation : C - les calculs en flottants
(Article écrit par Batchman et extrait d'A-News (Amiga News) - décembre 1989)
|
|
Ce mois-ci, la brochette de programmes du mois n'est pas pour les cancres. Mathématiques et calculs en flottants,
vais vous dresser, moi ! Plaisanterie mise à part, le calcul en flottants n'est pas quelque chose de trivial.
Votre microprocesseur 680x0 ne sait pas faire les additions, multiplications, etc. sur ces valeurs. Il faut
donc utiliser tout un ensemble de routines étudiées pour. Comme promis dans l'article
C qui traitait des types de base, nous allons
voir comment les mettre en oeuvre.
Flottants
Nous parlerons de deux types de flottants, les flottants "ordinaires" et les flottants FFP
(Fast Floating Point). Les flottants ordinaires permettent de couvrir un intervalle de valeurs
allant de plus ou moins 10E-37 à plus ou moins 10E+38 (1 bit de signe, 8 bits d'exposant et 23
bits pour la mantisse). Le traitement des flottants FFP est nettement plus rapide mais, en
contrepartie, il y a quelques inconvénients : ils sont moins faciles à mettre en oeuvre et
couvrent un domaine plus réduit : de plus ou moins 10E-20 à plus ou moins 10E+19 (soit 1
bit de signe, 7 bits d'exposant et 24 bits pour la mantisse).
Enfin, les flottants ordinaires gèrent certaines erreurs (comme la division par zéro) alors
que les flottants FFP vous renverront à vos chères études (avec le Guru n°5).
Avant tout, je précise que ces programmes sont écrits pour le compilateur Lattice. Pour ceux qui
ont le Manx, le principe de base est le même, mais les noms des bibliothèques
peuvent changer (reportez-vous à votre notice).
Exemple simple de calcul en flottants
Le programme qui suit ne fait que des opérations simples. Le compilateur dispose ici de
ses propres routines d'opérations arithmétiques. Comme vous le constatez, il n'y a pas de bibliothèques
à ouvrir.
Par contre, l'éditeur de liens doit utiliser la bibliothèque mathématique. Les trois bibliothèques
à utiliser sont donc, dans l'ordre, lcm.lib, lc.lib et amiga.lib.
C'est bien gentil tout ça mais vous aimeriez certainement faire des calculs plus savants,
qui utilisent des fonctions mathématiques. On les appelle encore "fonctions transcendentales".
Ici aussi, le compilateur vous facilite le travail en amenant ses propres routines, donc il
n'y a pas de bibliothèque à ouvrir. Ces routines se trouvent dans la lcm.lib. Par conséquent,
n'oubliez pas de la signaler à l'éditeur de lien.
Tout cela est très simple. Ce type de flottant doit être utilisé dans de petits programmes,
vite fait, bien fait, sans se casser la tête.
Mais pour des programmes où la vitesse est conditionnée par des calculs en flottants, il
vaut mieux utiliser à ce moment-là les flottants FFP. Attention, ils ne sont pas compatibles
avec les flottants ordinaires. Tous les "float" de votre programme doivent être soit ordinaires,
soit FFP. Le gain de temps est appréciable, allant de 2,5 fois pour des opérations simples à
10 fois pour des calculs de cosinus, par exemple. Ce sont deux valeurs relevées au hasard,
elles ne représentent pas forcément les gains minimaux et maximaux.
Comment mettre en oeuvre ces flottants FFP ?
Ici, ce n'est pas le compilateur qui dispose des bibliothèques, c'est Commodore qui les fournit.
La bibliothèque mathffp.library, qui se trouve en ROM, contient les fonctions de base :
- Conversion entier -> flottant FFP.
- Conversion flottant FFP -> entier.
- Comparaison de deux flottants FFP.
- Comparaison à 0.
- Valeur absolue.
- Calcul de l'opposé.
- Addition, soustraction de deux valeurs.
- Multiplication, division de deux valeurs.
Vous pouvez tester ces opérations sur le premier programme d'exemple mais, pour utiliser ces fonctions, plusieurs
opérations sont nécessaires :
1. Ouvrir la bibliothèque mathffp.library. Il faut pour cela la déclarer en tête du programme par :
Avant la première opération en flottant, il faut ouvrir effectivement la bibliothèque par :
MathBase = OpenLibrary("mathffp.library",0);
if (!MathBase) exit();
|
A la fin du programme, il faut refermer la bibliothèque par :
2. Vous devez avertir l'éditeur de liens qu'il travaille sur des flottants FFP.
Certaines fonctions étant différentes, il faut lier avec la bibliothèque
lcmffp.lib au lieu de lcm.lib. Attention, vous ne devez jamais avoir ces deux
bibliothèques en même temps puisque les flottants ordinaires et FFP sont
incompatibles.
3. Et j'ai gardé le meilleur pour la fin, il faut aussi prévenir le compilateur que
vous utilisez des flottants FFP, afin qu'il génère les appels aux bonnes fonctions.
Ceci se fait en ajoutant dans l'appel de lc1 ou de le l'argument -f.
Voilà pour le principe de base. Mais le compilateur Lattice est tout de même sympa.
Puisqu'il sait que vous utilisez les flottants FFP, il génère tout seul l'ouverture
de la mathffp.library lors du premier appel d'une de ces fonctions. Donc, si vous
compilez avec le Lattice, vous pouvez éviter l'étape n°1.
Les fonctions transcendantales en FFP
Voyons maintenant pour les fonctions transcendentales. Elles se trouvent dans la mathtrans.library,
qui n'est pas en ROM mais sur disque, dans votre répertoire "libs". Si le système ne la trouve
pas, le premier appel à une de ces fonctions provoquera un plantage. C'est pourquoi il
faut toujours tester le résultat de l'ouverture de la bibliothèque.
Si celle-ci a échoué, OpenLibrary renvoie "0" et il faut terminer sinon gare...
L'ouverture de cette bibliothèque se fait par :
...dans les déclarations et avant le premier calcul en flottant :
MathTransBase = OpenLibrary("mathtrans.library",0);
if (!MathTransBase) exit();
|
Et à la fin du programme :
|
CloseLibrary(MathTransBase);
|
N'oubliez pas aussi en début du fichier :
|
#include "librairies/mathffp.h"
|
...qui contient les déclarations de ces fonctions et de leurs paramètres. Vous ne serez pas étonné
si je vous dis que le compilateur Lattice, dans son infinie bonté, génère tout seul comme
un grand l'ouverture de cette bibliothèque à votre place, ici aussi.
Elle se fait lors de la première opération rencontrée sur un flottant. Ne soyez donc pas surpris si,
la première fois que vous lancez le programme, il commence à s'exécuter, et vous demande ensuite
d'insérer la disquette Workbench (si vous n'avez pas de disque dur).
Afin que vous ne soyez point interloqué par la turbidité de mes propos, vous pouvez essayer tout
de suite un exemple : le même programme que pour les flottants ordinaires (le deuxième) compilé
et lié suivant les conditions ci-dessus. Évidemment, vous obtenez le même résultat mais beaucoup
plus rapidement, bien que dans ce cas, cela ne soit pas très visible...
|
