TP n˚2 - Institut de Mathématiques de Bordeaux

Nicolas Gourmelon Calcul Scientifique et Symbolique avancés
7 février 2014 TP n˚2
Introduction à Sage. Algorithmes élémentaires de tri.
Sage est un logiciel libre de calcul scientifique et symbolique qui réunit sous une seule interface de
nombreux paquets ou bibliothèques (librairies en anglais) de logiciels mathématiques existants : Matlab,
Mathematica, Maple, Magma, Gap, Scilab, R, etc... Au contraire de ces autres logiciels qui ont chacun
un langage de programmation spécifique, les créateurs de Sage ont choisi de s’appuyer sur le langage
de programmation orientée objet Python, lequel est devenu standard et dispose de vastes ressources
documentaires en libre accès. En apprenant Sage, vous vous familiarisez avec Python. Pour ceux qui sont
déjà familiers avec Python, les différences entre Sage et Python sont détaillées dans
http://www.sagemath.org/doc/tutorial/afterword.html#why-python
Je vous recommande de télécharger Sage à l’adresse suivante :
http://www.sagemath.org/
Une version beta de Sage sur le "nuage" est testable depuis peu (creez un compte, puis creez et partagez
vos worksheets) :
https://cloud.sagemath.com/#settings
Le SageMathCloud semble cependant très incomplet pour l’instant. Une introduction à Sage, ainsi que
de nombreux tutoriels sont accessibles sur http://www.sagemath.org. Ceci peut être complémenté par
le tutoriel d’introduction à Python http://docs.python.org/2/tutorial/introduction.html.
Une fois Sage installé et lancé (sous linux, Sage se lance depuis la console), le prompt suivant apparaît :
sage:
On peut alors tester les différentes fonctions de Sage dans la console. Lancez par ailleurs l’environnement
intéractif de Sage en tapant
sage: notebook()
Une fenêtre de votre navigateur par défaut s’ouvre, dans lequel vous pouvez créer des feuilles de travail
(worksheets) et exécuter vos programmes Sage. Le notebook permet en outre d’y insérer du code html,
LaTeX, R, ... et de le compiler. Le jour du TP terminal noté (en août), vous m’enverrez par email votre
feuille de travail.
1 Premiers pas dans Sage
Testez et retestez toutes les commandes suggerées dans la suite.
L’aide s’obtient en entrant la fonction ou la classe, suivie de "?". Exemple : la fonction is_prime teste
la primalité des entiers, et ZZ désigne l’anneau des entiers.
sage: 4==5
sage: 4!=5
sage: 3==3 ; 3!=3
sage: ZZ
sage: 4 in ZZ
sage: 3.5 in ZZ
sage: is_prime(4)
sage: 4?
sage: is_prime?
sage: ZZ?
Les trois dernières commandes donnent l’aide relative aux entiers, à la fonction is_prime et à l’anneau
des entiers, respectivement. Lorsque vous serez plus familier, vous pourrez vous intéresser au code source
(et un jour y contribuer, j’espère).
1

sage: is_prime??
sage: ZZ??
Faire suivre un objet de ?? permet d’obtenir les codes sources des classes, méthodes et fonctions associées.
Testez les opérations suivantes :
sage: h=’Hallo’
sage: h; parent(h)
sage: 5+6 ; parent(5+6)
sage: (3+5)^4-1
sage: 6-4.0
sage: parent(6-4.0)
sage: 6-4.0 in ZZ
sage: 4.5 in ZZ
sage: 4.5 in QQ
Dans dmettre le résultat de la division euclidienne de 23 par 3:
sage: d=divmod(23,3)
sage: d
(7, 2)
sage: parent(d)
<type ’tuple’>
La fonction parent renvoie à un objet son type. Ici, le résultat de la division euclidienne est un uplet
(tuple en anglais), en l’occurence un couple.
Comparer les résultats et les types de
sage: is_prime(2305843009213693951)
sage: 2305843009213693951.isprime()
sage: factor(48937872337898)
sage: 48937872337898.factor()
Une des souplesses permises par Python et Sage est la coercition : des règles de conversion entre différents
types sont exhaustivement définies qui permettent de transformer une variable de tel type en une variable
de tel autre type, lorsque cela est naturel.
sage: ZZ(6-4.0)
sage: 4/3
sage: RR(4/3)
sage: n=RR(sqrt(2))
sage: n, QQ(n)
sage: L=[3,4,21,3948]
sage: parent(L)
sage: T=tuple(L)
sage: parent(T)
sage: T==L
sage: list(T)==L
sage: str(factor(48937872337898))
sage: list(factor(48937872337898))
Que font les deux dernières commandes ?
Au vu de l’identification canonique entre listes et uplets, on peut se demander quel est le sens de cette
distinction. Les listes sont des objets variables, il est possible de les modifier à la volée, d’en supprimer
ou d’en altérer des éléments. Les tuples sont eux des objets immuables, à moins de les redéfinir, comme
le montrent les résultats des commandes suivantes :
sage: L=[3,4,21,3948]
sage: L[0],L[1],L[2],L[3]; T[0],T[1],T[2],T[3]
#les éléments de la liste et du tuple sont indexés de 0 à 3.
2

sage: L[:0],L[:1],L[:2]; T[:2],T[:3],T[1:3]
sage: L[3]=32
sage: L
sage: T[3]=43
sage: L[:3]=[4,5,6,7]
sage: L.append(’bonjour’)
sage: L
sage: L+[49,8,[],68]
sage: T=(4,5,4,3) + (33,’rouge’,2) ; T
sage: ’l operateur + ’ + ’permet d’ + ’e tout concatener, \
....: m’ + ’eme les chaines de caracteres’
Sage permet d’écrire des codes très élégants et proches du langage mathématique. La définition de listes
est particulièrement simple :
sage: L=range(10); L
sage: [2*i for i in L]
sage: S=[i for i in range(1000) if 67.divides(i^2-1)]
#entiers i entre 0 et 999 tels que 67 divise i^2-1
sage: L=range(100)
sage: L=[(i,j) for i in L for j in L if 0<i-j<30 and 3.divides(i^2-j^2)]
#liste des couples (i,j) d’entiers entre 0 et 99 tels que 0<i-j<30 et...
2 Programmation dans Sage
Bases de la programmation en Sage (et Python).
2.1 Clauses
Le if... then... fi de Maple devient
sage: if condition_booléenne1:
....: conséquence1
....: conséquence2
....: conséquence3
....: elif condition_booléenne2:
....: conséquence4
....: conséquence5
....: else:
....: conséquence6
....: conséquence5
....:
Alors que sous Maple, le bloc de code conséquence est ponctué par fi, cette ponctuation est donnée sous
Sage par la fin de l’indentation. L’indentation a une valeur grammaticale dans Sage.
Dans la suite, on oublie les prompts sage:.
m=3;n=99
if m.divides(n):
print str(m)+’ divise ’+str(n)
else:
print str(n)+’ est peut-etre premier’
2.2 boucles
Les boucles peuvent se construire de 2 manières.
Boucles while :
L=[]
while len(L)<=10: #on commente les programmes
L=L+[0,1] #de cette façon
print L
3

Boucles for :
L=[]
for i in [0..5]:
L=L+[0,1]
print L
Les éléments de la liste d’indices peuvent être de n’importe quelle nature, ce qui permet une écriture
concise :
L=[’ la tete’, ’ le bec’, ’ les yeux’, ’ le cou’, ’ les ailes’]
J=’Je te plumerai’;A=’Alouette’;
for i in L:
print A+’, gentille ’+A.lower()+’,’
print A+’, ’+J.lower()+’.’
print
print J+i+’.’
for j in reversed(L[:L.index(i)]): #’reversed’ renverse la liste
print ’et’+j+’ !’
print A+’ !’
print
2.3 Définition de fonctions
Les fonctions se définissent très simplement en Sage. Voici par exemple la définition d’une fonction
euclide qui à aet brenvoie le ppcm de aet b:
def euclide(a,b):
r = a%b #reste de la division euclidienne de a par b
while r != 0:
a=b; b=r
r = a%b
return b
euclide(45,81)
3 Exercices : Comparaison d’algorithmes de Tri
Exercice 1 :
1. Ecrire une fonction qui à un argument associe True si cet argument est une liste d’entiers, et False
sinon. Tester cette fonction sur quelques listes.
2. Ecrire une fonction qui à nassocie une liste aléatoire de nentiers compris entre 1et 1000. On pourra
consulter l’aide de randint.
Exercice 2 :
1. Ecrire en sage une fonction effectuant le tri rapide d’une liste, en prenant pour pivot la tête de liste.
En consultant l’aide de la fonction timeit, déterminer le temps de calcul nécessaire.
2. En procédant à un échantillonnage, estimer expérimentalement la moyenne et l’écart-type (standard
deviation en anglais) du temps d’exécution du tri rapide pour une liste de 1000 entiers aléatoirement
choisis entre 1et 1000.Indication : en répètant un tel tri un certain nombre de fois, on obtient une liste
aléatoire de temps d’exécution. On appliquera à cette liste les fonctions sum, std.
Attention : le coût du tri doit exclure le coût de création des listes aléatoires ! Ceci vaut
également pour les exercices qui suivent.
Exercice 3 :
4

1. Ecrire en sage une fonction effectuant le tri fusion d’une liste.
2. Estimer expérimentalement la moyenne et l’écart-type du temps d’exécution du tri rapide pour une
liste de 1000 entiers aléatoirement choisis entre 1et 1000.
Exercice 4 :
Représentations graphiques. Que fait le programme suivant ?
L=[0]
for i in [0..1000]:
L.append(L[i]+randint(-1,1))
line(zip(range(1000),L))
D’autres fonctions graphiques de Sage sont accessibles par sage.plot.plot
Exercice 5 :
1. Soient R(n)et F(n)les coûts moyens du tri rapide et du tri Fusion d’une liste de nentiers entre 1et
1000 aléatoirement engendrée. Donner une représentation graphique expérimentale des fonctions
n7→ R(n)
nln n, n 7→ F(n) nln n,
pour nentre 0et 1000. Que peut-on en conclure ? Comparer ces temps d’execution avec ceux de l’algo-
rithme de tri sorted() de Sage.
On adaptera le pas de la représentation graphique de manière à avoir des temps de calcul raisonnables, et on
pourra utiliser les fonctions line, zip vues dans l’exercice 4.
Exercice 6 :
1. Ecrire une fonction effectuant le tri à bulles.
2. Ecrire un algorithme qui "perturbe" la liste [1,2..., n]de la façon suivante : il renvoie des listes aléatoires
de la forme
[1 + X1,2 + X2, ..., n +Xn],
où (Xi)est une suite de variables aléatoires indépendantes identiquement distribuées suivant la loi uni-
forme sur [0,ln(n)].
3. Comparer les coûts moyens du tri à bulles et du tri rapide sur de telles listes. On procédera comme
dans l’exercice précédent.
5