Licence PC-EEA Session Travaux Pratiques 1 I.N.U.

Champollion
2ème année

Section 1 :

Initiation au module Numpy

N umpy est un module/bibliothèque Python qui permet à la fois de manipuler des tableaux multidimensionels
mais aussi de faire des calculs sur ces objets. Ces tableaux sont du type array qui est similaire à une liste( list)
avec la condition supplémentaire que tous les éléments sont du même type (entiers ou flottants). Ci-dessous un
code qui permet de convertir une liste en un tableau via la fonction array :
import numpy a s np #np d e v i e n t l ’ a l i a s ou l ’ a b r e g e de numpy
a= np . a r r a y ( [ 1 , 5 , 7 , 8 , 6 , 4 ] )

N.B. Un alias est le deuxième nom d’une variable. Dans ce cas, lorsque la valeur référencée par la variable b est modifiée, il en sera
de même pour la variable a . Pour s’en convaincre, modifier le premier élément de b . Afficher ensuite la valeur de la variable a et
b avec l’instruction print .

Activité 1 : Copier et accéder des éléments d’un tableau array

En gardant la portion de code ci-dessus, identifier l’instruction qui permet :
♠ d’affecter le 3-ième élément du tableau a à la variable b ♠ b=a[:]
♠ de créer un alias b pour le tableau a . ♠ b=a[2]
♠ de créer une copie indépendante du tableau a et l’affecter à la b=np.copy(a[1:4])
variable b .
♠ b=np.copy(a)
♠ de créer une copie indépendante du 2-ième au 4-ième élément de ♠ b=a[1:4]
a et l’affecter à la variable b .
♠ b=a.copy()
1. Les opérations suivantes sont-elles équivalentes ?
(a) a=[1,5,7,8,6,4]*2
(b) a=np.array([1,5,7,8,6,4])*2
2. Que se passera-t-il avec l’opération a=a*2 suite à chaque bloc d’instruction d’avant ?
Question auto-évaluation : Êtes-vous capable d’accéder à n’importe quels éléments d’un tableau array et
créer un autre tableau indépendant à partir de ces éléments ?

Activité 2 : Génération et concaténation des tableaux unidimen-

sionnel à éléments identiques (zeros(), ones(), append())
La fonction zeros(N) de Numpy permet de générer un tableau (de type array ) à éléments nul de dimension
N (Idem pour la fonction ones(N) qui permet de générer un tableau rempli par l’unité.).
1. Générer un vecteur z de dimension 10 dont tous les éléments sont nuls sauf le 4-ième élément avec la
fonction zeros(N) 1 .
2. Générer un vecteur zbis de dimension 20 dont les 10 premiers éléments sont constitués par les éléments
du vecteur z , et les 10 suivant par la valeur 1.
Correction :
import numpy a s np
z=np . z e r o s ( 1 0 )
z [3]=10
z b i s = np . o n e s ( 2 0 )
zbis [0:10]= z

1. En cas de doute sur l’utilisation d’une fonction, taper help(nombibliotheque.nomfonction) sur la console pour obtenir de
l’aide.

1
Licence PC-EEA Session Travaux Pratiques 1 I.N.U. Champollion
2ème année

ou
z b i s = np . append ( z , np . o n e s ( 1 0 ) )

Activité 3 : Génération d’un tableau 1D à échantillonnage constant

Générer par deux méthodes différentes (en employant la fonction arange() puis la fonction linspace()
de Numpy), un vecteur avec tous les éléments suivants :

0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9

Correction :
import numpy a s np
a = np . a r a n g e ( 0 , 1 , 0 . 1 )
b = np . l i n s p a c e ( 0 , 0 . 9 , 1 0 )
#

Question auto-évaluation : Êtes-vous capable de générer un vecteur de 100 éléments variant de −π/2 à π/2
de pas d’incrémentation constant ?

Activité 4 : Génération d’un tableau de nombres pseudo-aléatoires

Numpy possède un sous-module/bibliothèque appelé random qui regroupe toutes les fonctions et opérations
relatives à des distributions aléatoires. Afin d’utiliser la fonction du sous-module/bibliothèque de random, la
syntaxe à utiliser correspond à np.random.[nomfonction()] . La fonction uniform(a,b, N) de la sous-module
random de Numpy permet de générer un tableau de dimension N des nombres pseudo-aléatoires (au sens de la
loi uniforme) pris entre a et b.
1. Générer un tableau Z de 10 éléments de valeurs comprises entre 0 et 0.1. Puis afficher la valeur minimale,
et maximale du tableau à l’aide des fonctions min() et max() de Numpy
2. La normalisation est une méthode de prétraitement de données qui permettent de réduire la compléxité
des données. Ceci a pour but de mieux visualiser les tendences. On dit que les données sont normalisées
par rapport à son amplitude lorque l’ensemble des données ont été divisées par la valeur maximale, et que
le bruit numérique a été éliminé. Normaliser le tableau de l’exercice précédent, c-à-d calculer le tableau
Z
z dont le maximum est égale à 1 et le minimum est égale à 0 tel que z = .
max(Z)
3. Visualiser l’ensemble des fonctions/méthodes disponibles sous la bibliothèque numpy à l’aide de la fonction
native dir()
import numpy a s np
f o r e l in dir ( np ) :
print ( e l )

4. Prenez une des fonctions affichées, puis à l’aide de la fonction native help(), identifier :
— son rôle, et éventuellement le type de variable que renvoie la fonction
— le nombre d’arguments obligatoires pour son fonctionnement, respectivement leur type
— les arguments optionnels.
Correction :
Z = np . random . uni for m ( 0 , 0 . 1 , 1 0 )
print ( ’ V a le ur ␣max␣ e s t ’ , np . min( Z ) )
print ( ’ V a le ur ␣max␣ e s t ’ , np .max( Z ) )
z = Z/np .max( Z )

2
Licence PC-EEA Session Travaux Pratiques 1 I.N.U. Champollion
2ème année

Section 2 :

Exploitation de numpy et matplotlib pour générer et représenter

des données des fonctions usuelles

Numpy permet de « vectoriser », i.e. appliquer une opération à un vecteur/tableau et éviter les boucles. Par
exemple le code suivant multiplie chacun des éléments du tableau a par le nombre π/4 2 et affecte le résultat
de multiplication à un nouveau tableau b .
import numpy a s np
a = np . a r r a y ( [ 1 , 2 , 5 , 7 ] )
b = a ∗np . p i / 4 .

De la même manière, nous pouvons effectuer l’opération suivante c = np.sin(b) pour calculer le sinus de
chacun des éléments de b . La plupart des fonctions mathématiques que vous connaissez sont disponibles sous
numpy (e.g. sin() , cos() , , tan() exp() , arccos() , etc.). Ces fonctions s’appliquent élément par élément
sur les tableaux type array .

Activité 1 : Générer, afficher, sauvegarder, importer des tableaux

de valeurs
Nous souhaitons calculer les valeurs de la fonction sinus

f (x) = sin(x)

pour x prenant les valeurs suivantes :

0 π/4 π/2 3π/4 π
1. Générer un vecteur x qui stocke les cinq valeurs ci-dessus et un vecteur y qui stocke l’image de la
fonction pour chacun des éléments de x .
import m a t p l o t l i b . p y p l o t a s p l
import numpy a s np
#g e n e r a t i o n v e c t e u r x
x = np . l i n s p a c e ( 0 , np . pi , 5 )
#c a l c u l e r l a v a l e u r de de s i n u s pour chaque e l e m e n t de x
y = np . s i n ( x )

2. Afficher sur le console les valeurs de x et y avec la fonction print .

3. Sauvegarder les valeurs de la variable y avec l’instruction np.savetxt(’data.dat’, y, header=’mon
entete ’) ,
4. Verification des données sauvegardées (par exportation) :
(a) Vérifier dans votre répertoire de travail qu’un fichier appelé ’data’ avec toutes les valeurs du tableau
a été générée. Ce fichier est de format ’DAT’ 3 .
(b) Vérifier également le rôle de l’argument header .
5. Utilisation des données externes (par importation) :
(a) Importer les données du fichier ’data.dat’ à partir de l’instruction np.loadtxt(’data.dat’, skiprows=1,
delimiter = ’\t’) et l’affecter à la variable ybis .
(b) Vérifier le rôle respective des arguments skiprows et delimiter . Quels sont les autres arguments
optionnels de la fonction loadtxt() 4 ? Comparer avec la fonction genfromtxt()
6. Tracer les valeurs tablées de y en fonction de celles de x avec les instructions suivantes :
2. La valeur π est une constante accessible par la bibliothèque de numpy.
3. Il est possible de générer un fichier de données en d’autres formats en changeant l’extension du nom de fichier dans l’argument
de savetxt().
4. Utiliser la fonction de base help() de python

3
Licence PC-EEA Session Travaux Pratiques 1 I.N.U. Champollion
2ème année

import m a t p l o t l i b . p y p l o t a s p l #d o i t e t r e p l a c e e j u s t e a p r e s i m p o r t numpy as np
...

p l . p l o t ( x , y , ’−∗ ’ ) #Tracer y en f o n c t i o n de x
p l . show ( ) #a f f i c h e r l a f e n e t r e du t r a c e

Explication : Matplotlib est une bibliothèque Python qui permet de faire toutes sortes de tracés. Pyplot est une
sous-bibliothèque de Matplotlib essentiellement utilisé pour tracer des fonctions. Ci-dessus sont des instructions
de base pour se servir de Matplotlib où nous avons importé la pyplot avec l’alias pl. La fonction plot() permet
de tracer des valeurs tabulées et la fonction show() intervient systématiquement à la fin pour faire apparaître
la fenêtre de tracé. Davantage de précisions sont données dans le mémento distribué sous Moodle Séance 1
(« Tracer-sous-Python » ).
Correction :
import m a t p l o t l i b . p y p l o t a s p l
import numpy a s np
#g e n e r a t i o n v e c t e u r x
x = np . l i n s p a c e ( 0 , np . pi , 5 )
#c a l c u l e r l a v a l e u r de de s i n u s pour chaque e l e m e n t de x
y = np . s i n ( x )
#Tracer y en f o n c t i o n de x
p l . p l o t ( x , y , ’−∗ ’ )
#a f f i c h e r l a f e n e t r e du t r a c e
p l . show ( )

Activité 2 : Tracer des fonctions à une variable

2.1 Représentation graphique usuelle
Nous pouvons être amené à représenter les résultats de calculs sur un graphique. Nous proposons de tracer
deux allures de courbes dont la figure finale doit ressembler à celle dessous :

Suivez successivement ces étapes :

1. En utilisant les fonctions linspace() et cos() de NumPy, tracer la fonction cos(x) sur [0, 10π] 5 , en prenant
au moins 100 points d’échantillonage tous les π.
2. Quelle est l’influence du nombre de points passé à la fonction linspace() ?
3. Grâce à un second appel à la fonction plot() avant l’instruction pl.show() , superposer le graphe de la
fonction exp(−x/10)cos(x).
5. Rappelons que pour tracer une fonction, il faut créer un tableau d’antécédents et un autre tableau de des images de la fonction.
Rappelons qu’une image yi est relié à l’antécédent xi par la fonction f associée telle que yi = f (xi ).

4
Licence PC-EEA Session Travaux Pratiques 1 I.N.U. Champollion
2ème année

4. Toujours avant l’appel à pl.show() , ajouter un titre avec pl.title(’Le titre de votre choix’) et
des noms aux axes avec pl.xlabel(’x’) et pl.ylabel(’y=f(x)’) .
Explication : Pour chacun des appels de fonctions appartenant à pyplot, les opérations sont effectués sur
la même fenêtre figure active tant que la fonction show() n’est pas appelée. En général, la fonction
show() n’est ainsi appelé qu’à la fin du code (Voir mémento « Tracer-sous-Python » pour création de
plusieurs figures).
5. Ajouter un texte d’annotation avec la fonction annotate de pyplot avec l’instruction suivante : pl.annotate(’mon
texte annotation’, xy=(2*np.pi,0.55), xytext=(12, 0.5), fontsize=11, arrowprops=dict(width=1,
facecolor=’black’, shrink=0.02)) .
Explication : La fonction annotate() permet de rajouter une annotation fléchée pour apporter plus de
renseignement sur la fenêtre de figure. Les arguments sont
— xy correspondant à la position de l’annotation
— xytxt à la position du texte
— fontsize à la taille du texte
— arrowprops qui accepte comme arguments un dictionnaire des propriétés de la flèche à utiliser.
6. A l’aide de la fonction legend() et l’argument label de la fonction plot() , ajouter une légende sur chaque
courbe. Celle correspondant à la fonction f (x) est notée ’libre’ et f2 (x) est notée ’amorti’
7. Sauvegarder la figure en ajoutant l’instruction pl.savefig(’expcosfig.png’, dpi=300) avant l’ins-
truction pl.show() .
8. Vous chercherez dans votre répertoire de travail le fichier d’image nommée « expcosfig » sous le format
PNG. Selon la résolution qui vous souhaité, vous pourrez évidemment modifier la valeur de l’argument
dpi (résolution en dot per inch).
Correction :
import m a t p l o t l i b . p y p l o t a s p l
import numpy a s np
#g e n e r a t i o n v e c t e u r x
x = np . l i n s p a c e ( 0 , 10∗ np . pi , 5 0 0 )
#c a l c u l e r l a v a l e u r d e s deux f o n c t i o n s pour chaque e l e m e n t de x
y1 = np . c o s ( x )
y2 = y1 ∗np . exp(−x / 1 0 )

#c r e e r l a f i g u r e 1
pl . f i g u r e (1)
#Tracer y en f o n c t i o n de x
p l . p l o t ( x , y1 , ’− ’ , c o l o r= ’ b ’ , l a b e l= ’ l i b r e ’ )
p l . p l o t ( x , y1 , ’− ’ , c o l o r= ’ g ’ , l a b e l= ’ a m o r t i ’ )
pl . ylabel ( ’ f (x) ’ )
pl . xlabel ( ’x ’ )
p l . t i t l e ( ’ Le␣ t i t r e ␣ de ␣ v o t r e ␣ c h o i x ’ )
p l . a n n o t a t e ( ’mon␣ t e x t e ␣ a n n o t a t i o n ’ , xy=(2∗np . pi , 0 . 5 5 ) , x y t e x t =(12 , 0 . 5 ) , f o n t s i z e =11 ,
a r r o w p r o p s=dict ( width =1, f a c e c o l o r= ’ b l a c k ’ , s h r i n k =0.02) )
#a f f i c h e r l e s l a b e l s
pl . legend ()
#s a u v e g a r d e r l a f i g u r e
p l . s a v e f i g ( ’ e x p c o s f i g . png ’ , d p i =300)
#a f f i c h e r l a f e n e t r e du t r a c e
p l . show ( )

2.2 De la représentation usuelle à la représentation paramétrée

Dans la partie précédente, vous avez dû créer deux vecteurs
— y1 qui stocke l’ensemble des images des éléments de x par la fonction f1 (x) = cos(x) et
— y2 qui stocke l’ensemble des images des éléments de x par la fonction f2 (x) = exp(−x/10)cos(x)
Les allures des courbes ont été représentée en fonction de la variable de reférence x. Chacun des éléments de
x, noté xi avec i = 0, 1, 2.... Les deux grandeurs y1 et y2 sont donc liées par le paramètre de référence x tel
que nous pouvons également chercher à représenter graphiquement cette relation avec la courbe paramétrique.
Pour cela, tracer y2 en fonction de y1 .

5
Licence PC-EEA Session Travaux Pratiques 1 I.N.U. Champollion
2ème année

Attention ! La courbe paramétrique ne peut être tracée que si les deux vecteurs y1 et y2 ont été généré avec
les mêmes éléments (même vecteur de variable paramètre).
Correction :
p l . p l o t ( y1 , y2 }

6
Licence PC-EEA Session Travaux Pratiques 1 I.N.U. Champollion
2ème année

Section 3 :

Devoir maison

Pour chaque exercice suivant, vous devez rendre un fichier de script en format .py.

Activité 1 : Tracer une courbe paramétrique

Matplotlib n’est pas seulement capable de tracer des fonctions de variable réelle mais aussi des courbes
paramétrées. De façon formelle, on peut définir une fonction d’un intervalle I ⊂ ℜ de la forme t 7−→ (x(t), y(t)).
Pour faire simple, nous pouvons penser à la trajectoire d’un point au cours du temps. Décrire cette trajectoire,
c’est se donner à chaque instant t l’abscisse et l’ordonnée du point étudié.

Soit la fonction paramétrique suivante :


 x = exp(−αt) cos(βt)
avec α = 0.25, β = 6
y = exp(−αt) sin(βt)


Référez-vous au mémento distribué sur le plateforme Moodle (« Tracer-sous-Python ») et à l’instruction

help() pour l’usage de la fonction subplot(). Puis, reproduire exactement la figure suivante :

Notons que les tracés correspondent à :

— y(t) (tracé de y en fonction de t) : en haut à gauche
— y(x) (tracé de y en fonction de x) : en haut à droite
— t(x) (tracé de t en fonction de x) : en bas à droite.
Quelle figure correspond à la courbe paramétrée ?
Correction
import numpy a s np
import m a t p l o t l i b . p y p l o t a s p l

def main ( ) :

7
Licence PC-EEA Session Travaux Pratiques 1 I.N.U. Champollion
2ème année

alpha = 0.25
beta = 6 .
n=200
tmin = 0
tmax = 5
#d e f i n i t i o n de l a v a r i a b l e p a r a m e t r i q u e
t = np . l i n s p a c e ( tmin , tmax , n )
#d e f i n i t i o n de l a f o n c t i o n p a r a m e t r i q u e
x = np . exp(− a l p h a ∗ t ) ∗np . c o s ( b e t a ∗ t )
y = np . exp(− a l p h a ∗ t ) ∗np . s i n ( b e t a ∗ t )

pl . f i g u r e (2)
#a c t i v e r l a zone 1 du q u a d r i l l a g e 2∗2
pl . subplot (221)
p l . p l o t ( t , y ) #y en f o n c t i o n de t
#a c t i v e r l a zone 2 du q u a d r i l l a g e 2∗2
pl . subplot (222)
p l . p l o t ( x , y ) #y en f o n c t i o n de x
#a c t i v e r l a zone 4 du q u a d r i l l a g e 2∗2
pl . subplot (224)
p l . p l o t ( x , t ) #t en f o n c t i o n de x

i f __name__==’ ’__main__ ’ ’ :
main ( ) #a p p e l programme p r i n c i p a l main ( )

Activité 2 : Tracer dans un repère polaire (polar())

Nous cherchons à comparer le diagramme de rayonnement de deux antennes différentes dans un repère
polaire à l’aide de la fonction polar() 6 de pyplot.
1. Le premier correspond à une antenne isotrope où ∀θ ∈ [0, 2π], nous avons le diagramme de rayonnement
r1 (θ) = 1
2. Le deuxième correspond à une cordioide tel que ∀θ ∈ [0, 2π], r2 (θ) = 1 + cos(θ − π/4)
Reproduire exactement la figure suivante :

6. au lieu de la fonction plot(). Le syntaxe des deux fonctions sont similiare.

8
Licence PC-EEA Session Travaux Pratiques 1 I.N.U. Champollion
2ème année

Correction :

#d e f i n i t i o n d ’ un d i c t i o n n a i r e de f o n t de t e x t e
titlefont = {
’ family ’ : ’ serif ’ ,
’ color ’ : ’ black ’ ,
’ weight ’ : ’ bold ’ ,
’ size ’ : 16 ,
}

#d e f i n i t i o n de l ’ a n g l e p o l a i r e en r a d i a n s
t h e t a= np . l i n s p a c e ( 0 , 2 ∗ np . pi , 2 0 0 )
#d e f i n i t i o n du rayonnement pour chaque c a s
r 1 = np . o n e s ( np . s i z e ( t h e t a ) )
r 2 = ( 1 + np . c o s ( t h e t a −np . p i / 4 ) )

p l . f i g u r e ( 3 ) #c r e e r une f i g u r e numero 3
p l . p o l a r ( t h e t a , r1 , ’−−r ’ , lw =2 , l a b e l= ’ i s o t r o p e ’ )
p l . p o l a r ( t h e t a , r2 , ’−k ’ , lw =2 , l a b e l= ’ c a r d i o i d e ’ )
p l . t i t l e ( ’ Diagramme␣ de ␣ rayonnement ’ , f o n t d i c t = t i t l e f o n t )
p l . l e g e n d ( l o c =2)
p l . s a v e f i g ( ’ antenne . png ’ , d p i =300)

p l . show ( )

Activité 3 : subplot()
Soit deux équations suivantes :

y1 = cos(2πt1 ) exp(−t1 ) et y2 = cos(2πt2 )

Tracer les courbes associées à chacune des équations dans deux sous-figures exactement de la manière
suivante :

Correction
import numpy a s np
import m a t p l o t l i b . p y p l o t a s p l

9
Licence PC-EEA Session Travaux Pratiques 1 I.N.U. Champollion
2ème année

#d e f i n i t i o n d e s p a r a m e t r e s c o n s t a n t s
n=50
p = np . p i

t 1 = np . l i n s p a c e ( 0 , 5 , n )
t 2 = np . l i n s p a c e ( 0 , 2 , n )
y1 = np . exp(− t 1 ) ∗np . c o s ( 2 ∗ p∗ t 1 )
y2 = np . c o s ( 2 ∗ p∗ t 2 )
pl . f i g u r e (5)
pl . subplot (211)
p l . p l o t ( t1 , y1 , ’−o ’ , c o l o r= ’ y ’ )
p l . y l a b e l ( ’ Damped␣ o s c i l l a t i o n ’ )

pl . subplot (212)
p l . p l o t ( t2 , y2 , ’−d ’ , c o l o r= ’ r ’ )
p l . y l a b e l ( ’ Undamped ’ )

p l . x l a b e l ( ’ ␣ time ␣ ( s ) ’ )
pl . subplot (211)
p l . t i t l e ( ’A␣ t a l e ␣ o f ␣ 2 ␣ s u b p l o t s ’ )
p l . show ( )

10
Licence PC-EEA Session Travaux Pratiques 1 I.N.U. Champollion
2ème année

Section 4 :

Pour aller plus loin... (chez vous)

Activité 1 : Évaluation de surface par Monte Carlo.

La méthode Monte-Carlo désigne une famille de méthodes algorithmiques qui permet de calculer
une valeur numérique approchée en utilisant des procédés aléatoires (càd probabilistes).
Dans cette partie, nous allons approximer la valeur de l’aire d’un cercle avec cette méthode, puis en
déduire la valeur numérique de π.
– Révision boucle for. Exploitation étendue des bibliothèques numpy et matplotlib.

1.1 Estimation de π par la méthode de Monte Carlo

Soit un carré tel que −0, 5 ≤ x ≤ 0, 5 et −0, 5 ≤ y ≤ 0, 5.
1. Écrire une fonction coord_aleatoire renvoyant les coordonnées d’un point i de manière aléatoire xi et yi
avec−0, 5 ≤ xi ≤ 0, 5 et −0, 5 ≤ yi ≤ 0, 5. Nous utiliserons la fonction random du module np.random
(l’usage de l’aide est autorisé help(np.random.random)).
2. Soit un cercle inscrit dans ce carré de rayon r = 0, 5
(a) Écrire une fonction inORout(xi , yi ) prenant en entrée les coordonnées d’un point xi et yi et renvoyant
True si le point est à l’intérieur du cercle, False si il est à l’extérieur.
(b) Écrire une fonction permettant de déterminer le pourcentage de points à l’intérieur
i. pour 30 points
ii. pour 1000 points
iii. pour 100000 points
3. En déduire la valeur de π, sachant que :
— Le rapport entre l’aire d’un cercle de diamètre d et d’un carré de côté d est de :

Scercle πd2 /4 π
= =
Scarre d2 4
— La probabilité qu’un point se trouve dans le cercle tend vers ce rapport.
4. Réaliser le graphique ci-dessous en prenant 1000 points, vert à l’intérieur du cercle rouge sinon, ne pas
se soucier du ratio de la figure.

11
Licence PC-EEA Session Travaux Pratiques 1 I.N.U. Champollion
2ème année

Activité 2 : Tracer une cartographie en 2D

Rappel sur les tracés en 1D
Pour tracer une fonction à une dimension f (x) sous python, rappelons que nous avons besoin de générer
deux tableaux de valeurs :
— un tableau de n valeurs des antécédents xx = [x0 , x1 , x2 , . . . , xi , . . . , xn−2 , xn−1 ] = [xi ], i = 0, 1, 2, . . . , (n−
1)
— un tableau de n valeurs des images zz = [z0 , z1 , z2 , . . . , zi , . . . , zn−2 , zn−1 ] = [zi ], i = 0, 1, 2, . . . , (n − 1)
Chaque image est reliée à un antécédent tel que, zi = f (xi ) :
antécédents : x0 x1 x2 ... xn−2 xn−1
↓ ↓ ↓ ... ↓ ↓
images : z0 z1 z2 ... zn−2 zn−1

Sous python l’instruction pl.plot(xx,zz) trace donc un ensemble de valeurs de z en fonction d’un ensemble
de valeurs de x.
Dans ce cas-ci, chaque image est associée à une seule valeur d’antécédent.

Bases de connaissances pour Tracer en 2D

Pour une fonction bidimensionnelle g(x, y), chaque image est associée à un couple de valeurs d’antécédent.
Exemple :
— le couple (x0 , y0 ) sera associé à l’image z0,0 = g(x0 , y0 )
— le couple (x0 , y1 ) sera associé à l’image z1,0 = g(x0 , y1 )
— le couple (x1 , y1 ) sera associé à l’image z1,1 = g(x1 , y1 )
— le couple (x1 , y0 ) sera associé à l’image z0,1 = g(x1 , y0 )
Remarquons ici que 2 valeurs de x et 2 valeurs de y, nous avons 2 × 2 images possibles.
Généralisons pour m valeurs de x et n valeurs de y, nous aurons n × m images possibles :

x0 x1 x2 ... xj ... xm−2 xm−1

↓ ↓ ↓ ... ↓ ... ↓ ↓
y0 z0,0 z0,1 z0,2 ... z0,j ... z0,m−2 z0,m−1
y1 z1,0 z1,1 z1,2 ... z1,j ... z1,m−2 z1,m−1
y2 z2,0 z2,1 z2,2 ... z2,j ... z2,m−2 z2,m−1
.. .. .. .. .. .. ..
. . . . ... . ... . .
yi zi,0 zi,1 zi,2 ... z i,j ... zi,m−2 zi,m−1
.. .. .. .. .. .. ..
. . . . ... . ... . .
yn−2 zn−2,0 zn−2,1 zn−2,2 ... zn−2,j ... zn−2,m−2 zn−2,m−1
yn−1 zn−1,0 zn−1,1 zn−1,2 ... zn−1,j ... zn−1,m−2 zn−1,m−1

Il s’agit donc d’une matrice d’images ZZ de n lignes et m colonnes (dimension n × m).

Génération de la matrice d’images classique

La première façon classique (à savoir le reproduire) pour générer cette matrice est en utilisant deux boucles
for imbriquées. Succinctement, on procède comme suit :
1. On initialise une matrice ZZ de dimension n × m avec que des « 1 » (ou des « 0 »).
2. On parcours l’ensemble des valeurs de xj et yi pour remplir la matrice ZZ.
Exemple avec la fonction suivante :
g(x) = exp(−(x2 + y 2 ))
avec (x, y) ∈ [−1, 1]2
a = −1
b = 1
m = 50
n = 70
xx = np . l i n s p a c e ( a , b ,m) #e c h a n t i l l o n a g e de x
yy = np . l i n s p a c e ( a , b , n ) #e c h a n t i l l o n a g e de y

12
Licence PC-EEA Session Travaux Pratiques 1 I.N.U. Champollion
2ème année

############################
# P a r t i e g e n e r a t i o n de l a m a t r i c e ZZ
############################
#i n i t i a l i s a t i o n d ’ un t a b l e a u de dimension n∗m
ZZ = np . z e r o s ( ( n ,m) )
f o r i in range ( 0 , n ) : #i n d i c e pour v a l e u r de yy
f o r j in range ( 0 ,m) : #i n d i c e pour v a l e u r s de xx
ZZ [ i , j ] = np . exp(− xx [ j ] ∗ ∗ 2 − yy [ i ] ∗ ∗ 2 )

Génération de la matrice d’images par meshgrid()

La deuxième façon (plus courte) de générer la matrice z est en exploitant le fait que la bibliothèque numpy
effectue des opérations « élément à élément ». C’est-à-dire le produit entre le vecteur (a0 a1 a2 a3 ) et le
vecteur (b0 b1 b2 b3 ) donnera un vecteur de même dimension (a0 b0 a1 b1 a2 b2 a3 b3 )Exemple :
Pour générer la matrice ZZ, l’idée est donc de générer au préalable les matrices XX et Y Y de même
dimension que celle attendue pour ZZ.
Illustration avec un vecteur x de m = 3 éléments et un vecteur y de n = 4 éléments :
— vecteur de x =  (x0 x1 
x2 )
y0
 y1 
— vecteur de y =   y2 


y3
Les matrices à générer sont de dimension 4 × 3 :

XX YY ZZ = g(XX, Y Y )
 ↓   ↓   ↓ 
x0 x1 x2 y0 y0 y0 z0,0 z0,1 z0,2
 x0 x1 x2   y1 y1 y1   z1,0 z1,1 z1,2 

 x0
   →  
x1 x2   y2 y2 y2   z2,0 z2,1 z2,2 
x0 x1 x2 y3 y3 y3 z3,0 z3,1 z3,2

Notons les choses suivantes :

1. Les matrices XX, Y Y et ZZ sont de même dimension.
2. L’élément à la i-ième ligne et j-ième colonne de la matrice ZZ (élement zi,j est l’image obtenue à partir
de l’élément à la i-ième ligne et j-ième colonne des matrices XX et Y Y .
3. Toutes les lignes de la matrice XX sont identiques.
4. Toutes les colonnes de la matrice Y Y sont identiques.
Pour l’exemple précédent, il suffit de remplacer la partie de génération de la matrice ZZ par le bloc d’ins-
truction suivant :
############################
# P a r t i e g e n e r a t i o n de l a m a t r i c e ZZ
############################
XX, YY = np . meshgrid ( xx , yy )
ZZ = np . exp(− XX∗∗2− YY∗∗2 )

Tracer une cartographie de couleur à partir de la matrice d’images ZZ et les matrices d’abscisses
XX et d’ordonnées Y Y

############################
# P a r t i e t r a c e r une c a r t o g r a p h i e en e c h e l l e de c o u l e u r de l a m a t r i c e ZZ
############################
p l . f i g u r e ( )#c r e a t i o n d ’ une f e n e t r e de f i g u r e
p l . c o n t o u r f (XX,YY, ZZ , 2 0 0 , a l p h a= 0 . 7 5 , cmap = p l . cm . hot ) #t r a c e r une c a r t o g r a h i e a v e c
l ’ e c h e l l e de c o u l e u r d e f i n i e dans l a c a r t e de c o u l e u r s p l . cm . h o t
p l . c o l o r b a r ( ) #a f f i c h a g e de l ’ e c h e l l e de c o u l e u r

13
Licence PC-EEA Session Travaux Pratiques 1 I.N.U. Champollion
2ème année

14