Obligement - L'Amiga au maximum

Dimanche 19 novembre 2017 - 05:53  

Translate

En De Nl Nl
Es Pt It Nl


Rubriques

 · Accueil
 · A Propos
 · Articles
 · Galeries
 · Glossaire
 · Hit Parade
 · Liens
 · Liste jeux Amiga
 · Quizz
 · Téléchargements
 · Trucs et astuces


Articles

 · Actualité (récente)
 · Actualité (archive)
 · Comparatifs
 · Dossiers
 · Entrevues
 · Matériel (tests)
 · Matériel (bidouilles)
 · Points de vue
 · En pratique
 · Programmation
 · Reportages
 · Tests de jeux
 · Tests de logiciels
 · Tests de compilations
 · Articles divers

 · Articles in english
 · Articles in other languages


Twitter

Suivez-nous sur Twitter




Liens

 · Sites de téléchargements
 · Associations
 · Pages Personnelles
 · Moteurs de recherche
 · Pages de liens
 · Constructeurs matériels
 · Matériel
 · Autres sites de matériel
 · Réparateurs
 · Revendeurs
 · Presse et médias
 · Programmation
 · Développeurs logiciels
 · Logiciels
 · Développeurs de jeux
 · Jeux
 · Autres sites de jeux
 · Scène démo
 · Divers
 · Informatique générale


Jeux Amiga

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


Trucs et astuces

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


Glossaire

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


Partenaires

Annuaire Amiga

Amedia Computer

Relec

Hit Parade


Contact

David Brunet

Courriel

 


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.

C

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 :

int MathBase;

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 :

CloseLibrary(MathBase);

2. Vous devez avertir l'éditeur de lien 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 :

int MathTransBase;

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

C


[Retour en haut] / [Retour aux articles]