TP1, prise en main de Pari/GP et arithmétique

TP1, prise en main de Pari/GP
et arithmétique
Le programme que nous allons utiliser pour les TP se nomme PARI/GP dont le
point fort est la théorie des nombres (au sens large). Il est donc tout à fait adapter
pour les applications que nous avons en vues et nous permettra en particulier de
manipuler de grands nombres entiers et d’effectuer des calculs rapides.
1. Introduction à gp
1.1. En tant que calculatrice. Nous utiliserons essentiellement l’interpréteur
de commandes gp qui permet d’accéder à toutes les commandes avec la simplicité
d’une calculatrice programmable. Ainsi, une fois arriver au prompt ? il est possible
des faire des calculs comme on le ferait habituellement
? (3+10)*50-7^4
%1 = -1751
? 1/40+3*Pi
%2 = 9.449777960769379715387930150
? (4*I+5)^2
%3 = 9 + 40*I
? 40!
%4 = 815915283247897734345611269596115894272000000000
Le résultat de chaque commande peut alors être rappelé en utilisant le numéro
de la commande
? %1
%5 = -1751
? (%1^10-45)/%2
%6 = 2.867080300425034435767949332 E31
Il est aussi possible de stocker des valeurs dans des variables, celles-ci n’ayant pas
besoin d’être déclarée préalablement
? x=4
%7 = 4
? x^4+5*x+3
%8 = 279
Le programme gp possède également une sortie graphique qui peut, en particulier,
être utilisée pour le tracer de fonctions, ce qui est réalisé avec la fonctions ploth
(et aussi avec la fonction plot mais le résultat est alors en mode texte)
? ploth(x=-2, 5, cos(x)*exp(x)*log(abs(x))*x)
Outre les entiers, les réels et les complexes, le programme gp permet d’utiliser
beaucoup d’autres types d’objets comme les matrices, les vecteurs, les listes, les
ensembles, les polynômes, ...
1
2
1.2. Ou pour exécuter des scripts. D’autre part, gp permet d’exécuter des
scripts écris dans n’importe quel éditeur de texte (du moins lorsque la sauvegarde
du fichier s’effectue en texte simple !). Supposant que notre script soit sauvegardé
dans le fichier test.gp, on l’appelle sous gp par la commande
\r test.gp
Sous beaucoup d’aspects, l’exécution à travers un script est très avantageux car il
permet de sauvegarder le travail effectué, de réexécuter une suite de commandes
en faisant varier seulement quelques paramètres sans avoir à tout retaper, ...
Le langage gp comprend les virgules et les points virgules de manière très précises :
- les , servent à séparer les arguments d’une fonction. Pour reprendre l’exemple
du tracé de fonction (? ploth(x=-3, 3, cos(x))), on voit que la fonction
ploth prend trois arguments : x=-3 (précisant quelle est la variable et la borne
gauche de l’intervalle dans lequel x varie), 3 (précissant la borne droite de
l’intervalle) et cos(x) (fonction dépendant de x et qu’on va tracer sur tout
l’intervalle).
- les ; se placent entre les commandes et permettent ainsi de définir des séquences de commandes (que nous abrévierons en seq dans la description des
commandes qui les utilisent), celles-ci n’étant alors pas affichées ! Ainsi, la séquence x=3; y=4; fixe les deux variables x et y à des valeurs précises.
2. Programmation
La programmation en Pari est de type procédurale, et donc très semblable aux
langages C, Pascal, ... Nous nous contenterons donc de donner les grandes lignes
permettant d’écrire du code.
2.1. Les fonctions. Les fonctions se définissent de la manière suivante :
NomDeLaFonction(param1, param2, ...)=
{
\\ Code de la fonction
}
On peut ainsi écrire la fonction
Addition(x, y)=
{
return(x+y);
}
La commande return quitte la fonction et renvoi son paramètre comme résultat.
3
2.2. Les tests. La fonction if est appelée comme une fonction et prend donc
des paramètres.
On peut l’appeler sous la forme if(a, seq1), qui exécutera la séquence seq1 si la
condition a est vérifiée, ou bien sous la forme if(a, seq1, seq2) qui exécutera
seq1 si a est vérifiée et exécutera seq2 sinon.
Ainsi, le calcul du reste de la division de a par b, stockant dans x le résultat si
b 6= 0 et affichant un message d’erreur, tout en fixant x = 0, dans le cas contraire,
s’effectue de la manière suivante
if(b==0,
print("division par zéro"); x=0,
x = a % b)
Les principaux opérateurs de comparaison sont <=, <, >=, >, ==, != et ils
peuvent être combinés à l’aide de || et && donnant, par exemple,
? ((3 <= 4) && (4 < 3)) || (-1 > 0)
%1 = 0
\\ c’est-à-dire FAUX
2.3. Les boucles. Les différentes boucles fonctionnent comme des fonctions, et
prennent donc des paramètres, le dernier étant une séquence qui correspond au
code à exécuter dans la boucle. Ainsi, le code for(x=a, b, seq) exécutera le
code seq pour tous les x=a...b par incrément de 1.
Les principales autres boucles sont
forstep(x=a, b, s, seq)
while(a, seq)
until(a, seq)
\\ comme for, mais l’incrément est s
\\ tant que a est vérifiée
\\ jusqu’à ce que a soit vérifiée
Dans les deux derniers exemples, le terme a est une expression booléenne indiquant une condition (cf. la partie sur les tests).
2.4. Les variables. Il existe deux types de variables pour la programmation en
Pari : les variables locales et les variables globales.
Les variables globales sont celles qui sont vues depuis la console et peuvent être
accédées depuis toutes les fonctions. Il est possible de définir des variables globales
à l’intérieur d’une fonction, il suffit pour cela de lui affecter une valeur, sans avoir
à la prédéfinir, par exemple X=5.
Les variables locales ne sont définies qu’à l’intérieur d’une fonction, et oubliées
dès qu’on en sort. Elles doivent être prédéfinies à l’aide de la commande local.
Ainsi, la ligne
local (a, b, c);
permet de créer des variables locales a, b et c à l’intérieur d’une fonction. S’il
se trouvait que la variable a existe déjà comme variable globale, la fonction travaillera avec sa variable a locale, laissant inchangée la variable globale de même
nom.
4
2.5. Un exemple. À titre d’exemple, voici le calcul du factoriel par deux méthodes, la première récursive, et la deuxième itérative.
FactIter(n)=
{
local (s);
if (n < 0, print("l’argument doit être positif"); return);
if (n==0, return(1));
s=1;
for(i=1, n, s=s*i);
return(s);
}
FactRec(n)=
{
if (n < 0, print("l’argument doit être positif"); return);
if (n==0, return(1));
return(n*FactRec(n-1));
}
2.6. Pour aller plus loin. L’aide en ligne de Pari-GP peut être utile, elle
est appelé par ?function pour avoir une description succincte de function,
et ??function pour avoir une description plus détaillée.
Les “Users’ Guide”, “Tutorial” et “Reference Card” de Pari disponible sur
http://pari.math.u-bordeaux.fr/doc.html peuvent également être d’une aide
précieuse.
3. Exercices
Exercice 3.1. Écrire une fonction Euclide(a, b) renvoyant le pgcd des entiers
a et b.
Exercice 3.2. Écrire une fonction Bezout(a, b) calculant une décomposition
de Bézout au + bv = pgcd(a, b) par l’algorithme d’Euclide étendu et changeant u
si nécessaire pour que 0 ≤ u < b (on montrera au préalable qu’il existe une telle
décomposition et qu’elle est unique).
5
Exercice 3.3. Écrire une fonction Eratosthene(n) renvoyant la liste de tous
les nombres premiers ≤ n (cf. le manuel de Pari pour une description du travail
avec les listes).
On tracera ensuite, à l’aide de la liste obtenue, le graphe de la fonction x 7→
card {p ≤ x, p premier} qui devrait ressembler à
Exercice 3.4. Construire une fonction Factorisation(n) qui calcule une décomposition en facteur premier d’un entier n (on se servira pour cela de la fonction
Eratosthene).