2016

PC*

Le module numpy

I. Pour commencer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
I.1 Pourquoi un cours sur numpy ? . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
I.2 Comment charger le module numpy ? . . . . . . . . . . . . . . . . . . . . . . . . 2
II. Les tableaux numpy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
II.1 Création avec np.array . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
II.2 Création avec des fonctions spéciales . . . . . . . . . . . . . . . . . . . . . . . . 3
II.3 Attributs d’un tableau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
II.4 Lecture dans un tableau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
II.5 Écriture dans un tableau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
II.6 À propos des copies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
III. Opérations sur les tableaux numpy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
III.1 Les opérations se font terme à terme . . . . . . . . . . . . . . . . . . . . . . . . 8
III.2 Les fonctions universelles s’appliquent terme à terme . . . . . . . . . . . . . . . 8
III.3 Quelques méthodes sur les tableaux . . . . . . . . . . . . . . . . . . . . . . . . 9
III.4 Opérations d’algèbre linéaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
III.5 Manipulation de polynômes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

A Les aide-mémoires Centrale-Supélec 13

B L’aide-mémoire Arts et Métiers Paristech 27

2015-2016 1/30
 2016
PC* Python 1 Le module numpy

I. Pour commencer
I.1 Pourquoi un cours sur numpy ?

Le calcul scientifique Il nécessite la manipulation de données en quantité souvent importante. Le

module numpy offre la possibilité de faire du calcul de façon très efficace, reposant sur trois principes :
• Les données sont stockées sous la forme de tableaux numpy, de type ndarray ;
• On utilise au maximum la manipulation de ces tableaux en évitant d’en faire des copies ;
• On évite si possible le recours aux boucles, préférant l’utilisation de fonctions vectorialisées.
Les contraintes liées à cette volonté d’optimisations sont que les tableaux numpy sont constitués d’élé-
ments qui sont tous du même type (en général np.float ou np.int64), et que la taille des tableaux
est fixée à la création. On ne peut donc pas augmenter ou diminuer la taille d’un tableau numpy comme
on le ferait pour une liste.

L’oral de math 2 à Centrale-Supélec Pour cette épreuve mixte, l’outil informatique est utilisé pour
résoudre un exercice mathématique. C’est très naturellement que les bibliothèques scientifiques (numpy,
matplotlib, scipy) et leurs sous-modules (matplotlib.pyplot, numpy.polynomial, numpy.alg,
scipy.integrate etc.) sont utilisées. Sont annexées à ce cours les fiches fournies par le service concours
Centrale-Supélec.

I.2 Comment charger le module numpy ?

On charge traditionnellement l’ensemble du module numpy en le renommant np :

import numpy as np

Pour ne pas surcharger l’espace des noms et risquer la présence d’homonymes, on ne charge pas un
module par l’instruction from module import *.

II. Les tableaux numpy

II.1 Création avec np.array

On définit souvent un tableau numpy à partir d’une liste, en utilisant la fonction array du mo-
dule numpy, nommée np.array :
a = np.array( [1, 2, 3] )
# [1 2 3]
b = np.array( [[1, 2, 3],
[2, 3, 4],
[0, 1, 0]])
# [[1 2 3]
# [2 3 4]
# [0 1 0]]

Mais ce ne sont pas des listes :
print(type(a))
# <class 'numpy.ndarray'>
print(a.dtype)
# int64

L’attribut dtype indique le type commun à tous les éléments du tableau – ici des entiers codés sur
64 bits.

2/30 2015-2016
 2016PC* Python 1 Le module numpy

II.2 Création avec des fonctions spéciales

II.2.a Vecteurs spéciaux (tableaux uni-dimensionnels)

On connaît les fonctions np.arange et np.linspace :

a = np.arange(0, 10, 2) # start, stop exclu, step
print(a)
# [0 2 4 6 8]
b = np.linspace(0, 10, 5) # start, stop inclus, nb
print(b)
# [ 0. 2.5 5. 7.5 10. ]

Ces fonctions sont en particulier utilisées pour le tracé des fonctions. Voir l’aide-mémoire annexé.

II.2.b Matrices spéciales (tableaux bi-dimensionnels)

Découvrons les trois fonctions spéciales : np.ones, np.zeros, np.eye, ainsi que la fonction np.diag :
a = np.ones((3, 5))
# [[ 1. 1. 1. 1. 1.]
# [ 1. 1. 1. 1. 1.]
# [ 1. 1. 1. 1. 1.]]
b = np.ones((3, 5), np.int) # on ne met pas de dtype car dtype est
# le 2ème argument de np.ones
# [[1 1 1 1 1]
# [1 1 1 1 1]
# [1 1 1 1 1]]
c = np.zeros((3, 5))
# [[ 0. 0. 0. 0.]0.
# [ 0. 0. 0. 0.]0.
# [ 0. 0. 0. 0.
0.]]
d = np.zeros((3, 5),
dtype=np.bool) # on met un dtype, car dtype est le 4ème argument
# (et non le 2ème) de np.eyes
# [[False False False False False]
# [False False False False False]
# [False False False False False]]
e = np.eye(3)
# [[ 1. 0. 0.]
# [ 0. 1. 0.]
# [ 0. 0. 1.]]
f = np.diag([1,2,3])
# [[1 0 0]
# [0 2 0]
# [0 0 3]]


II.2.c Tableaux aléatoires

a = np.random.randint(0, 10, size=(2, 5)) # tirage uniforme d'entiers dans [0, 10[
print(a)
# [[8 2 6 2 7]
# [4 3 5 5 5]]
b = np.random.binomial(10, .3, (2, 5)) # simule (2, 5) valeurs d'une vad suivant une binomiale(10,.3)
print(b)
# [[1 1 2 3 3]
# [1 2 4 2 1]]

2015-2016 3/30
 2016
PC* Python 1 Le module numpy

c = np.random.geometric(.3, 5) # simule 5 valeurs d'une vad suivant une géométrique(.3)

print(c)
# [1 1 1 3 3]
d = np.random.poisson(4.3, 5) # simule 5 valeurs d'une vad suivant une poisson(4.3)
print(d)
# [2 6 6 3 3]


Remarque. Il existe d’autres fonctions, voir la fiche correspondante.

Exemple. Comment simuler dix lancers d’un dé équilibré à 6 faces ?

II.2.d Lecture des données dans un fichier

Si des données sont stockées dans un fichier texte avec délimiteur (format csv), on peut construire la
matrice de ces données avec la fonction np.genfromtxt. Supposons que le fichier data.csv contienne
les données suivantes
1,2,3,4,5
6,0,0,7,8
0,0,9,10,11

On peut alors définir une matrice de la façon suivante :

m = np.genfromtxt("./data.csv", delimiter = ',')
print (m)
# [[ 1. 2. 3. 4. 5.]
# [ 6. 0. 0. 7. 8.]
# [ 0. 0. 9. 10. 11.]]


II.3 Attributs d’un tableau

Les tableaux numpy sont des objets, qui possèdent certains attributs (des propriétés de ces objets).
Modifier ces attributs est une action « en place », sans copie du tableau.
• dtype indique le type commun de ses éléments,
• size indique le nombre d’éléments du tableau,
• shape donne le tuple de son format (nombre le lignes, de colonnes...),
• ndim le nombre d’indices nécessaires au parcours du tableau, c’est-à-dire le nombre d’éléments
du tuple indiquant son format.
a = np.array( [1, 2, 3] )
print(a.size)
# 3
print(a.shape)
# (3,)
print(a.ndim)
# 1
b = np.array( [[1, 2, 3],
[2, 3, 4]])
print(b.size)
# 6
print(b.shape)
# (2, 3)
print(b.ndim)
# 2

Il est remarquable que l’attribut shape soit mutable. On peut aussi utiliser la méthode reshape.

4/30 2015-2016
 2016
PC* Python 1 Le module numpy

b.shape = (3,2) # ou alors : b.reshape((3,2))

print(b)
# [[1 2]
# [3 2]
# [3 4]]
b.shape = (6, ) # ou alors : b.shape = (-1, )
print(b)
# [1 2 3 2 3 4]

En fait, les éléments d’un tableau numpy sont stockés consécutivement dans la mémoire, indépendam-
ment du format. Ce n’est que lorsque c’est nécessaire (par exemple pour l’affichage) que l’attribut
shape est utilisé. Modifier cet attribut est parfaitement négligeable en terme de complexité.
L’attribut dtype n’est pas modifiable, puisque le stockage d’un entier n’utilise pas le même nombre
de bits que le stockage d’un flottant ou d’un complexe. Il peut cependant être imposé à la création du
tableau numpy, pour éviter le casting automatique.
c = np.array( [[1, 0],
[0, 2] ], dtype = complex)
print(c)
# [[ 1.+0.j 0.+0.j]
# [ 0.+0.j 2.+0.j]]

Si l’on souhaite modifier le dtype d’un tableau, il faut passer par une copie avec conversion, en utilisant
la méthode astype :
d = c.astype(int)
print(d)
# [[1 0]
# [0 2]]


II.4 Lecture dans un tableau

II.4.a Slicing

a = np.array([2, 3, 5]) a[0]

print(a.ndim) 2

# 1
print(a.shape)
axis = 0

3
# (3,)
print(a[0])
5
# 2

axis = 1

b = np.array([ [2, 3, 5, 7], b[0,1] b[:,3]

[11, 13, 17, 19],

[23, 29, 31, 37] ])
print(b.ndim) 2 3 5 7

# 2
print(b.shape)
axis = 0

11 13 17 19
# (3, 4)
print(b[0,1])
23 29 31 37
# 3
print(b[:,3])
# [ 7 19 37] axis = 1


2015-2016 5/30
 2016
PC* Python 1 Le module numpy

c = np.array( range(24) ) # [[ 8 9]
c.shape = (3, 4, 2) # [10 11]
print (c) # [12 13]
# [[[ 0 1] # [14 15]]
# [ 2 3] 
# [ 4 5]
# [ 6 7]] c[0,1,0]

2
=
# [[ 8 9] c[1,:,:]

is
ax
# [10 11]
# [12 13] 0 2 4 6

# [14 15]]

axis = 0
8 10 12 14
# [[16 17]
# [18 19]
16 18 20 22
# [20 21]
# [22 23]]]
print(c[1,:,:]) axis = 1

II.4.b Les masques

Si a est un tableau numpy, et b un tableau de booléens de même format, alors a[b] met en relation un
à un les éléments de a et ceux de b, en ne conservant que les éléments de a associés à la valeur True :
a = np.array(range(10))
a.shape = (2, 5)
print(a)
b = np.array([[ True, False, False, True, False],
[False, True, False, False, True]])
print(a[b])
# [0 3 6 9]

On verra au § III.1 qu’il est aisé de construire le tableau des booléens traduisant par exemple la
propriété : l’élément est divisible par 3.
b = a % 3 == 0
print(b)
[[ True False False True False]
[False True False False True]]

Bref, pour obtenir tous les éléments de a qui sont divisibles par 3, on écrira donc :
a [ a % 3 == 0 ]


II.5 Écriture dans un tableau

Les tableaux numpy sont mutables, on peut donc modifier les valeurs qu’ils contiennent sans redéfinir
l’objet lui-même. Et on peut modifier simultanément plusieurs valeurs, en utilisant les mêmes syntaxes
qu’au paragraphe précédent.
a = np.array(range(10))
a.shape = (2, 5)
print(a)
# [[0 1 2 3 4]
# [5 6 7 8 9]]
a[0,0] = 7
print(a)

6/30 2015-2016
 2016
PC* Python 1 Le module numpy

# [[7 1 2 3 4]
# [5 6 7 8 9]]
a[0,:] = [8, 7, 6, 5, 4]
print(a)
# [[8 7 6 5 4]
# [5 6 7 8 9]]
a[ a % 2 == 0 ] /= 2
print(a)
# [[4 7 3 5 2]
# [5 3 7 4 9]]

Dans ce dernier exemple, les éléments pairs de a sont divisés par 2.

II.6 À propos des copies

Lorsque l’on manipule de grandes quantités de données, c’est souvent une mauvaise idée de vouloir
copier ces données. C’est pourquoi la plupart des manipulations de tableau numpy se fait au travers
de vues d’un même tableau.
a = np.array(range(10))
a.shape = (2, 5)
b = a
print(id(a), id(b))
# 4346543408 4346543408

Ici, comme on pouvait s’y attendre, a et b sont simplement deux noms pour un même objet. Lorsque
l’on manipule des listes, on peut faire :

# avec a=np.array(range(10) # avec a=[i for i in range(10)] (donc une liste)

b = a[:,:] b = a[:,:]
print(id(a), id(b)) print(id(a), id(b))
# 4346543408 4299979904 # 4371580680 4371581000
 

ce qui apparaît comme prometteur : a et b ne correspondent plus à un même objet. Cependant :

# avec a=np.array(range(10) # avec a=[i for i in range(10)] (donc une liste)

b.fill(1) b[3:6]=[-1,-1,-1]
print(a) print(a)
# [[1 1 1 1 1] # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# [1 1 1 1 1]] print(b)
print(b) # [0, 1, 2, -1, -1, -1, 6, 7, 8, 9]
# [[1 1 1 1 1] 
# [1 1 1 1 1]]

De même :
a = np.zeros((2, 5), dtype=np.int64)
b = a[1, 1:3]
b[:] = [1, 1]
print(a)
# [[0 0 0 0 0]
# [0 1 1 0 0]]

a et b sont en fait deux vues (partielle pour b) du même objet.

Remarque. C’est en général une mauvaise idée, mais si on souhaite malgré tout faire une copie d’un
tableau numpy, on utilise la méthode copy(), ou bien astype(dtype) déjà mentionnée.

2015-2016 7/30
 2016
PC* Python 1 Le module numpy

III. Opérations sur les tableaux numpy

III.1 Les opérations se font terme à terme

Les opérations +, *, /, ==, etc s’appliquent aux tableaux numpy, mais TERME à TERME. C’est
cohérent avec la définition mathématique pour l’addition, mais ça ne l’est plus du tout pour la multi-
plication, les puissances etc.
a = np.random.randint(0, 10, (2, 5))
b = np.random.randint(1, 10, (2, 5))
print(a)
# [[0 9 0 6 6]
# [8 9 2 0 0]]
print(b)
# [[3 1 3 5 2]
# [8 7 7 1 6]]
print(a + b)
# [[ 3 10 3 11 8]
# [16 16 9 1 6]]
print(a * b)
# [[ 0 9 0 30 12]
# [64 63 14 0 0]]
print(a // b)
# [[0 9 0 1 3]
# [1 1 0 0 0]]
print(a / b)
# [[ 0. 9. 0. 1.2 3. ]
# [ 1. 1.28571429 0.28571429 0. 0. ]]
print(a ** b)
# [[ 0 9 0 7776 36]
# [16777216 4782969 128 0 0]]
print(a == b)
# [[False False False False False]
# [True False False False False]]


III.2 Les fonctions universelles s’appliquent terme à terme

Les fonctions définies dans le module numpy sont universelles, ou vectorialisées, c’est-à-dire qu’elles
acceptent comme argument un tableau numpy et renvoient le tableau numpy des images. Utiliser des
fonctions vectorialisées permet de faire gagner des facteurs énormes en temps de calcul.
x = np.linspace(-1, 1, 18)
y = np.arcsin(x)
print(y)
# [-1.57079633 -1.080839 -0.87058477 -0.70372051 -0.55790704 -0.42438971
# -0.2985322 -0.1773996 -0.05885751 0.05885751 0.1773996 0.2985322
# 0.42438971 0.55790704 0.70372051 0.87058477 1.080839 1.57079633]

On peut vectoriser ses propres fonctions :
def f(x):
k, s = 0, 0
while s <= x:
k += 1
s += k
return k

8/30 2015-2016
 2016
PC* Python 1 Le module numpy

print(f(9.56))
# 4

x = np.arange(1, 10, 2)
# print(f(x)) # déclenche une erreur
vf = np.vectorize(f)
print(vf(x))
# [2 3 3 4 4]


III.3 Quelques méthodes sur les tableaux

On peut utiliser les méthodes (ou les fonctions associées) a.max(), a.min(), a.sum(), a.prod(),
a.mean() (moyenne arithmétique), a.var() (variance), a.std() (écart-type).
a = np.random.randint(0, 10, (2,5))
print(a)
# [[8 5 0 1 3]
# [2 2 1 5 3]]
print(a.sum()) # ou encore np.sum(a)
# 30
print(a.sum(axis=0))
# [10 7 1 6 6]
print(a.sum(axis=1))
# [17 13]
print(a.mean())
# 3.0
print(a.mean(axis=0))
# [ 5. 3.5 0.5 3. 3. ]
print(a.mean(axis=1))
# [ 3.4 2.6]
print(a.max())
# 8
print(a.max(axis=0))
# [8 5 1 5 3]
print(a.max(axis=1))
# [8 5]


III.4 Opérations d’algèbre linéaire

Commençons par le produit matriciel : c’est la fonction np.dot(a,b) ou la méthode a.dot(b) :

a = np.array([[1,2,3],
[4,5,6],
[7,8,9]])
b = np.array([[0,1,0],
[1,0,0],
[0,0,1]])
print(np.dot(a,b)) # ou alors print(a.dot(b))
# [[2 1 3]
# [5 4 6]
# [8 7 9]]

Le produit scalaire canonique, entre deux vecteurs ou deux matrices, se calcule avec np.vdot.
Le produit vectoriel se calcule avec np.cross.
La transposée de la matrice a est a.transpose() ou plus simplement a.T.
Le sous-module linalg fournit les fonctions :

2015-2016 9/30
2016
PC* Python 1 Le module numpy

np.linalg.det, np.linalg.inv, np.linalg.norm, np.linalg.solve

np.linalg.matrix_power, np.linalg.matrix_rank

dont les significations sont immédiates. Pour cette dernière, la matrice doit être inversible pour que le
résultat soit cohérent.
a = np.array([[1,2,3],
[0,2,2],
[0,2,3]])
b = np.array([4,9,1])
print(np.linalg.solve(a,b))
# [ 3. 12.5 -8. ]

La fonction np.linalg.eig fournit un couple de deux matrices, la première étant le spectre de la
matrice, donné sous forme d’un vecteur où les valeurs propres multiples apparaissent autant de fois
que leurs multiplicités, et d’une matrice carrée dont les colonnes sont des vecteurs engendrant respecti-
vement les espaces propres de la matrice. On utilisera cette fonction dans le chapitre de mathématique
concernant la réduction des matrices.
a = np.array([[1,2,3],
[0,1,2],
[0,0,2]])
sp, p = np.linalg.eig(a)
print(sp)
# [ 1. 1. 2.]
print(p)
# [[ 1.00000000e+00 -1.00000000e+00 9.52579344e-01]
# [ 0.00000000e+00 1.11022302e-16 2.72165527e-01]
# [ 0.00000000e+00 0.00000000e+00 1.36082763e-01]]

Terminons par des opérations sur les tableaux : np.concatenate( (a, b), axis=0) permet d’accoler
les tableaux a et b dans la direction indiquée. np.column_stack((v1,v2,v3)) permet de construire
la matrice dont les colonnes sont les vecteurs passés en arguments.
a = np.array([[1,2,3],
[4,5,6],
[7,8,9]])
b = np.array([[0,1,0],
[1,0,0],
[0,0,1]])
print(np.concatenate((a,b), axis=0))
# [[1 2 3]
# [4 5 6]
# [7 8 9]
# [0 1 0]
# [1 0 0]
# [0 0 1]]
print(np.concatenate((a,b), axis=1))
# [[1 2 3 0 1 0]
# [4 5 6 1 0 0]
# [7 8 9 0 0 1]]

v1 = np.array([1,2,3])
v2 = np.array([4,5,6])
v3 = np.array([1,0,0])
p = np.column_stack((v1,v2,v3))
print(p)
# [[1 4 1]

10/30 2015-2016
 2016
PC* Python 1 Le module numpy

# [2 5 0]
# [3 6 0]]


III.5 Manipulation de polynômes

Une classe Polynomial est disponible, et permet de manipuler les polynômes, qui sont représentés à
l’aide de la liste des coefficients classés par ordre croissant de degré. L’objet créé a un attribut coef, des
méthodes degree, roots, deriv, integ permettant d’accéder respectivement au degré, à des valeurs
approchées de racines, à la dérivée formelle, à une primitive formelle. On peut aussi utiliser l’objet
pour évaluer la fonction polynomiale associée.
from numpy.polynomial import Polynomial

p = Polynomial([1, 0, 1])
print(p.coef)
# [ 1. 0. 1.]
print(p.degree())
# 2
print(p.roots())
# [ 0.-1.j 0.+1.j]
dp = p.deriv()
print(dp.coef)
# [ 0. 2.]
ip = p.integ()
print(ip.coef)
# [ 0. 1. 0. 0.33333333]
print(p(0))
# 1.0
print(p(0+1j))
# 0j


2015-2016 11/30
 (1) Vérifier qu’il n’y a qu’une solution à ce système. 2016
12/30

PC*
Exo 1 Pour cet exercice, on prend n = 1000000. On pourra aug- (2) En utilisant np.linalg.solve, déterminer cette solution.
menter ou diminuer cette valeur en fonction de la machine utilisée.
n (3) Vérifier le résultat obtenu en utilisant un produit matriciel.
(1) Calculer i sans utiliser numpy.
P
i=0 (4) Construire la matrice m de format 4 × 5, dont les colonnes sont
(2) Chronométrer le temps nécessaire pour le calcul précédent, par successivement les colonnes de a et b.
exemple en utilisant time.clock().
(3) Utiliser un tableau numpy et la méthode sum pour calculer à nou- (5) Appliquer à m la méthode du pivot de Gauss pour résoudre « à
veau la somme proposée. la main » le système proposé.
(4) Comparer le temps de calcul avec la méthode précédente.
Exo 5 On pose M = 20 et m = 10.
Exo 2
À un nombre quelconque c, on associe la suite (un )n définie par :
(1) Définir une matrice aléatoire a de taille 50 × 50.
(2) Déterminer la valeur Maxi,j |ai,j+1 − ai,j |. u0 = 0 et un+1 = u2n + c pour n > 0
(3) Que peut représenter cette valeur ?
S’il existe, on note k le plus petit entier tel que l’on ait 0 6 k 6 m et
Exo 3
|uk | > M .
(1) Définir une matrice aléatoire a de flottants, de taille 50 × 50 (si On définit alors la fonction f par :
on doit imprimer, on se limitera à 5 × 5).
(2) Compter le nombre de valeurs inférieures à 0.5. s’il existe
(
k
On pourra utiliser le fait que l’on peut sommer les booléens : f : c 7→
m+1 sinon
print(True+True)
# 2
print(False+False) (1) Donner le code définissant la fonction f .
# 0
 (2) Tracer l’allure de la courbe représentative de la fonction f sur
(3) Remplacer toutes les valeurs inférieures à 0.5 par 0, et celles stric- [−2, 2].

Python 1 Le module numpy

tement supérieures à 0.5 par 1. (3) Construire le tableau des valeurs f (x + iy) où x prend 101 valeurs
entre −2 et 0.5, et y 101 valeurs entre −1.1 et 1.1.
Exo 4 On s’intéresse au système linéaire suivant :
 (4) Utiliser les fonctions imshow et show de matplotblib.pyplot



x1 + 2x2 + x3 + x4 = 0 pour représenter l’image que code ce tableau.
 x2 + 2x3 + x4 = 0
2015-2016

 x 1 + x3 + 2x4 = 1 (5) Quels paramètres peut-on modifier pour obtenir une meilleure
résolution ?



2x1 + x2 + x4 = 0
2016
PC*

Annexe A

Les aide-mémoires Centrale-Supélec

2015-2016 13/30
 Svi?QM
P`H
JS- S*- SaA- haA
*H+mH Ki`B+B2H

PM i`pBHH2 p2+ H2b KQ/mH2b MmKTv 2i MmKTvXHBMH;X

BKTQ`i MmKTv b MT
BKTQ`i MmKTvXHBMH; b H;

*`ûiBQM /2 Ki`B+2b
SQm` /û}MB` mM2 Ki`B+2- QM miBHBb2 H 7QM+iBQM ``v /m KQ/mH2 MmKTvX

 4 MTX``vU((R- k- j)- (9- 8- e))V


``vU((R- k- j)-
(9- 8- e))V

GǶii`B#mi b?T2 /QMM2 H iBHH2 /ǶmM2 Ki`B+2 , MQK#`2 /2 HB;M2b- MQK#`2 /2 +QHQMM2bX PM T2mi `2/BK2MbBQMM2`
mM2 Ki`B+2- bMb KQ/B}2` b2b i2`K2b- ¨ HǶB/2 /2 H Kûi?Q/2 `2b?T2X

Xb?T2
Uk- jV
 4 X`2b?T2UUj- kVV

``vU((R- k)-
(j- 9)-
(8- e))V

GǶ++ĕb ¨ mM i2`K2 /2 H Ki`B+2  b2 7Bi ¨ HǶB/2 /2 HǶQTû`iBQM /ǶBM/2t;2 (B- D) Qɍ B /ûbB;M2 H HB;M2 2i D
H +QHQMM2X ii2MiBQM- H2b BM/B+2b +QKK2M+2Mi ¨ xû`Q 5 § HǶB/2 /ǶBMi2`pHH2b- QM T2mi û;H2K2Mi `û+mTû`2`
mM2 T`iB2 /ǶmM2 Ki`B+2 , HB;M2- +QHQMM2- bQmb@Ki`B+2X _TT2H-  ,# /ûbB;M2 HǶBMi2`pHH2 Qmp2`i ¨ /`QBi2 <<Ԑ ԑ<<-
, /ûbB;M2 HǶBMi2`pHH2 +QMi2MMi iQmb H2b BM/B+2b /2 H /BK2MbBQM +QMbB/û`û2X LQi2x H /Bzû`2M+2 2Mi`2 HǶBM/2tiBQM
T` mM 2MiB2` 2i T` mM BMi2`pHH2 `û/mBi ¨ mM 2MiB2`X

(R- y) O i2`K2 /2 H /2mtBĐK2 HB;M2- T`2KBĐ`2 +QHQMM2

j
(y- ,) O T`2KBĐ`2 HB;M2 bQmb 7Q`K2 /2 i#H2m £ R /BK2MbBQM
``vU(R- k)V
(y- ,)Xb?T2
Uk-V
(y ,R- ,) O T`2KBĐ`2 HB;M2 bQmb 7Q`K2 /2 Ki`B+2 HB;M2
``vU((R- k))V
(y ,R- ,)Xb?T2
UR- kV
( ,- R) O /2mtBĐK2 +QHQMM2 bQmb 7Q`K2 /2 i#H2m £ R /BK2MbBQM
``vU(k- 9- e)V
( ,- R ,k) O /2mtBĐK2 +QHQMM2 bQmb 7Q`K2 /2 Ki`B+2 +QHQMM2
``vU((k)-
(9)-
(e))V
(R ,j- y ,k) O bQmb@Ki`B+2 HB;M2b k 2i j- +QHQMM2b R 2i k
``vU((j- 9)-
(8- e))V

e DmBM kyR8 R3,y8 Svi?QM@Ki`B+2b@R

G2b 7QM+iBQMb x2`Qb 2i QM2b T2`K2ii2Mi /2 +`û2` /2b Ki`B+2b `2KTHB2b /2 y Qm /2 RX G 7QM+iBQM 2v2b T2`K2i
/2 +`û2` mM2 Ki`B+2 /m ivT2 Ӿ։ Qɍ ԝ 2bi mM 2MiB2`X G 7QM+iBQM /B; T2`K2i /2 +`û2` mM2 Ki`B+2 /B;QMH2X

MTXx2`QbUUk-jVV
``vU(( yX- yX- yX)-
( yX- yX- yX))V
MTXQM2bUUj-kVV
``vU(( RX- RX)-
( RX- RX)-
( RX- RX))V
MTX2v2U9V
``vU(( RX- yX- yX- yX)-
( yX- RX- yX- yX)-
( yX- yX- RX- yX)-
( yX- yX- yX- RX))V
MTX/B;U(R-k-j)V
``vU((R- y- y)-
(y- k- y)-
(y- y- j))V

1M}M H 7QM+iBQM +QM+i2Mi2 T2`K2i /2 +`û2` /2b Ki`B+2b T` #HQ+bX

 4 MTXQM2bUUk-jVV
" 4 MTXx2`QbUUk-jVV
MTX+QM+i2Mi2UU-"V- tBb4yV
``vU(( RX- RX- RX)-
( RX- RX- RX)-
( yX- yX- yX)-
( yX- yX- yX))V
MTX+QM+i2Mi2UU-"V-tBb4RV
``vU(( RX- RX- RX- yX- yX- yX)-
( RX- RX- RX- yX- yX- yX))V

*H+mH Ki`B+B2H
G2b QTû`iBQMb /ǶDQmi 2i /2 KmHiBTHB+iBQM T` mM b+HB`2 b2 7QMi p2+ H2b QTû`i2m`b Y 2i X

 4 MTX``vU((R-k)- (j-9))V
" 4 MTX2v2UkV
 Y j "
``vU(( 9X- kX)-
( jX- dX))V

SQm` 2z2+im2` mM T`Q/mBi Ki`B+B2H UHQ`b[m2 [m2 +2H 2bi TQbbB#H2V- BH 7mi 2KTHQv2` H 7QM+iBQM /QiX

 4 MTX``vU((R-k)- (j-9))V
" 4 MTX``vU((R-R-R)- (k-k-k))V
MTX/QiU- "V
``vU(( 8- 8- 8)-
(RR- RR- RR))V

PM T2mi û;H2K2Mi miBHBb2` H Kûi?Q/2 /Qi [mB 2bi THmb T`iB[m2 TQm` +H+mH2` mM T`Q/mBi /2 THmbB2m`b Ki`B+2bX

X/QiU"V
``vU(( 8- 8- 8)-
(RR- RR- RR))V
X/QiU"VX/QiUMTXQM2bUUj-kVVV
``vU(( R8X- R8X)-
( jjX- jjX))V

G 7QM+iBQM Ki`BtnTQr2` /m KQ/mH2 MmKTvXHBMH; T2`K2i /2 +H+mH2` /2b TmBbbM+2b /2 Ki`B+2bX

H;XKi`BtnTQr2`U-jV

e DmBM kyR8 R3,y8 Svi?QM@Ki`B+2b@k

 ``vU(( jd- 89)-
( 3R- RR3))V

G i`MbTQbû2 bǶQ#iB2Mi p2+ H 7QM+iBQM i`MbTQb2X GǶ2tT`2bbBQM Xh `2MpQB2 mbbB H i`MbTQbû2 /2 X

MTXi`MbTQb2U"V
``vU((R- k)-
(R- k)-
(R- k))V
"Xh
``vU((R- k)-
(R- k)-
(R- k))V

G2 /ûi2`KBMMi- H2 `M; 2i H i`+2 /ǶmM2 Ki`B+2 bǶQ#iB2MM2Mi T` H2b 7QM+iBQMb /2i- Ki`Btn`MF /m KQ/mH2
MmKTvXHBMH; 2i i`+2 /m KQ/mH2 MmKTvX 1M}M H 7QM+iBQM BMp /m KQ/mH2 MmKTvXHBMH; `2MpQB2 HǶBMp2`b2 /2
H Ki`B+2 bǶBH 2tBbi2X

H;X/2iUV
@kXyyyyyyyyyyyyyyy9
H;XKi`Btn`MFUV
k
MTXi`+2UV
8
H;XBMpUV
Ki`BtU((@kX - RX )-
( RX8- @yX8))V

SQm` `ûbQm/`2 H2 bvbiĕK2 HBMûB`2 Ӷԧ  ԑ HQ`b[m2 H Ki`B+2 Ӷ 2bi BMp2`bB#H2- QM T2mi 2KTHQv2` H 7QM+iBQM bQHp2
/m KQ/mH2 MmKTvXHBMH;X

# 4 MTX``vU(R-8)V
H;XbQHp2U- #V
``vU( jX- @RX)V

G 7QM+iBQM 2B;pHb /m KQ/mH2 MmKTvXHBMH; `2MpQB2 H2b pH2m`b T`QT`2b /2 H Ki`B+2X SQm` Q#i2MB` 2M THmb
H2b p2+i2m`b T`QT`2b bbQ+Bûb- BH 7mi 2KTHQv2` H 7QM+iBQM 2B;X

H;X2B;pHbUV
``vU(@yXjdkk3Rjk- 8Xjdkk3Rjk)V
G 4 H;X2B;UV
G
U``vU(@yXjdkk3Rjk- 8Xjdkk3Rjk)V- ``vU((@yX3k98e939- @yX9R8Ndj8e)-
( yX8e8ded9e- @yXNyNjdedR))VV
G(R)X/QiUMTX/B;UG(y)VVX/QiUH;XBMpUG(R)VV
``vU(( RX- kX)-
( jX- 9X))V

G 7QM+iBQM p/Qi T2`K2i /2 +H+mH2` H2 T`Q/mBi b+HB`2 /2 /2mt p2+i2m`b /2 න ։ X

m 4 MTX``vU(R-k)V
p 4 MTX``vU(j-9)V
MTXp/QiUm- pV
RR

G 7QM+iBQM +`Qbb T2`K2i /2 +H+mH2` H2 T`Q/mBi p2+iQ`B2H /2 /2mt p2+i2m`b /2 නϯ X

m 4 MTX``vU(R-y-y)V
p 4 MTX``vU(y-R-y)V
MTX+`QbbUm- pV
``vU(y- y- R)V

e DmBM kyR8 R3,y8 Svi?QM@Ki`B+2b@j

 Svi?QM
P`H
JS- S*- SaA- haA
_ûHBbiBQM /2 i`+ûb
G2b 7QM+iBQMb T`ûb2Miû2b /Mb +2 /Q+mK2Mi T2`K2ii2Mi H `ûHBbiBQM /2 i`+ûbX 1HH2b Mû+2bbBi2Mi HǶBKTQ`i /m
KQ/mH2 MmKTv 2i /m KQ/mH2 KiTHQiHB#XTvTHQiX .2 THmb TQm` 2z2+im2` /2b i`+ûb 2M /BK2MbBQM j- BH +QMpB2Mi
/ǶBKTQ`i2` H 7QM+iBQM t2bj/ /m KQ/mH2 KTHniQQHFBibXKTHQij/X G2b BMbi`m+iBQMb Mû+2bbB`2b mt 2t2KTH2b
[mB bmBp2Mi bQMi HBbiûb +B@/2bbQmbX

BKTQ`i Ki?
BKTQ`i KiTHQiHB#XTvTHQi b THi
BKTQ`i MmKTv b MT
7`QK KTHniQQHFBibXKTHQij/ BKTQ`i t2bj.

h`+ûb /2 HB;M2b #`Bbû2b 2i QTiBQMb /2 i`+ûb

PM /QMM2 H HBbi2 /2b #b+Bbb2b 2i H HBbi2 /2b Q`/QMMû2b TmBb QM 2z2+im2 H2 i`+ûX G 7QM+iBQM tBb T2`K2i /2
/û}MB` H 72Māi`2 /Mb H[m2HH2 2bi +QMi2Mm2 H2 ;`T?B[m2X GǶQTiBQM 2[mH T2`K2i /ǶQ#i2MB` H2b KāK2b û+?2HH2b
bm` H2b /2mt t2bX G2b i`+ûb `2HiB7b ¨ /Bp2`b 2KTHQBb /2 H 7QM+iBQM THQi b2 bmT2`TQb2MiX G 7QM+iBQM THiX+H7UV
2z+2 H2b i`+ûb +QMi2Mmb /Mb H 72Māi`2 ;`T?B[m2X

t 4 (RX- kX8- 9X)

v 4 (jX- RX- 8X)
THiXtBbU^2[mH^V
THiXTHQiUt- vV
THiXtBbU(@RX- 8X- @RX- eX)V
THiX;`B/UV
THiXb?QrUV

G 7QM+iBQM THQi /K2i /2 MQK#`2mb2b QTiBQMb /2 T`ûb2MiiBQMX G2 T`Kĕi`2 +QHQ` T2`K2i /2 +?QBbB` H +QmH2m`
U^;^ , p2`i- ^`^ , `Qm;2- ^#^ , #H2mVX SQm` /û}MB` H2 bivH2 /2 H HB;M2- QM miBHBb2 HBM2bivH2 U^@^ , HB;M2 +QMiBMm2-
^@ @^ , HB;M2 /Bb+QMiBMm2- ^ ,^ , HB;M2 TQBMiBHHû2VX aB QM p2mi K`[m2` H2b TQBMib /2b HBbi2b- QM miBHBb2 H2 T`Kĕi`2
K`F2` U^Y^- ^X^- ^Q^- ^p^ /QMM2Mi /Bzû`2Mib bvK#QH2bVX

t 4 (RX- kX8- 9X)

v 4 (jX- RX- 8X)
THiXtBbU(@RX- 8X- @RX- eX)V
THiXTHQiUt- v- +QHQ`4^`^- HBM2bivH24^ ,^-
K`F2`4^Q^V
THiXb?QrUV

e DmBM kyR8 R3,Rd Svi?QM@THQi@R

h`+ûb /2 7QM+iBQM
PM /û}MBi mM2 HBbi2 /Ƕ#b+Bbb2b TmBb QM +QMbi`mBi H HBbi2 /2b Q`/QMMû2b +Q``2bTQM/Mi2bX GǶ2t2KTH2 +B@/2bbQmb
i`+2 ԧ ‫ ޓ‬TJO ԧ bm` < ᅵ>X

/27 7UtV ,
`2im`M Ki?XbBMUtV

s 4 MTX`M;2Uy- j MTXTB- yXyRV

u 4 ( 7UtV 7Q` t BM s )
THiXTHQiUs- uV
THiXb?QrUV

AH 2bi ;ûMû`H2K2Mi THmb BMiû`2bbMi /ǶmiBHBb2` H2b 7QM+iBQMb /m KQ/mH2 MmKTv- THmiƬi [m2 +2HH2b /m KQ/mH2 Ki?-
+` 2HH2b T2`K2ii2Mi /2 i`pBHH2` mbbB #B2M p2+ /2b b+HB`2b [mǶp2+ /2b i#H2mt UQM H2b TT2HH2 7QM+iBQMb
mMBp2`b2HH2bVX

/27 7UtV ,
`2im`M MTXbBMUtV

s 4 MTX`M;2Uy- j MTXTB- yXyRV

u 4 7UsV
THiXTHQiUs- uV
THiXb?QrUV

lM2 mi`2 bQHmiBQM +QMbBbi2 ¨ miBHBb2` H 7QM+iBQM p2+iQ`Bx2 /m KQ/mH2 MmKTv [mB T2`K2i /2 i`Mb7Q`K2` mM2
7QM+iBQM b+HB`2 2M mM2 7QM+iBQM +T#H2 /2 i`pBHH2` p2+ /2b i#H2mtX AH 2bi +2T2M/Mi #2m+QmT THmb 2zB++2
/ǶmiBHBb2` /B`2+i2K2Mi /2b 7QM+iBQMb mMBp2`b2HH2bX

/27 7UtV ,
`2im`M Ki?XbBMUtV

7 4 MTXp2+iQ`Bx2U7V

AH 2bi ¨ MQi2` [m2 H2b QTû`i2m`b Tvi?QM UY- @- - 2i+XV T2mp2Mi bǶTTHB[m2` ¨ /2b i#H2mt- BHb ;Bbb2Mi HQ`b i2`K2
¨ i2`K2X BMbB H 7QM+iBQM 7 /û}MB2 +B@/2bbQmb 2bi mM2 7QM+iBQM mMBp2`b2HH2- 2HH2 T2mi i`pBHH2` mbbB #B2M p2+
/2mt b+HB`2b [mǶp2+ /2mt i#H2mt 2i KāK2 p2+ mM b+HB`2 2i mM i#H2mX

/27 7Ut- vV ,
`2im`M MTXb[`iUt k Y v kV

7Uj- 9V
8Xy
7UMTX``vU(R- k- j)V- MTX``vU(9- 8- e)VV
``vU( 9XRkjRy8ej- 8Xj38Re93R- eXdy3kyjNj)V
7UMTX``vU(R- k- j)V- 9V
``vU( 9XRkjRy8ej- 9X9dkRj8N8- 8X )V

e DmBM kyR8 R3,Rd Svi?QM@THQi@k

h`+ûb /Ƕ`+b T`Kûi`ûb
.Mb H2 +b /ǶmM `+ T`Kûi`û THM- QM /û}MBi /Ƕ#Q`/ H HBbi2 /2b pH2m`b /QMMû2b m T`Kĕi`2 TmBb QM
+QMbi`mBi H HBbi2 /2b #b+Bbb2b 2i /2b Q`/QMMû2b +Q``2bTQM/Mi2bX PM 2z2+im2 2MbmBi2 H2 i`+ûX

/27 tUiV ,
`2im`M MTXbBMUk iV

/27 vUiV ,
`2im`M MTXbBMUj iV

h 4 MTX`M;2Uy- k MTXTB- yXyRV

s 4 tUhV
u 4 vUhV
THiXtBbU^2[mH^V
THiXTHQiUs- uV
THiXb?QrUV

oQB+B mM 2t2KTH2 /2 i`+û /ǶmM `+ T`Kûi`û /2 HǶ2bT+2X

t 4 t2bj.UTHiX7B;m`2UVV
h 4 MTX`M;2Uy- k MTXTB- yXyRV
s 4 MTX+QbUhV
u 4 MTXbBMUhV
w 4 h
tXTHQiUs- u- hV
THiXb?QrUV

h`+û /2 bm`7+2b
SQm` i`+2` mM2 bm`7+2 /Ƕû[miBQM ԩ  ԕ ԧ Ԩ - QM `ûHBb2 /Ƕ#Q`/ mM2 ;`BHH2 2M ԧ Ԩ TmBb QM +H+mH2 H2b pH2m`b
/2 ԩ +Q``2bTQM/Mi mt TQBMib /2 +2ii2 ;`BHH2X PM 7Bi 2MbmBi2 H2 i`+û p2+ H 7QM+iBQM THQinbm`7+2X

t 4 t2bj.UTHiX7B;m`2UVV

/27 7Ut-vV ,
`2im`M t k @ v k

s 4 MTX`M;2U@R- R- yXykV
u 4 MTX`M;2U@R- R- yXykV
s- u 4 MTXK2b?;`B/Us- uV
w 4 7Us- uV
tXTHQinbm`7+2Us- u- wV
THiXb?QrUV

e DmBM kyR8 R3,Rd Svi?QM@THQi@j

h`+û /2 HB;M2b /2 MBp2m
SQm` i`+2` /2b +Qm`#2b /Ƕû[miBQM ԕ ԧ Ԩ  Ԛ- QM 7Bi mM2 ;`BHH2 2M ԧ 2i 2M Ԩ bm` H[m2HH2 QM +H+mH2 H2b pH2m`b
/2 ԕ X PM 2KTHQB2 2MbmBi2 H 7QM+iBQM +QMiQm` 2M K2iiMi /Mb mM2 HBbi2 H2b pH2m`b /2 Ԛ TQm` H2b[m2HH2b QM p2mi
i`+2` H +Qm`#2 /Ƕû[miBQM ԕ ԧ Ԩ  ԚX

/27 7Ut-vV ,
`2im`M t k Y v k Y t v

s 4 MTX`M;2U@R- R- yXyRV
u 4 MTX`M;2U@R- R- yXyRV
s- u 4 MTXK2b?;`B/Us- uV
w 4 7Us- uV
THiXtBbU^2[mH^V
THiX+QMiQm`Us- u- w- (yXR-yX9-yX8)V
THiXb?QrUV

e DmBM kyR8 R3,Rd Svi?QM@THQi@9

 Svi?QM
P`H
JS- S*- SaA- haA
MHvb2 MmKû`B[m2

G THmT`i /2b 7QM+iBQMb T`ûb2Miû2b /Mb +2ii2 b2+iBQM Mû+2bbBi2Mi HǶBKTQ`i /m KQ/mH2 MmKTv 2i /2 bQmb@KQ/mH2b
/m KQ/mH2 b+BTvX G2b BMbi`m+iBQMb Mû+2bbB`2b mt 2t2KTH2b bmBpMib bQMi HBbiûb +B@/2bbQmbX

BKTQ`i MmKTv b MT
BKTQ`i b+BTvXQTiBKBx2 b `2bQH
BKTQ`i b+BTvXBMi2;`i2 b BMi2;`
BKTQ`i KiTHQiHB#XTvTHQi b THi

_ûbQHmiBQM TT`Q+?û2 /Ƕû[miBQMb

SQm` `ûbQm/`2 mM2 û[miBQM /m ivT2 ԕ ԧ   Qɍ ԕ 2bi mM2 7QM+iBQM /ǶmM2 p`B#H2 `û2HH2- QM T2mi miBHBb2` H
7QM+iBQM 7bQHp2 /m KQ/mH2 b+BTvXQTiBKBx2X AH 7mi T`û+Bb2` H pH2m` BMBiBH2 ԧЈ /2 HǶH;Q`Bi?K2 2KTHQvû T`
H 7QM+iBQM 7bQHp2X G2 `ûbmHii T2mi /ûT2M/`2 /2 +2ii2 +QM/BiBQM BMBiBH2X

/27 7UtV ,
`2im`M t k @ k

`2bQHX7bQHp2U7- @kXV
``vU(@RX9R9kRj8e)V

`2bQHX7bQHp2U7- kXV
``vU( RX9R9kRj8e)V

.Mb H2 +b /ǶmM2 7QM+iBQM ԕ ¨ pH2m`b p2+iQ`B2HH2b- QM miBHBb2 H 7QM+iBQM `QQiX S` 2t2KTH2- TQm` `ûbQm/`2 H2
bvbiĕK2 MQM HBMûB`2

ԧϵ ਲ Ԩ ϵ  
ব
ԧ Ԩ ਲ   

/27 7UpV ,
`2im`M p(y) k @ p(R) k @ R- p(y) Y k p(R) @ j

bQH 4 `2bQHX`QQiU7- (y-y)V

bQHXbm++2bb
h`m2
bQHXt
``vU( RXjyN9yRy3- yX398kNN9e)V

bQH4`2bQHX`QQiU7- (@8-8)V
bQHXbm++2bb
h`m2
bQHXt
``vU(@jXjyN9yRy3- jXR89dyy89)V

e DmBM kyR8 R3,R9 Svi?QM@L@R

*H+mH TT`Q+?û /ǶBMiû;`H2b
G 7QM+iBQM [m/ /m KQ/mH2 b+BTvXBMi2;`i2 T2`K2i /2 +H+mH2` /2b pH2m`b TT`Q+?û2b /ǶBMiû;`H2bX 1HH2
`2MpQB2 mM2 pH2m` TT`Q+?û2 /2 HǶBMiû;`H2 BMbB [mǶmM KDQ`Mi /2 HǶ2``2m` +QKKBb2X *2ii2 7QM+iBQM T2mi mbbB
bǶ2KTHQv2` p2+ /2b #Q`M2b /ǶBMiû;`iBQM û;H2b ¨ ˜ Qm ਲ˜X

/27 7UtV ,
`2im`M MTX2tTU@tV

BMi2;`X[m/U7- y- RV
UyXejkRky8833k388d3- dXyRdN9dN3d8yj38e2@R8V

BMi2;`X[m/U7- y- MTXBM7V
URXyyyyyyyyyyyyyyyk- 8X39keydyj38d3yyd2@RRV

_ûbQHmiBQM TT`Q+?û2b /Ƕû[miBQMb /Bzû`2MiB2HH2b

SQm` `ûbQm/`2 mM2 û[miBQM /Bzû`2MiB2HH2 ԧ ஠  ԕ ԧ ԣ - QM T2mi miBHBb2` H 7QM+iBQM Q/2BMi /m KQ/mH2 b+BTvXBM@
i2;`i2X *2ii2 7QM+iBQM Mû+2bbBi2 mM2 HBbi2 /2 pH2m`b /2 ԣ- +QKK2MÏMi 2M ԣЈ - 2i mM2 +QM/BiBQM BMBiBH2 ԧЈ X G
7QM+iBQM `2MpQB2 /2b pH2m`b TT`Q+?û2b Umt TQBMib +QMi2Mmb /Mb H HBbi2 /2b pH2m`b /2 ԣV /2 H bQHmiBQM ԧ
/2 HǶû[miBQM /Bzû`2MiB2HH2 [mB pû`B}2 ԧ ԣЈ  ԧЈ X SQm` i`Qmp2` /2b pH2m`b TT`Q+?û2b bm` < > /2 H bQHmiBQM
ԧங ԣ  ԣԧ ԣ [mB pû`B}2 ԧ   - QM T2mi 2KTHQv2` H2 +Q/2 bmBpMiX

/27 7Ut- iV ,
`2im`M i t

h 4 MTX`M;2Uy- RXyR- yXyRV

s 4 BMi2;`XQ/2BMiU7- R- hV
s(y)
``vU( RX)V
s(@R)
``vU( RXe93dkR9j)V
THiXTHQiUh-sV
THiXb?QrUV

e DmBM kyR8 R3,R9 Svi?QM@L@k

aB QM p2mi `ûbQm/`2- bm` < >- H2 bvbiĕK2 /Bzû`2MiB2H

ԧங ԣ  ਲԧ ԣ ਲ Ԩ ԣ
ব
Ԩங ԣ  ԧ ԣ ਲ Ԩ ԣ

p2+ H +QM/BiBQM BMBiBH2 ԧ    Ԩ    H2 +Q/2 /2pB2Mi H2 bmBpMiX

/27 7Ut- iV ,
`2im`M MTX``vU(@t(y)@t(R)- t(y)@t(R))V

h 4 MTX`M;2Uy- 8XyR- yXyRV

s 4 BMi2;`XQ/2BMiU7- MTX``vU(kX-RX)V- hV
s(y)
``vU( kX- RX)V
THiXTHQiUs( ,-y)- s( ,-R)V
THiXb?QrUV

SQm` `ûbQm/`2 mM2 û[miBQM /Bzû`2MiB2HH2 b+HB`2 /ǶQ`/`2 k /2 bQHmiBQM ԧ- QM /2KM/2` H `ûbQHmiBQM /m bvbiĕK2
ԧԣ
/Bzû`2MiB2H /ǶQ`/`2 R biBb7Bi T` ԍ ԣ  ন ঩X
ԧங ԣ

LQK#`2b +QKTH2t2b
Svi?QM +H+mH2 p2+ H2b MQK#`2b +QKTH2t2bX G2 MQK#`2 BK;BMB`2 Tm` Ԙ b2 MQi2 RDX G2b ii`B#mib `2H 2i BK;
T2`K2ii2Mi /ǶQ#i2MB` H T`iB2 `û2HH2 2i H T`iB2 BK;BMB`2X G 7QM+iBQM #b +H+mH2 H2 KQ/mH2 /ǶmM +QKTH2t2X

 4 k Y jD
# 4 8 @ jD
 #
URNYNDV
X`2H
kXy
XBK;
jXy
#bUV
jXey888Rkd89ejN3Ne

e DmBM kyR8 R3,R9 Svi?QM@L@j

 Svi?QM
P`H
JS- S*- SaA- haA
SQHvMƬK2b

G +Hbb2 SQHvMQKBH /m KQ/mH2 MmKTvXTQHvMQKBHXTQHvMQKBH T2`K2i /2 i`pBHH2` p2+ /2b TQHvMƬK2bX

7`QK MmKTvXTQHvMQKBH BKTQ`i SQHvMQKBH

Pour
Sm` +`û2` mM TQHvMƬK2- BH 7mi HBbi2` b2b +Q2zB+B2Mib T` Q`/`2 /2 /2;`û +`QBbbMiX S` 2t2KTH2- TQm` H2 TQHvMƬK2
ԍ ϯ ԍ ਲ -

T 4 SQHvMQKBHU(@j- k- y- R)V

PM T2mi HQ`b miBHBb2` +2ii2 p`B#H2 +QKK2 mM2 7QM+iBQM TQm` +H+mH2`- 2M mM TQBMi [m2H+QM[m2- H pH2m` /2 H
7QM+iBQM TQHvMƬK2 bbQ+Bû2X *2ii2 7QM+iBQM T2mi ;B` û;H2K2Mi bm` mM i#H2m /2 pH2m`b- 2HH2 +H+mH2 HQ`b H
Texte
pH2m` /2 H 7QM+iBQM TQHvMƬK2 2M +?+mM /2b TQBMib BM/B[mûbX

TUyV
@jXy
TU(R- k- j)V
``vU( yX- NX- jyX)V

GǶii`B#mi +Q27 /QMM2 ++ĕb mt +Q2zB+B2Mib Q`/QMMûb T` /2;`û +`QBbbMi c BMbB TX+Q27(B) +Q``2bTQM/ m
+Q2zB+B2Mi /m i2`K2 /2 /2;`û BX G Kûi?Q/2 /2;`22 `2MpQB2 H2 /2;`û /m TQHvMƬK2 HQ`b [m2 `QQib +H+mH2 b2b
`+BM2bX

TX+Q27
``vU(@jX- kX- yX- RX)V
TX+Q27(R)
kXy
TX/2;`22UV
j
TX`QQibUV
``vU(@yX8@RXe83jRk9D- @yX8YRXe83jRk9D- RXyYyXD )V

G Kûi?Q/2 /2`Bp `2MpQB2 mM MQmp2m TQHvMƬK2- /û`Bpû /m TQHvMƬK2 BMBiBHX *2ii2 Kûi?Q/2 T`2M/ 2M `;mK2Mi
7+mHiiB7 mM 2MiB2` TQbBiB7 BM/B[mMi H2 MQK#`2 /2 /û`BpiBQMb ¨ 2z2+im2`X .2 H KāK2 KMBĕ`2 H Kûi?Q/2 BMi2;
BMiĕ;`2 H2 TQHvMƬK2- 2HH2 T`2M/ mM T`Kĕi`2 QTiBQMM2H bmTTHûK2MiB`2 /QMMMi H +QMbiMi2 /ǶBMiû;`iBQM
¨ miBHBb2`- +2 T`Kĕi`2b T2mi āi`2 mM2 HBbi2 2M +b /ǶBMiû;`iBQM KmHiBTH2 c H2b +QMbiMi2b /ǶBMiû;`iBQM MQM
T`û+Bbû2b bQMi T`Bb2b û;H2b ¨ xû`QX

TX/2`BpUVX+Q27
``vU( kX- yX- jX)V
TX/2`BpUkVX+Q27
``vU( yX- eX)V
TX/2`BpU8VX+Q27
``vU(@yX)V
TXBMi2;UVX+Q27
``vU( yX - @jX - RX - yX - yXk8)V
TXBMi2;UR- kVX+Q27 O BMiö;`2` mM2 7QBb p2+ H +QMbiMi2 k
``vU( kX - @jX - RX - yX - yXk8)V
TXBMi2;Uk- (R- k)VX+Q27 O BMiö;`2` /2mt 7QBb
``vU( kX - RX - @RX8 - yXjjjjjjjj- yX -
yXy8 )V

e DmBM kyR8 Rd,kN Svi?QM@TQHvMQK2b@R

G2b QTû`i2m`b Y- @- T2`K2ii2Mi /Ƕ//BiBQMM2`- bQmbi`B`2 2i KmHiBTHB2` /2b TQHvMƬK2bX AHb 7QM+iBQMM2Mi û;H2@
K2Mi 2Mi`2 mM TQHvMƬK2 2i mM b+HB`2X GǶQTû`i2m` T2`K2i /ǶûH2p2` mM TQHvMƬK2 ¨ mM2 TmBbbM+2 2MiBĕ`2
TQbBiBp2X

 4 SQHvMQKBHU(R- k- R)V
# 4 SQHvMQKBHU(8- j)V
T 4 k  # Y SQHvMQKBHU(@d- k)V
TX+Q27
``vU( jX- k3X- kkX- eX)V
UT kVX+Q27
``vU( NX- Re3X- NReX- Rke3X- 3kyX- ke9X- jeX)V

GǶQTû`i2m` f T2`K2i /2 /BpBb2` mM TQHvMƬK2 T` mM b+HB`2X SQm` /BpBb2` /2mt TQHvMƬK2b BH 7mi miBHBb2`
HǶQTû`i2m` ff [mB `2MpQB2 H2 [mQiB2Mi c HǶQTû`i2m` W +H+mH2 H2 `2bi2X

UT f kVX+Q27
``vU( RX8- R9X - RRX - jX )V
[ 4 T ff 
` 4 T W 
[X+Q27
``vU( RyX- eX)V
`X+Q27
``vU(@dX- kX)V
U[  Y `VX+Q27
``vU( jX- k3X- kkX- eX)V

e DmBM kyR8 Rd,kN Svi?QM@TQHvMQK2b@k

 Svi?QM
P`H
JS- S*- SaA- haA
S`Q##BHBiûb

G2b 7QM+iBQMb /Ƕû+?MiBHHQMM;2 2i /2 ;ûMû`iBQM /2 pH2m`b Tb2m/Q@HûiQB`2b bQMi `2;`QmTû2b /Mb H #B#HBQi?ĕ[m2
MmKTvX`M/QKX

BKTQ`i MmKTvX`M/QK b `/

GǶ2tT`2bbBQM `M/BMiU- #V T2`K2i /2 +?QBbB` mM 2MiB2` m ?b`/ /Mb HǶBMi2`pHH2 <<Ԑ ԑ<<X G 7QM+iBQM `M/BMi
T`2M/ mM i`QBbBĕK2 T`Kĕi`2 QTiBQMM2H T2`K2iiMi /Ƕ2z2+im2` THmbB2m`b iB`;2b 2i /2 `2MpQv2` H2b `ûbmHii bQmb
7Q`K2 /2 i#H2m Qm /2 Ki`B+2X

`/X`M/BMiUR- dV O mM HM+2` /2 /ö
k
`/X`M/BMiUR- d- kyV O ky HM+2`b /2 /ö
``vU(8- k- k- j- R- 8- 8- j- e- 9- k- e- e- 9- j- k- 9- 8- R- j)V
`/X`M/BMiUR- d- U9- 8VV O ky HM+2`b /2 /ö bQmb 7Q`K2 /^mM2 Ki`B+2 9t8
``vU((j- e- R- e- j)-
(8- R- e- k- k)-
(j- R- k- k- 8)-
(8- k- e- R- 9))V

G 7QM+iBQM `M/QK `2MpQB2 mM `û2H +QKT`Bb /Mb HǶBMi2`pHH2 < <X aB ԍ /ûbB;M2 H p`B#H2 HûiQB`2 +Q``2bTQM@
/Mi m `ûbmHii /2 H 7QM+iBQM `M/QK- HQ`b TQm` iQmi Ԑ 2i ԑ /Mb < > p2+ Ԑ ହ ԑ- QM  ԅ Ԑ ହ ԍ  ԑ  ԑ ਲ ԐX
*2ii2 7QM+iBQM ++2Ti2 mM T`Kĕi`2b QTiBQMM2H T2`K2iiMi /2 `ûHBb2` THmbB2m`b iB`;2b 2i /2 H2b `2MpQv2` bQmb
7Q`K2 /2 i#H2m Qm /2 Ki`B+2X

`/X`M/QKUV
yXNRe3yNkyRjdy3y9N
`/X`M/QKU9V
``vU( yXN3d933Nd- yX3e83NNdk- yX8je3jyyR- yX8ye3dj3e)V
`/X`M/QKUUk-9VV
``vU(( yXd3kjye33- yX3j3yj8ke- yXekydd98d- yXkd9jk3RN)-
( yXee8kkj3d- yXdRk83je8- yXk83Rj993- yXk33jjy39))V

G 7QM+iBQM #BMQKBH T2`K2i /2 bBKmH2` mM2 p`B#H2 HûiQB`2 bmBpMi mM2 HQB #BMQKBH2 /2 T`Kĕi`2b M 2i TX
1HH2 T2`K2i /QM+ û;H2K2Mi /2 bBKmH2` mM2 p`B#H2 HûiQB`2 bmBpMi mM2 HQB /2 "2`MQmHHB /2 T`Kĕi`2b T 2M
T`2MMi bBKTH2K2Mi ԝ  X *2ii2 7QM+iBQM T`2M/ mM i`QBbBĕK2 T`Kĕi`2 QTiBQMM2H [mB +Q``2bTQM/- +QKK2 TQm`
H2b 7QM+iBQMb T`û+û/2Mi2b- m MQK#`2 /2 pH2m`b ¨ Q#i2MB`X

`/X#BMQKBHURy- yXj- dV
``vU(k- k- k- k- k- 9- j)V
`/X#BMQKBHUR- yXe- kyV
``vU(y- R- R- R- R- y- R- R- y- y- y- R- R- R- R- y- R- R- R- R)V

G2b 7QM+iBQMb ;2QK2i`B+ 2i TQBbbQM 7QM+iBQMM2K2Mi

nt /2 H KāK2 KMBĕ`2 TQm` H2b HQBb ;ûQKûi`B[m2 Qm /2 SQBbbQMX

`/X;2QK2i`B+UyX8- 3V
``vU(R- R- j- R- j- k- 8- R)V
`/XTQBbbQMU9- R8V
``vU(8- k- j- 9- e- y- 8- j- R- 8- R- 8- N- 9- e)V

e DmBM kyR8 RN,R8 Svi?QM@`M/QK

2016
PC*

Annexe B

L’aide-mémoire Arts et Métiers Paristech

2015-2016 27/30
©2012-2013 - Laurent Pointal Mémento v1.2.2.1

Mémento Python 3
Licence Creative Commons Paternité 2

entier, flottant, complexe, booléen, chaîne

Types
int 783 0 -192 de base
float 9.23 0.0 -1.7e-6
complex 2.7+3.1j 1j 10-6 Types Conteneurs (listes, tuples, chaînes)
bool True False = séquences ordonnées, accès index rapide, valeurs répétables
str "Un\nDeux" 'L\'âme' list [1,5,9] ["x",11,8.9] ["mot"] []
retour à la ligne ' échappé tuple (1,5,9) 11,"y",7.4 ("mot",) ()
multiligne
"""X\tY\tZ non modifiable expression juste avec des virgules
1\t2\t3""" str en tant que séquence ordonnée de caractères
non modifiable,
séquence ordonnée de caractères tabulation

pour noms de variables, Identificateurs type(expression) Conversions

fonctions, modules, classes…
a‥zA‥Z_ suivi de a‥zA‥Z_0‥9
int("15") on peut spécifier la base du nombre entier en 2 paramètre nd

' accents possibles mais à éviter int(15.56) troncature de la partie décimale (round(15.56) pour entier arrondi)
' mots clés du langage interdits float("-11.24e8")
' distinction casse min/MAJ
str(78.3) et pour avoir la représentation littérale repr("Texte")
☺ a toto x7 y_max BigOne voir au verso le formatage de chaînes, qui permet un contrôle fin
☹ 8y and
bool utiliser des comparateurs (avec ==, !=, <, >, …), résultat logique booléen

Affectation de variables list("abc") utilise chaque élément de ['a','b','c']

la séquence en paramètre
x = 1.2+8+sin(0)
valeur ou expression de calcul
":".join(['toto','12','pswd']) 'toto:12:pswd'
nom de variable (identificateur)
chaîne de jointure séquence de chaînes
y,z,r = 9.2,-7.6,"bad"
noms de conteneur de plusieurs "Un blanc final \n".strip() "Un blanc final"
variables valeurs (ici un tuple)
incrémentation "des mots espacés".split() ['des','mots','espacés']
x+=3 décrémentation x-=2
"1,4,8,2".split(",") ['1','4','8','2']
x=None valeur constante «Pnon définiP» chaîne de séparation

Indexation des listes, tuples, chaînes de caractères...

index négatif -6 -5 -4 -3 -2 -1 len(lst) 6
index positif 0 1 2 3 4 5 accès individuel aux éléments par [index]
lst=[11, 67, "abc", 3.14, 42, 1968] lst[1]→67 lst[0]→11 le premier
tranche positive 0 1 2 3 4 5 6 lst[-2]→42 lst[-1]→1968 le dernier
tranche négative -6 -5 -4 -3 -2 -1 accès à des sous-séquences par [tranche début:tranche fin:pas]
lst[:-1]→[11,67,"abc",3.14,42] lst[1:3]→[67,"abc"]
lst[1:-1]→[67,"abc",3.14,42] lst[-3:-1]→[3.14,42]
lst[::2]→[11,"abc",42] lst[:3]→[11,67,"abc"]
lst[:]→[11,67,"abc",3.14,42,1968] lst[4:]→[42,1968]
Indication de tranche manquante → à partir du début / jusqu'à la fin.
Sur les séquences modifiables, utilisable pour suppression del lst[3:5] et modification par affectation lst[1:4]=['hop',9]

Logique booléenne Blocs d'instructions bloc d'instructions exécuté Instruction conditionnelle

Comparateurs: < > <= >= == != instruction parente: uniquement si une condition est vraie
≤ ≥ = ≠ if expression logique:
bloc d'instructions 1…
a and b et logique ⁝ bloc d'instructions
indentationP!

les deux en même temps

a or b ou logique instruction parente: combinable avec des sinon si, sinon si... et un seul sinon final.
l'un ou l'autre ou les deux bloc d'instructions 2… if x==42:
not a non logique
⁝ # bloc si expression logique x==42 vraie
True valeur constante vrai print("vérité vraie")
elif x>0:
False valeur constante faux instruction suivante après bloc 1 # bloc sinon si expression logique x>0 vraie
print("positivons")
else:
☝ nombres flottants… valeurs approchéesM! angles en radians Maths # bloc sinon des autres cas restants
print("ça veut pas")
Opérateurs: + - * / ** from math import sin,pi…
× ÷ ab
÷ entière reste ÷
sin(pi/4)→0.707… Complexes Opérations spécifiques
cos(2*pi/3)→-0.4999… z=1+2j aux entiers
(1+5.3)*2→12.6 z.real
acos(0.5)→1.0471… z.imag 17 % 5 reste et
abs(-3.2)→3.2 sqrt(81)→9.0 √ z.conjugate() 17 // 5 quotient
abs(z) dans la div. eucl. de 17 par 5
round(3.57,1)→3.6 log(e**2)→2.0 etc. (cf doc)
bloc d'instructions exécuté Instruction boucle conditionnelle bloc d'instructions exécuté pour Instruction boucle itérative
tant que la condition est vraie chaque élément d'un conteneur ou d'un itérateur
while expression logique: for variable in séquence:
s = 0
bloc d'instructions bloc d'instructions
i = 1 initialisations avant la boucle Parcours des valeurs de la séquence
s = "Du texte" initialisations avant la boucle
condition avec au moins une valeur variable (ici i) cpt = 0
while i <= 100: variable de boucle, valeur gérée par l'instruction for
# bloc exécuté tant que i ≤ 100 for c in s:
i=100 Comptage du nombre
if c == "e":
s = s + i**2 s= ∑ i
2 de e dans la chaîne.
i = i + 1 ☝ faire varier la variable cpt = cpt + 1
de conditionM!
i=1 print("trouvé",cpt,"'e'")
boucle sur dict/set = boucle sur séquence des clés
print("somme:",s) résultat de calcul après la boucle
utilisation des tranches pour parcourir un sous-ensemble de la séquence
☝ attention aux boucles sans finM! Parcours des index de la séquence
contrôle de boucle7: ' changement de l\élément à la position
break sortie immédiate continue itération suivante ' accès aux éléments autour de la position (avant/après)
lst = [11,18,9,12,23,4,17]
perdu = []
for idx in range(len(lst)): Bornage des valeurs
Affichage / Saisie val = lst[idx] supérieures à 15,
print("v=",3,"cmm:",x,",",y+4) mémorisation des
if val> 15:
valeurs perdues.
perdu.append(val)
éléments à afficherP: valeurs littérales, variables, expressions lst[idx] = 15
Options de print: print("modif:",lst,"-modif:",perdu)
' sep=" " (séparateur d\éléments, défaut espace) Parcours simultané index et valeur de la séquence:
' end="\n" (fin d\affichage, défaut fin de ligne) for idx,val in enumerate(lst):
' file=f (print vers fichier, défaut sortie standard)
s = input("Directives:") très utilisé pour les Génération de séquences d'entiers
boucles itératives for par défaut 0 non compris
☝ input retourne toujours une chaîne, la convertir vers le type range([début,] fin [,pas])
désiré (cf encadré Conversions au recto).
range(5) 0 1 2 3 4
Opérations sur conteneurs range(3,8) 3 4 5 6 7
len(c)→ nb d\éléments range(2,12,3) 2 5 8 11
min(c) max(c) sum(c) (listes, tuples, chaînes)
range retourne un «PgénérateurP», faire une conversion
sorted(c) → copie triée en liste pour voir les valeurs, par exemple:
val in c → booléen, opérateur in de test de présence (not in d\absence) print(list(range(4)))
enumerate(c)→ itérateur sur (index,valeur)
Spécifique aux conteneurs de séquences (listes, tuples, chaînes) :
reversed(c)→ itérateur inversé c*5 → duplication c+c2 → concaténation nom de la fonction (identificateur) Définition de fonction
c.index(val) → position c.count(val)→ nb d\occurences paramètres nommés
def nomfct(p_x,p_y,p_z):
☝ modification de la liste originale Opérations spécifiques aux listes """documentation"""
lst.append(item) ajout d\un élément à la fin # bloc instructions, calcul de res, etc.
lst.extend(seq) ajout d\une séquence d\éléments à la fin
lst.insert(idx,val) insertion d\un élément à une position
return res valeur résultat de l\appel.
si pas de résultat calculé à
lst.remove(val) suppression d\un élément à partir de sa valeur ☝ les paramètres et toutes les
lst.pop(idx) suppression de l\élément à une position et retour de la valeur variables de ce bloc n\existent retournerP: return None
lst.sort() lst.reverse() tri / inversion de la liste sur place que dans le bloc et pendant l\appel à la fonction («Mboite noireM»)
Appel de fonction
Listes par compréhension r = nomfct(3,i+2,2*i)
lst = [2*i for i in range(10)] un argument par paramètre
lst = [i for i in range(20) if i%2 == 0] récupération du résultat renvoyé (si nécessaire)
lstP= [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
Ce mémento est fourni à titre indicatif. Il ne faut le considérerM:
! ni comme exhaustif (en cas de problème sur un exercice particulier, si une
stockage de données sur disque, et relecture Fichiers fonction ou une commande indispensable était absente de la liste,
f = open("fic.txt","r",encoding="utf8") l'interrogateur pourrait aider le candidat),
! ni comme exclusif (une fonction ou une commande absente de cette liste
n'est pas interditeM: si un candidat utilise à très bon escient d'autres
variable nom du fichier mode d\ouverture encodage des fonctions MAIS sait aussi répondre aux questions sur les fonctions de base,
fichier pour sur le disque, ' 'r' lecture (read) caractères pour les il n'y a pas de problème),
les opérations chemin, relatif ' 'w' écriture (write) fichiers textes: ! ni comme un minimum à connaître absolument (l'examinateur n'attend
ou absolu ' 'a' ajout (append)… utf8 ascii pas du candidat qu'il connaisse parfaitement toutes ces fonctions et ces
latin1 … commandes).
en écriture chaîne vide si fin de fichier en lecture Les fonctions et commandes présentées doivent simplement permettre de faire
les exercices proposés aux candidats.
f.write("coucou") s = f.read(4)si nb de caractères L'examinateur n'attend pas du candidat une connaissance encyclopédique du
☝ fichier texte → lecture / écriture lecture ligne pas précisé, lit tout langage Python, mais une utilisation raisonnée des principes algorithmiques et
de chaînes uniquement, convertir suivante le fichier une mise en pratique des connaissances de base.
de/vers le type désiré s = f.readline() L'utilisation de l'aide en ligne est encouragée, mais ne doit pas masquer une
f.close() ☝ ne pas oublier de refermer le fichier après son utilisationP! ignorance sur ces aptitudes.
Aide
très courantP: boucle itérative de lecture des lignes d\un fichier texteP: help(a) → aide sur a dir(a) → liste d\attributs de a F1
for ligne in fm: help("module.obj")→ aide sur obj de module, sans avoir
bloc de traitement de la ligne besoin d\importer le module
 Mémento numérique Python 3
import numpy as np → charge le module numpy sous le nom np
Construction de tableaux (de type ndarray)
np.zeros(n)→ crée un vecteur dont les n
composantes sont nulles
np.zeros((n,m))→ crée une matrice n × m,
dont les éléments sont nuls
np.eye(n)→ crée la matrice identité d\ordre n
np.linspace(a,b,n)→ crée un vecteur de
n valeurs régulièrement espacées de a à b
np.arange(a,b,dx)→ crée un vecteur de
valeurs de a incluse à b exclue avec un pas dx
M.shape → tuple donnant les dimensions de M
M.size → le nombre d\éléments de M
M.ndim → le nombre de dimensions de M
M.sum() → somme de tous les éléments de M
M.min() → plus petit élément de M
M.max() → plus grand élément de M
argument axisPoptionnel : 0 → lignes, 1 → colonnesP:
M.sum(0)→ somme des lignes
M.min(0) → plus petits éléments, sur chaque colonne
M.max(1) → plus grands éléments, sur chaque ligne
import numpy.linalg as la
la.det(M)→ déterminant de la matrice carrée M
la.inv(M) → inverse de M
la.eigvals(M) → valeurs propres de M
la.matrix_rank(M)→ rang de M
la.matrix_power(M,n)→ M n (n entier)
la.solve(A,B)→ renvoie X tel que A X = B
import scipy.integrate as spi
spi.odeint(F,Y0,LT)
→ renvoie une solution numérique du problème de
Cauchy Y\(t) = F(Y(t), t ) , où Y est un vecteur
d\ordre n, avec la condition initiale Y(t0) = Y0,
pour les valeurs de t dans la liste LT de longueur k
commençant par t0, sous forme d\une matrice n× k
spi.quad(f,a,b) → renvoie une évaluation
b ni comme exclusif, ni comme un minimum à connaître absolument (l'examinateur n'attend
numérique de l\intégraleP: ∫ f (t)dt
a
Conversion ndarray <-> liste
V = np.array([1,2,3])→ VP: vecteur (1 2 3)
L = V.tolist() → LP: liste [1, 2, 3]
M = np.array([[1,2],[3,4]])→ MP: matrice ( )
1 2
3 4
L = M.tolist() → LP: liste [[1, 2], [3,4]]
Extraction d'une partie de matrice
M[i], M[i,:] → ligne de M d\index i
M[:,j] → colonne de M d\index j
M[i:i+h,j:j+l] → sous-matrice h × l
Copier un tableau avec la méthode copyP:
M2 = M1.copy()
M1+M2, M1*M2, M**2 → opérations «Pterme-à-termeP»
c*M → multiplication de la matrice M par le scalaire c
M+c → matrice obtenue en ajoutant le scalaire c à chaque terme de M
V1.dot(V2) → renvoie le produit scalaire de deux vecteurs
np.dot(V1,V2)
M.dot(V) → renvoie le produit d\une matrice par un vecteur
np.dot(M,V)
M1.dot(M2) → renvoie le produit de deux matrices
np.dot(M1,M2)
M.transpose() → renvoie une copie de M transposée
np.transpose(M) (ne modifie pas M)
M.trace() → renvoie la trace de M
np.trace(M)
Fonctions mathématiques usuelles
np.exp, np.sin, np.cos, np.sqrt etc.
→ fonctions qui s\appliquent sur des réels ou des complexes, mais aussi sur
des vecteurs et des matrices (s\appliquent à chaque terme), qui sont
optimisées en durée de calcul.
RappelM: ce mémento est fourni à titre indicatif. Il ne faut le considérerMni comme exhaustif,
pas du candidat qu'il connaisse parfaitement toutes ces fonctions et ces commandes).