Introduction à Pari/GP¶

Pari/GP est un logiciel de calcul prévu pour la théorie des nombres. Il contient énormément de fonctions pour effectuer les opérations de base en arithmétique, sur des courbes elliptiques, des fonctions L.

Le programme s’installe assez facilement sous windows, linux ou osX. Cette page repose sur un port javascript qui vous permet d’exécuter les commandes dans votre navigateur.

Principes¶

Pari/GP est une super calculatrice : on entre directement les opérations que l’on veut faire, le système étant assez sympa pour donner le plus grand sens possible aux opérations.

Le complexe \(i\) se note I, les flottants avec un ., toute lettre non définie peut servir d’indéterminée.

exp(I*Pi)

x^3+2*x+1

On construit les éléments d’un quotient en écrivant Mod(,)

a = Mod(2, 7)

On a toutes les opérations arithmétiques usuelles : +, -, *, /, ^, % pour le reste et \ pour la division entière.

a^5

2^5 % 7

a = 'a \\ on réinitialise a comme variable
i = Mod(x, x^2+1)
(a+i*b)*(c+i*d)

Il y a plein de fonctions à découvrir en tapant ? pour accéder à l’aide, ou en commençant un mot et en tapant tabulation pour compléter : les fonctions commençant par pol concernent les polynômes, par vec pour les vecteurs (tableaux), par mat pour les matrices.

Pour la programmation, la syntaxe est proche du C, excepté que tout est écrit sous forme de fonction, le code à exécuter étant fourni dans les différents arguments.

Par exemple, une alternative if ( ) then { } else { } s’écrit

n = 5;
n = if(n % 2, 3*n+1, n/2)

Outre les classiques for(k=1,10,...) et while(i<10,...), il y a plein d’itérateurs : sum, prod, forprime, fordiv…

Par exemple, pour trouver tous les premiers nombres premiers de Sophie Germain :

forprime(p=2,1000,if(isprime(2*p+1),print1(p, " ")))

Langage¶

Types de base¶

entiers, flottants
```
a = 7
```
```
b = 3.141592
```
Rationnels, entiers modulaires
```
3/4
```
```
Mod(7,26)
```
Polynômes
```
x^7+x^2+1
```

vecteurs¶

c’est un tableau d’éléments quelconques, indicés à partir de 1.
```
l = [ 1, x^2-x-1, 0.2 ]
#l \\ longueur
```
affectation
```
l[2] = 2/3
l
```
création
```
vector(10)
```
```
vector(10,k,k^2)
```
```
[1..5]
```
concaténation
```
l = concat(l, [2,3,4])
```
opérations par compréhension
```
l = [1..9]
```
```
l = [ k^2 | k <- l ]
```
on peut rajouter des conditions pour ne garder que certains éléments
```
l = [ k | k <- l, k % 2 == 1 ]
```

Opérations¶

Les opérateurs usuels :

arithmétiques : +, -, *, /, ^, % pour le reste et \ pour la division entière

Les i++ et i--, i+=2, etc. du langage C sont valides.
comparaisons : ==, <=, >=, !=, <, >
opérateurs logiques : &&, ||

Note

principe fondamental

De manière générale, les opérations sont autorisées sur des objets dès qu’elles ont une signification naturelle bien définie.

On peut en particulier écrire

[1, 3, 7, 9] + [3, 1, 4, 3]

Mod([5, 8], 15)

11/17 % 5

sqrt(Mod(-1,17))

fonctions disponibles¶

Il existe beaucoup de fonctions pour travailler sur les entiers, les polynômes (pol...), les matrices (préfixe mat), les corps de nombres (nf...), les courbes elliptiques (ell...)…

ellcard(ellinit([3,5]),11) \\ # E : y^2=x^3+3x+5 sur F11

Programmation¶

boucles¶

boucle tant que
```
n = 7; while(n>0, print(n); n-=1)
```
itération simple
```
for(n=2,9, print(n^2) )
```

d’autres itérateurs existent, par exemple

forstep(k=1,30,5,print(k))

forprime(p=8,40,print(p))

forvec(v=[[1,2],[5,7],[0,1]],print(v))

forpart(p=7,print(Vec(p)))

tests¶

n = 4
if(issquare(n), n++)

n = if(n % 2, 3*n+1, n/2 )

fonctions¶

f(x) = x^2+1;

Les fonctions peuvent être récursives. Pour faire une définition sur plusieurs lignes, il est nécessaire de mettre des accolades

g(a,b) = {
  if ( b == 0,
    a,
    g( b, a % b )
    );
}