TP ALGORITHMIQUE EN SAGE 1. Complexité et tris Exercice 1. On

M1
TP ALGORITHMIQUE EN SAGE
CHRISTOPHE RITZENTHALER
1. Complexité et tris
Exercice 1. On propose le programme SAGE suivant de recherche d’un maximal dans
une liste d’entiers.
def plus_grand_element(liste):
resultat = liste[0]
for i in range(1, len(liste)):
if liste[i] > resultat:
resultat = liste[i]
return resultat
(1) Implémenter le.
(2) À l’aide des fonctions ZZ.random_element(), créer des listes aléatoires de longueur
croissante et donner le temps pour le calcul de la fonction avec cputime().
(3) Automatiser la procédure précédente et tracer le graphe du temps dans le pire des
cas (en prenant le maximum pour 5 tirages à longueur donnée) pour des longueurs
entre 104et 106(avec un pas de 104). On pourra avoir besoin de list_plot() et
de stocker des éléments dans une liste avec la fonction append.
(4) Qu’en pensez-vous ?
Exercice 2. (1) Implémenter le tri rapide avec l’implémentation ci-dessous
def quicksort(aList):
theList = aList
if len(theList)==1:
return theList
else:
early = []
late = []
pivot=floor(random()*len(theList))
pivotValue=theList[pivot]
del theList[pivot]
for j in [0..len(theList)-1]:
if theList[j]<pivotValue:
early.append(theList[j])
else:
late.append(theList[j])
if len(early)>=1:
sortEarly = quicksort(early)
else:
sortEarly = []
if len(late)>=1:
sortLate = quicksort(late)
1

else:
sortLate = []
sortEarly.append(pivotValue)
for j in [0..len(sortLate)-1]:
sortEarly.append(sortLate[j])
return sortEarly
(2) Comparer le temps de cette méthode avec l’implémentation où le pivot est choisi
à la dernière place (le dernier élément d’une liste a l’indice −1). On fera les tests
sur des listes aléatoires puis sur des listes triées de longueur 100 à1000 avec un
pas de 10. Pour afficher deux graphes p1 et p2 superposés, on utilisera la fonction
show(p1+p2).
Exercice 3. (1) Implémenter le tri par sélection et par insertion.
(2) Comparer les temps de ces méthodes sur des listes de longueur croissante avec le
temps du tri rapide. On pourra automatiser les tests comme précédemment.
2

2. Graphes
Sage possède des fonctions pour gérer les graphes, comme suit
•Initialiser un graphe orienté (resp. non orienté) vide avec le constructeur DiGraph()
(resp. Graph()).
•Ajouter les sommets avec la commande add_vertex ou add_vertices
•Ajouter les arcs (resp. arêtes) avec la commande add_edge ou add_edges.
Pour connaitre les fonctions implémentés sur les graphes, il suffit d’entrer le nom d’une
instance de graphe (par exemple ici on a initialisé G=Graph()), suivi du point ’.’ et faire
tab pour que s’affiche la liste des 257 fonctions prédéfinies dans la librairie. Par exemple
la fonction G.topological_sort() retourne une liste topologique si le graphe est sans
circuit.
Exercice 4. On rappelle que la matrice d’incidence d’un graphe orienté G= (S, A)est
la matrice ∆tel que δxa = 1 si xest l’origine de l’arc a,−1si xest l’extrémité de l’arc a
et 0sinon.
(1) Construire et afficher le graphe du TD donné par la matrice d’adjacence
0100010
0011000
0000000
0000100
0000001
0100101
0010000
On souhaite automatiser le passage de la matrice d’adjacence à la matrice d’incidence.
(2) Comment lit-on le nombre d’arêtes sur la matrice d’adjacence ?
(3) Donner un algorithme qui calcule la matrice d’adjacence à partir de la matrice
d’incidence. Quel est son coût ?
(4) Donner un algorithme qui calcule la matrice d’incidence à partir de la matrice
d’adjacence. Quel est son coût ?
On pourra utiliser les fonctions G.adjacency_matrix() ou G.incidence_matrix() déjà
implémentées pour obtenir des exemples à partir d’un graphe aléatoire donné par la
fonction digraphs.RandomDirectedGNM(10,20) (ici à 10 sommets et 20 arcs). On aura
besoin des fonctions Matrix(n,n),nrows(),augment() et delete_columns().
(5) On cherche maintenant à passer du graphe à la matrice d’adjacence. On utilisera
pour cela les fonctions neighbors_out(),stack() et delete_rows().
Soit nle nombre de sommets de G.
(6) Montrer que pour tout 1≤k≤n, le coefficient (i,j), noté mk
ij , de la matrice Mk
est égal au nombre de chemins de longueur kdu sommet iau sommet j.
(7) Essayer sur un exemple. Comparer avec la fonction adjacency_matrix().
Exercice 5. Implémenter les algorithmes de Roy-Warshall et Floyd.
Exercice 6. Quelle est la taille du plus grand sous-ensemble S⊂ {1,...,100}qui ne
contient pas i, j tel que |i−j|soit un carré parfait ? Une fois le problème modélisé par un
graphe, on pourra utiliser la fonction independent_set() qui retourne un sous-ensemble
maximum d’éléments deux à deux non adjacents.
3

3. Multiplication rapide
Exercice 7. Implémenter la méthode de Karatsuba.
Exercice 8. On cherche à implémenter l’algorithme de la FFT. Notre exemple test sera
les polynômes
F=x4+ 3x3+ 2x2+ 6x+ 7, G =x2+ 2x+ 6
sur F17 (pourquoi ce corps ?). Pour trouver une racine n-ième de l’unité, on pourra
commencer par chercher un élément primitif avec primitive_element().
(1) Commencer par implémenter la procédure d’évaluation.
(2) Implémenter l’algorithme complet avec un choix de racine n-ième.
(3) Pour deux polynômes de degré quelconque sur un corps fini k, écrire un programme
pour faire la FFT de ces deux polynômes. On pourra avoir besoin des fonctions
parent(),
(4) Comparer la multiplication usuelle, Karatsuba et la FFT sur F29·257 +1 pour des
degrés croissants.
4. Séries formellles, division euclidienne
Exercice 9. Implémenter l’algorithme de calcul de la division euclidienne pour les polynômes
basé sur l’inversion des séries formelles. On utilisera PowerSeriesRing(QQ) pour définir
les séries formelles. L’opération de troncature est truncate().
Exercice 10. Soit Fune série formelle de terme constant nul. Écrire un programme qui
calcule log(1 + F)en utilisant l’expression
log(1 + F) = ZF0
1 + F.
Exercice 11. Soient a>bdeux entiers pour lesquels on veut effectuer la division eucli-
dienne. On propose l’algorithme ci-dessous. Soit nle plus petit entier tel que 2nb > a.
B:= b;
R:= a;
Q:= 0;
N:= n;
Aux := 2NB;
while N > 0do
Aux := Aux/2;
N:= N−1;
if R < Aux then
Q:= 2 ∗Q;
else
Q:= 2Q+ 1;
R:= R−Aux;
end if;
end while;
(1) Vérifier qu’à chaque étape on a a=Aux ·Q+Ret 0≤R < Aux et que si N= 0
on a Aux =B.
(2) Donner la complexité de l’algorithme.
(3) Écrire le programme correspondant en SAGE.
4

5. Évaluation, évaluation multi-points, interpolation
Exercice 12. Dans la méthode de pré-processing pour l’évaluation d’un polynôme de
degré 4
a4x4+a3x3+a2x2+a1x+a0
=a4((x(x+α0) + α1)(x(x+α0) + x+α2) + α3)(1)
=a4x4+a4(2α0+ 1)x3+a4(α1+α2+α0(α0+ 1))x2
+a4((α1+α2)α0+α1)x+a4(α1α2+α3).
trouver les αien fonction des coefficients ai.
Exercice 13. Implémenter l’interpolation de Lagrange. On ne cherchera pas à optimer
le calcul des Ai.
Exercice 14. Implémenter l’évaluation multi-points rapide ainsi que l’interpolation rapide.
On pourra créer la structure arborescente de la manière suivante
class Tree(object):
def __init__(self):
self.left = None
self.right = None
self.data = None
Puis pour créer un arbre binaire Ade racine un polynôme Pet de sous-arbre gauche
(resp. droit) A0(resp. A1), on écrit
A = Tree()
A.data = P
A.left = A0
A.right = A1
Exercice 15. On considère la fonction f(x) = 1
1+25x2. On cherche à interpoler cette
fonction aux points a0=−1, a1=−1 + h, . . . , ai+1 =ai+h, . . . , 1avec h= 2/n et
n= 2s−1. Dessiner pour plusieurs valeurs de sle polynôme de Lagrange obtenu et
comparer le dessin à celui de f. Qu’observe-t-on ?
6. PGCD - Résultant - Factorisation
Exercice 16. Écrire un algorithme qui étant données des listes (m1, . . . , mr)d’entiers
premiers entre eux deux à deux et une liste d’entiers (a1, . . . , ar)renvoie une solution x
au système
x≡a1(mod m1)
.
.
.
x≡ar(mod mr)
Exercice 17. (1) Trouver les points d’intersection des ellipses d’équations P= 0 et
Q= 0 avec P=X2−XY +Y2−1et Q= 2X2+Y2−Y−2. Tracer les courbes.
La fonction pour le résultant est P.resultant(Q,X).
(2) Même exercice dans le cas P=XY −1et Q=XY .
(3) Fabriquer l’équation implicite de la courbe paramétrée par x=t2+t+ 1,y=
(t2−1)/(t2+ 1).
Exercice 18. Calculer le polynôme minimal de √2 + √3et de √2·√3. Conclusion.
Soit P(X) = X4+X+ 1 = Q(X−αi). Calculer le polynôme Q(X−α5
i).
5