Introduction à MPIR

En C, sans en-tête, pas de répit. On commence donc par inclure l'en-tête C de MPIR. Si des fonctionnalités basées sur des fichiers sont requises, il faut inclure stdio.h avant l'en-tête de MPIR ; pour des prototypes avec paramètres va_list, stdarg.h ou varargs.h ; pour des fonctions avec des paramètres struct obstack, obstack.h. Pour bénéficier de toutes les fonctionnalités, on fera donc :

#include <stdio.h>
#include <stdarg.h>
#include <varargs.h>
#include <mpir.h>

Cependant, ces fonctionnalités ne seront pas abordées dans ce tutoriel, cette simple inclusion suffira largement :

#include <mpir.h>

Pour que la compilation se passe ensuite sans souci, il faut encore préciser les bibliothèques à lier (dynamiquement ou statiquement) en ligne de commande. Pour GCC, cela donne :

gcc myprogram.c -lmpir

Le même genre d'options sont disponibles pour les autres suites d'outils de compilation, leur documentation reste une référence à ce sujet.

MPIR est concentré autour de trois types de base :

• mpz_t : un entier signé ;
• mpq_t : un rationnel (quotient de deux entiers) ; (2)
• mpf_t : un nombre en virgule flottante (mantisse de précision arbitraire mais exposant de précision limitée).

À chaque fois, on ne garde qu'un pointeur sur les objets avec les champs requis par MPIR. Ces objets sont au final assez légers : les tailles et les pointeurs sur les espaces alloués pour les données. L'allocation de mémoire est gérée automatiquement : dès que plus d'espace est requis, il est alloué automatiquement.

mpz_t et mpq_t ne peuvent que grandir en mémoire pour éviter de fréquentes réallocations (3) ; a contrario, mpf_t utilise une quantité d'espace prédéfinie par la précision désirée, la taille d'une telle variable ne variera donc pas.

On peut remarquer quelques points communs : tous les types correspondent au masque mp?_t. t signifie qu'il s'agit d'un type ; le préfixe mp? indique le type de nombres géré. Ainsi, on retrouvera ce même préfixe pour les fonctions qui gèrent ces types : mpz_add, par exemple, additionne deux entiers.

Revenons sur cette fonction d'addition : quels sont ses paramètres ? Elle prend trois opérandes de type mpz_t : le résultat et les deux opérandes de l'addition. Dans MPIR, les fonctions ont toujours cet ordre de paramètres : d'abord les sorties, puis les entrées, par analogie avec l'opérateur d'assignation. Les opérandes d'entrée sont généralement définies const : elles ne seront en aucun cas modifiées. Il est donc facilement possible pour une fonction de retourner plusieurs variables. On remarquera que cela laisse le retour de la fonction (par l'instruction return) pour, par exemple, vérifier qu'une opération s'est bien déroulée.

Toute variable d'un type déjà cité doit être initialisée avant toute utilisation ; on utilisera la famille de fonctions mp?_init pour ce faire. Une fois initialisée, une variable peut recevoir une valeur autant de fois que nécessaire (être assignée).

Aussi, il n'est pas possible de donner une valeur à une variable de type MPIR à l'aide du simple opérateur =, cela n'étant possible que pour les types de base (la surcharge des opérateurs n'existant pas en C).

Le couple d'opérations initialisation-assignation étant très fréquent, des fonctions permettent de combiner les deux opérations : cela permet de gagner un peu de temps à l'exécution (chaque appel de fonction étant une perte de temps potentielle ; de plus, il est possible d'optimiser encore plus ces opérations).

On commence toujours par définir une variable :

mpz_t i;

Ensuite, on doit l'initialiser (la valeur par défaut est 0) :

mpz_init(i);

On peut, si l'on a une estimation de la taille requise pour cette variable, la définir à l'initialisation, ce qui aura pour effet d'éviter de coûteuses réallocations :

mpz_init2(i, 15684);

On ne définit ici qu'une taille initiale de la variable, elle continuera à grandir avec les besoins.

La gestion mémoire a toujours été importance en C, il est donc possible (et plus que chaudement recommandé) de libérer la mémoire allouée :

mpz_clear(i);

Diverses méthodes d'affectation sont possibles : on peut copier un entier déjà affecté ou bien utiliser un nombre dans un type standard du C, on peut également utiliser une chaîne (un tableau de char, la fin de la chaîne est indiquée par \0), auquel cas on peut spécifier la base de l'entrée (de deux à trente-six sans distinction entre majuscules et minuscules, les lettres étant utilisées comme chiffres ; entre trente-sept et soixante-deux, les majuscules représentent les chiffres entre dix et trente-cinq tandis que les minuscules terminent la ronde entre trente-six et soixante-et-un).

Ces fonctions ont un prototype semblable à void mpz_set*(mpz_t rop, type op) : une sortie et une entrée, le contenu de op est mis dans rop.

Pour des chaînes, on peut utiliser int mpz_set_str(mpz_t rop, char * str, int base) (les espaces blancs sont ignorés), qui retourne 0 si la chaîne est un nombre valide dans la base donnée, -1 sinon.

On peut aussi échanger les valeurs de deux variables de manière efficace avec void mpz_swap(mpz_t rop1, mpz_t rop2).

On ajoute simplement le mot-clé init dans les fonctions d'affectation ; il est inutile de définir la taille voulue, étant donné qu'elle est déterminée avec l'opérande d'entrée. Exemple complet :

#include <mpir.h>

int main(void)
{
	mpz_t i; 
	
	mpz_init_set_ui(i, (unsigned long int) 42);
	
	mpq_clear(i);
	
	return 0;
}

Pour transmettre un résultat, il n'est pas toujours aisé d'utiliser un type de MPIR, il est donc possible de revenir aux types standard du C : exception, un seuleopérande (la variable à convertir), la sortie se fait par return (plus pratique si l'on doit, par exemple, afficher le résultat par printf()).

La bibliothèque est cohérente : on peut reprendre le tableau précédent pour les types, il suffit de changer le radical utilisé par mpz_get.

Il faut cependant faire attention lors de la conversion : MPIR est parfois amené à effectuer des opérations sur des nombres extrêmement grands, potentiellement impossibles à représenter dans les types standard du C. En fonction des cas, le signe est ignoré (type de destination unsigned) ou bien seuls les bits de poids faible (autant que possible) sont renvoyés.

Heureusement, on dispose de la fonction mpz_fits_slong_p() : elle permet de déterminer si la variable peut être convertie sans perte en signed long int.

Il faut aussi noter la fonction mpz_sizeinbase (op, base), qui permet de déterminer la taille requise pour afficher le nombre dans la base donnée. Avec deux octets supplémentaires (pour le signe et \0), cela donne la taille maximale d'une chaîne de caractères représentant le nombre ; on obtient cette chaîne de caractères avec la fonction char * mpz_get_str (char * str, int base, mpz_t op). Le paramètre char * str n'est pas très naturel : s'il est NULL, alors MPIR allouera la mémoire nécessaire pour afficher le nombre ; sinon, il utilisera ce pointeur pour commencer à stocker la représentation du nombre.

La partie la plus intéressante : on peut effectuer des opérations arithmétiques avec MPIR ! Vu leur extrême complexité, elles sont présentées dans un tableau, avec la correspondance en termes d'opérateurs C. D'autres versions sont disponibles et documentées dans le manuel (on peut, par exemple, remplacer certains opérandes par des types de base du C, sans besoin d'utiliser les types de MPIR).

Les fonctions de division sont, quant à elles, beaucoup plus variées : on peut toujours arrondir vers le haut, le bas ou tronquer le résultat, notamment. Elles sont suffisamment abondantes pour qu'il soit inutile de les lister ici. De même pour l'extraction des racines, la détection des nombres premiers probables, le PGCD, le PPCM, la factorielle et bien d'autres. De plus, ces fonctions n'intéresseront pas forcément tous les publics tout en étant correctement documentées. Pour information : il existe aussi des fonctions pour comparer, inverser, calculer les symboles de Jacobi ou de Legendre, calculer un terme de la suite de Fibonacci, effectuer des opérations logiques et binaires, lire ou écrire le résultat dans un fichier, générer des nombres aléatoires.