Revenir à IS104 – Algorithmique Numérique

Présentation de Numpy/Scipy

Il existe un certain nombre de versions de Python installées sur les machines de l’ENSEIRB. Les exercices de cette feuille sont basés sur la version 2.7.3. Avant de commencer cette feuille, se référer à la page de configuration pour mettre en place l’environnement de travail.

Remarques : Toutes les zones de code sont copiables à partir du navigateur et de ce fait ne méritent pas d’être recopiées à la main. Le bouton en haut à droite de cette page permet d’agrandir la zone de texte lisible.

Première utilisation de Numpy/Scipy

  1. Créer un répertoire réservé aux TPs d’IS 104 et se placer à l’intérieur.

    Ajouter les lignes suivantes à votre .emacs afin de pouvoir charger le mode python adéquat :

    (setq load-path (cons "/net/autre/LABRI/ramet/backup/.emacs.d/" load-path))
    (load "python-mode")

    Créer un fichier « .py » sous emacs, rempli avec quelques commentaires (commençant par #). Lancer l’interpréteur python avec la commande C-c !, et l’évaluer avec la commande C-c C-c.


    Ajouter la ligne suivante au .emacs permet d’évaluer simplement une région avec C-c C-e.

    (global-set-key (kbd "C-c C-e") 'py-execute-region)
  2. Regarder l’aide sur la syntaxe du langage pour visualiser les constructions du langage python.

    Parcourir l’aide-mémoire afin de se familiariser avec les commandes disponibles.

  3. Aller jeter un coup d’oeil aux feuilles de référence de Numpy et de Scipy. En particulier, utiliser l’interface de recherche pour trouver la documentation d’une fonction connue.

Ecriture d’algorithmes simples

Cette section présente l’écriture d’algorithmes en langage python. Le langage de programmation utilisé a une syntaxe particulière, utilisant les indentations pour définir les blocs de code. La syntaxe des différentes constructions du langage est donnée sur cette page.

  1. Récupérer le fichier power.py dans emacs et l’exécuter dans à l’aide de l’interpréteur python.
  2. Utiliser la fonction power dans l’interpréteur et vérifier son fonctionnement en calculant 2^{32}. Calculer les puissances de 2 successives en utilisant une boucle :
    for i in range(10,20):
        print "2^%d = %d\n" % (i,power(2,i));

    Quelle est la limite maximale des nombres entiers sous python ? Qu’en est-il pour les nombres flottants ? (Indice : remplacer le %d par %f ou %g)

  3. Écrire une fonction fibo qui prend en entrée un nombre n et renvoie le n-ème élément de la suite de Fibonacci définie par :

    • fibo(0) = 0
    • fibo(1) = 1
    • fibo(n+1) = fibo(n)+fibo(n-1)

    La syntaxe d’écriture d’une fonction est décrite ici. Jusqu’à quelles valeurs de n êtes vous capables de calculer fibo(n) en un temps raisonnable (toute réponse inférieure à 100 est inacceptable) ?

Manipulation des vecteurs et matrices

En python, il existe différents types d’objets pour manipuler les tableaux d’éléments. Se référer à la documentation pour comprendre la différence. Dans cette partie, on se limitera aux objets de type array.

  1. Stocker la matrice suivante dans une variable de type array :

    \left[ \begin{array}{ccc} 1 & 2 & 7 \\ 2 & 5 & 9 \\\ 1 & 4 & 6 \end{array}\right]
    Les opérations arithmétiques usuelles, comme l’addition et la multiplication, sont surchargées : elles fonctionnent aussi dans certains cas sur les matrices et les vecteurs. En particulier, essayer d’ajouter un nombre à une matrice, de multiplier une matrice par un nombre, ou d’en prendre son cosinus.
  2. A partir de la matrice précédente, il est possible de construire des tranches (slices) qui sont des morceaux de cette matrice. Ainsi, la notation m[0,:] représente la première ligne de la matrice m

    Construire la deuxième ligne, la dernière ligne, puis la dernière colonne de la matrice précédente (Indice : il est possible d’utiliser des indices négatifs)

  3. Écrire la fonction qui, étant donné n, construit la matrice carrée suivante :

    \left[ \begin{array}{cccc} 1 & 2 & \ldots & n \\ 1 & 2 & \ldots & n \\ \vdots & \vdots & & \vdots \\\ 1 & 2 & \ldots & n \end{array}\right]
    Compter le nombre d’opérations nécessaire pour l’écriture de cette fonction (une opération est ici un appel à une fonction d’une des bibliothèques de python). Arrivez-vous à écrire cette fonction en seulement 3 appels de fonctions ?

Le tutoriel de numpy donne quelques pointeurs pour plus d’informations sur l’utilisation des matrices dans python.

Utilisation des polynômes

Le langage permet de représenter facilement des polynômes à l’aide des fonctions poly et poly1d (cf. ici). Ils sont stockés sous forme de tableaux de coefficients. Il est possible d’évaluer un polynôme en un point en écrivant p(x).

  1. Ecrire le polynôme x et le stocker dans une variable. Elever cette variable au carré, et au cube.

    Encore une fois, les opérations arithmétiques élémentaires sont surchargées. Essayer de multiplier deux polynômes, et calculer la puissance n-ème d’un polynôme. Que calcule t’on lorsque l’on effectue la division de deux polynômes ?


  2. Ecrire une fonction qui prend un polynôme donné, ainsi qu’un intervalle [a;b], et qui cherche une racine de ce polynôme dans cet intervalle par dichotomie.

Tracé de fonctions réelles

Savoir tracer des courbes est très important car c’est le moyen le plus probant de montrer le fonctionnement d’un algorithme.

Une petite explication sur la façon de générer des graphiques avec python est disponible ici.

  1. A l’aide de la commande plot, tracer le graphe des fonctions \sin(x) et \cos(x), sans oublier le titre et la légende :


  2. Utiliser la fonction imshow pour dessiner les valeurs d’une matrice générée aléatoirement. Vous pouvez générer une grande matrice aléatoire en utilisant :
    import numpy as n;
    import matplotlib.pyplot as p
    m = n.random.rand(5,5)
    p.imshow(m, interpolation='nearest')
    p.show()

    Vous pouvez ajouter un peu de couleur à votre graphe en modifiant la carte des couleurs (colormap). Pour cela, regarder la documentation de matplotlib, qui donne une liste des colormaps possibles.

  3. Expliquer les étapes permettant de faire fonctionner l’exemple suivant :
    import numpy as n
    import matplotlib.pyplot as p
    from mpl_toolkits.mplot3d import Axes3D
    from matplotlib import cm
    
    fig = p.figure()
    ax = Axes3D(fig)
    X = n.arange(-5, 5, 0.25)
    Y = n.arange(-5, 5, 0.25)
    X, Y = n.meshgrid(X, Y)
    R = n.sqrt(X**2 + Y**2)
    Z = n.sin(R)
    ax.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap=cm.jet)


Il est possible d’exporter les images générées par python au format « .png » et au format Postscript (« .eps »), ce qui permet de les inclure facilement dans un document généré par Latex.