« Python pour le calcul scientifique/Manipulation de matrices » : différence entre les versions

# Les matrices sont l'élément de base du calcul vectorisé qui permet un gain de temps appréciable.

Pour pouvoir expliter les matrices, il faut charger le module NumPy ; nous utilisons également Matplotlib pour les graphiques. Ainsi, les programmes contiennent tous au début :

import numpy as np

import matplotlib.pyplot as plt

 

== Définir un tenseur ==

 

'''Exemples'''

a = np.array([1, 3, 5, 7]) # vecteur

bc = np.array([[1], [2], [3], [4]]) # matrice 4 × 1 (matrice colonne)

[ 7, 6, 5]]]) # tenseur d'ordre 3, de dimension 3 × 2 × 2

Notez que dans NumPy, un vecteur n'est pas la même chose qu'une matrice ligne ou colonne. Un vecteur de dimension ''n'' est un tenseur d'ordre 1 et de dimension ''n'' ; une matrice ligne ou colonne est un tenseur d'ordre 2 et de dimension 1 × ''n'' ou ''n'' × 1.

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

b = np.array([[1, 2, 3]])

print(a.ndim, b.ndim, c.ndim) # 1 2 2

print(a.shape, b.shape, c.shape) # (3,) (1, 3) (3, 1)

 

La fonction <code>np.arange()</code> est similaire à la fonction <code>range()</code> pour les liste ; elle génère un vecteur de réels. La fonction <code>np.linspace()</code> permet également de créer un vecteur de même type mais on indique le dernier nombre alors que la règle du découpage en tranches fait que le nombre maximal indiqué à <code>np.arange()</code> est le premier nombre qui ne ''figure pas'' dans le vecteur.). La fonction <code>np.zeros()</code> génère une matrice nulle, <code>np.zeros_like()</code> une matrice nulle ayant les dimensions d'une matrice fournie comme modèle. De même, <code>np.ones()</code> et <code>np.ones_like()</code> crée des matrice dont toutes les composantes sont à 1. La fonction <code>np.eye()</code> crée une matrice unité.

 

'''Exemples'''

e = np.arange(0, 2, 0.1) # vecteur [0, 0.1, 0.2…, 1.8, 1.9]

f = np.linspace(0, 2, 5) # 5 nombre entre 0 et 2 soit le vecteur [0, 0.5, 1, 1.5, 2]

k = np.ones_like(a) # matrice de 1 de même dimension que a

u = np.eye(3) # matrice unité 3 × 3

Le paramètre <code>dtype</code> permet de forcer le type. Par exemple

a = np.array([1, 2, 3], dtype="complex")

k = np.ones_like(a, dtype="int")

 

La méthode <code>.reshape()</code> remet en forme une matrice. Par exemple, pour transformer un vecteur de dimension 9 en une matrice 3 × 3 :

a = np.arange(1, 10)

b = a.reshape(3, 3)

# ou bien directement

c = np.arange(1, 10).reshape(3, 3)

La méthode <code>.fill()</code> remplit la matrice avec un scalaire :

b.fill(5) # remplace les valeurs de b par la valeur 5

 

== Calcul vectorisé ==

Les fonctions de NumPy traitent en général les matrices en entier. Ainsi, il n'est pas nécessaire de créer une boucle pour faire défiler les indices un par un. Il en résulte un code clair et compact et surtout un plus grande rapidité d'exécution. Par exemple :

 

x = np.linspace(0, 2*np.pi, 50) # 50 points entre 0 et 2π

y = np.sin(x)

plt.plot(x, y)

La variable <code>x</code> est un vecteur de 50 valeurs et il est traité en une seule passe par la fonction sinus <code>np.sin()</code>.

 

* utiliser un vecteur ou une matrice de booléens de même dimension que a matrice ; Python extrait alors les valeurs correspondant aux <code>True</code>, la matrice booléenne est un « masque » pour la matrice d'origine. Par exemple :

 

a = np.arange(0, 10)

b = np.array([1, 3, 5, 7, 9])

c = np.array([True, True, False, False, True, False, True, False, False, True])

print(a[b], "\n", a[c])

 

'''Exercice'''

 

{{boîte déroulante début|Solution}}

#!/usr/bin/env python

# coding: utf-8

 

plt.plot(resultat, np.zeros_like(resultat), "|")

 

L'extraction par un vecteur d'indice intervient dans l'instruction :

indices[i*j-1]=False

qui élimine en une seule passe tous les multiples de ''i''. L'extraction par un vecteur booléen intervient dans l'instruction :

liste = liste0[indices]+1

qui permet d'extraire toutes la valeurs conservées en une seule passe.

{{boîte déroulante fin}}

* <code>.size</code> : nombre d'éléments ;

* <code>.dtype</code> : type des éléments.

a = np.linspace(1, 9, 9)

print("a", a, "\n",

" ; size : ", a.size,

" ; dtype : ", a.dtype, "\n")

* <code>.real</code>, <code>.imag</code> : parties réelle et imaginaire de la matrice ;

* <code>.flat</code> : liste des éléments de la matrice ; les éléments sont réorganisés en une liste ;

* <code>.T</code> : transposée.

print(a)

# [[0 1 2]

print(a.flat[:])

# array([0, 1, 2, 3, 4, 5, 6, 7, 8])

; Ressources

: Section « Attribute », {{lien web

* <code>.sum()</code>, <code>prod()</code> : somme et produit de tous les éléments de la matrice ;

* <code>.cumsum()</code>, <code>cumprod()</code> : somme et produit cumulés.

a = np.linspace(1, 9, 9)

print("min : ", a.min(),

"prod : ", a.prod(),

"; cumprod : ", a.cumprod(), "\n")

 

Méthodes statistiques :

* <code>.flatten()</code> : vecteur contenant les éléments réorganisés en liste ; par rapport à l'attribut <code>.flat</code>, on peut choisir le sens de linéarisation (par lignes, <code>.flatten(C)</code>, ou par colonnes, <code>.flatten(F)</code>) mais cela crée une copie, on ne peut pas par exemple s'en servir pour modifier la matrice ;

* <code>.tofile()</code> : crée un fichier texte contenant les valeurs de la matrice ; par exemple, pour une matrice <code>a</code> et pour séparer les valeurs par un point-virgule :

a.tofile("matriceA.txt", sep=" ; ")

 

Algèbre linéaire :

: <math>5 + \mathrm{A} = \begin{pmatrix} 5 & 5 \\ 5 & 5 \end{pmatrix} + \begin{pmatrix} 1 & 2 \\ 3 & 4 \end{pmatrix} </math>

:: La matrice (5) est de dimension 1 × 1, la valeur « 5 » est donc répétée dans les deux dimensions

A = np.array([[1, 2], [3, 4]])

print(5 + A)

# [[6 7]

# [7 8]]

: <math>(5, 4) + \mathrm{A} = \begin{pmatrix} 5 & 4 \\ 5 & 4 \end{pmatrix} + \begin{pmatrix} 1 & 2 \\ 3 & 4 \end{pmatrix} </math>

print(np.array([[5, 4]]) + A)

# [[6 6]

# [6 8]]

: <math>\begin{pmatrix} 5 \\ 4 \end{pmatrix} + \mathrm{A} = \begin{pmatrix} 5 & 5 \\ 4 & 4 \end{pmatrix} + \begin{pmatrix} 1 & 2 \\ 3 & 4 \end{pmatrix} </math>

print(np.array([[5], [4]]) + A)

# [[6 7]

# [7 8]]

 

== Fonctions « universelles » ==