.. include:: special.rst
Memento numpy
+++++++++++++
La bibliothèque ``numpy`` est capable de gérer des variables de typé ``array``. Une variable du type ``array`` peut être vue comme une liste dont les éléments sont toujours du même type. C'est cette catégorie de variable que nous avons choisi d'utiliser pour représenter des vecteurs et des matrices.
Création de vecteurs et matrices
--------------------------------
Après avoir chargé la bibliothèque ``numpy`` par la commande :
.. code-block :: python
:linenos:
import numpy as np
La création d'un tel objet est réalisé comme suit
.. code-block :: python
:linenos:
a=np.array([[1,2,3],[4,5,6]],float)
b=np.array([1,2,3])
bb=b.copy() # Copie du tableau dans une autre variable
Lors de la création d'une variable ``array``, un secon argument optionnel permet de spécifier le type des éléments qu'elle contient.
.. list-table ::
* - Commandes
- Utilité
* - :code:`np.array([elt1,elt2,...,eltn])`
- Création d'un vecteur ligne
* - :code:`np.array([[elt1],[elt2],...,[eltn]])`
- Création d'un vecteur colonne
* - :code:`copy()`
- Méthode pour copier une variable de type ``array``
* - :code:`x.size`
- Taille du vecteur **x** sous la forme d'un tuple
* - :code:`A.shape`
- Taille de la matrice **A** sous la forme d'un tuple
* - :code:`np.linspace(debut,fin,N)`
- Vecteur ligne avec ``N`` valeur équiréparties entre début et fin
* - :code:`np.linspace(debut,fin)`
- Vecteur ligne avec 50 valeurs équiréparties entre début et fin
* - :code:`np.arange(N)`
- Vecteur ligne avec le ``N`` entiers de 0 à ``N-1``
* - :code:`np.arange(a,b,pas)`
- Vecteur ligne avec les valeurs variant de ``a`` à ``b`` **exclus** distantes de ``pas``
* - :code:`np.zeros(n)`
- Vecteur ligne nul de taille ``n``
* - :code:`np.zeros((n,p))`
- Matrice nulle de taille ``n*p``
* - :code:`np.zeros_like(A)`
- Matrice nulle de même dimension que la matrice ``A``
* - :code:`np.eye(n)`
- Matrice de taille ``n*n`` avec des 1 sur la diagonale
* - :code:`np.ones(n)`
- Vecteur ligne ne contenant que la valeur 1, de taille ``n``
* - :code:`np.ones((n,p))`
- Matrice de taille ``n*p`` dont tous les éléments sont égaux à 1
* - :code:`np.eye(n,p)`
- Matrice de taille ``n*p`` avec des 1 sur la diagonale
* - :code:`np.diag(v)`
- Matrice diagonale dont la diagonale est le vecteur **v**
* - :code:`np.diag(v,k)`
- Matrice diagonale dont la diagonale *décalée* de :math:`k ∈ \mathbb{Z}` est le vecteur **v**
Opérations usuelles
-------------------
.. list-table ::
* - Commandes
- Utilité
* - :code:`A+B`
- Addition de deux matrices de même dimension
* - :code:`v+w`
- Addition de deux vecteur de même dimension
* - :code:`2+A(resp.2+v)`
- Ajout d'un scalaire à chaque coefficient d'un vecteur (resp. d'une matrice)
* - :code:`2*A(resp.2*v)`
- Multiplication d'un vecteur (resp. d'une matrice) par un scalaire
* - :code:`A***3(resp.v**3)`
- Matrice (resp. vecteur) dont tous les coefficients sont élevés au cube
* - :code:`1/A(resp.1/v)`
- Matrice (resp. vecteur) dont tous les coefficients sont donnés par :math:`x→\frac{1}{x}`
* - :code:`np.sin(A)`
- Sinus de tous les termes de la matrice **A**
Opérations d'algèbre linéaire
-----------------------------
.. list-table ::
* - Commandes
- Utilité
* - :code:`np.dot(A,B)`
- Produit matriciel de `AB`
* - :code:`np.dot(A,v)`
- Produit de `Av`
* - :code:`np.dot(v,A)`
- Produit de **v** :math:`^T` **A**
* - :code:`np.vdot(v,w)`
- Produit scalaire < **v** , **w** > = **v** :math:`^T` **w**
* - :code:`A.transpose()`
- **A** :math:`^T` transposée de la matrice **A**
Pour inverser une matrice, il faut appeler la méthode ``inv`` de la bibliothèque ``linalg`` de ``numpy``. Dans le préambule, il faut donc ajouter:
.. code-block :: python
:linenos:
import numpy.linalg as linalg
L'inversion d'une matrice peut s'obtenir à l'aide du code ci-après
.. code-block :: python
:linenos:
A=np.array([[1,0,0],[0,1,2],[0,2,1]])
linalg.inv(A)
Autres opérations utiles
------------------------
.. list-table ::
* - Commandes
- Utilité
* - :code:`x.max()` (resp. `x.min()`)
- Plus grand (resp. plus petit) élément du vecteur **x**
* - :code:`A.max()` (resp. `A.min()`)
- Plus grand (resp. plus petit) élément de la matrice ``A``
* - :code:`A.max(0)` (resp. `A.min(0)`)
- Plus grands (resp. plus petits) éléments de chaque colonne de la matrice ``A``
* - :code:`A.max(1)` (resp. `A.min(1)`)
- Plus grands (resp. plus petits) éléments de chaque ligne de la matrice ``A``
* - :code:`x.mean()` (resp. `A.mean()`)
- Moyenne des éléments du vecteur **x** (resp. de la matrice ``A`` )
* - :code:`x.std()` (resp. `A.std()`)
- Écart-type des éléments du vecteur **x** (resp. de la matrice ``A`` )
* - :code:`x.sum()` (resp. `A.sum()`)
- Somme des éléments du vecteur **x** (resp. de la matrice ``A`` )
* - :code:`x.prod()` (resp. `A.prod()`)
- Produit des éléments du vecteur **x** (resp. de la matrice ``A`` )
* - :code:`x.cumsum()` (resp. `A.cumsum()`)
- Somme cumulée des éléments du vecteur **x** (resp. de la matrice ``A`` )
* - :code:`A[(A>1)]`
- Éléments de la matrice ``A`` strictement supérieur à 1
* - :code:`A[((A>1) & (A<=3))]`
- Éléments de la matrice`` A`` strictement supérieur à 1 et inférieurs ou égaux à 3
Redimensionnement
-----------------
.. warning::
``Numpy`` propose le redimentsionnement d'un tableau avec la fonction ``reshape`` avec la condition suivante :
**Le nombre d'éléments doit être inchangé.**
Tester le code suivant:
.. code-block :: python
:linenos:
a=np.arange(12)
print(a)
b=a.reshape(3,4)
print(b)
c=a.reshape(2,6)
print(c)
Concaténantion
--------------
``Numpy`` permet d'assembler les vecteurs et les matrices ( on parle de *concaténation*). Par défaut, l'assemblage se fait selon les lignes (l'axe horizontal), mais on peut aussi signifier que l'assemblage doit se faire selon les colonnes (l'axe vertical) avec l'otpion ``axis=1``.
Tester le code suivant :
.. code-block :: python
:linenos:
a=np.linspace(2,21,20).reshape(4,5)
print(a)
b=np.linspace(10,29,20).reshape(4,5)
print(b)
print(np.concatenate((a,b)))
print(np.concatenate((a,b),axis=1))
Accès aux termes d'une matrice
------------------------------
En tenant compte du fait que les lignes et les colonnes sont numérotées **à partir de 0**, on peut utiliser les commandes suivantes:
.. list-table ::
* - Commandes
- Utilité
* - :code:`A[i,j]`
- Accès à l'élément de **A** en *i*-ième ligne et *j*-ième colonne
* - :code:`A[i,:]`
- Ligne de *i* de **A**
* - :code:`A[:,j]`
- Colonne de *j* de **A** (résultat sous forme d'un vecteur ligne)
* - :code:`A[i1:i2,j1:j2]`
- Sous-matrice de la ligne i1 à i2 exclue et de la colonne j1 à j2 exclue
* - :code:`x[-1]`
- Retourne le dernier élément du vecteur **x**
* - :code:`A[-1,-1]`
- Retourne l'élément situé sur la dernière ligne et dernière colonne de la matrice **A**
* - :code:`A[-1]`
- Retourne la dernière ligne de la matrice **A**
Exercices
---------
*Exercice 10* - **Manipulations de vecteurs**
On donne:
:math:`u_1=\begin{bmatrix}1\\ 2\\ 3\end{bmatrix}` :math:`u_2=\begin{bmatrix}-5\\ 2\\ 1\end{bmatrix}` :math:`u_1=\begin{bmatrix}-1\\ -3\\ 7\end{bmatrix}`
1. Définir ces vecteurs.
2. Calculer :math:`u_1+u_2 , u_1+3u_2-5u_3 , u_3/5`
3. Calculer le produit des compansantes des vecteur :math:`u_1` et :math:`u_2`, terme à terme.
4. Calculer les produits :math:`u_1^Tu_2` et :math:`u_1u_2^T`.
5. Crée par concaténation la matrice : :math:`\begin{bmatrix}1 & -5 &-1 \\ 2 & 2 & -3 \\ 3 & 1 & 7\end{bmatrix}`
*Exercice 11* - **Opérations matricielles**
Soit le vecteur :math:`u=\begin{bmatrix}1\\2\\-5\\2\\-1\\-3\end{bmatrix}` .
1. Calculer la somme des composantes du vecteur **u** sans utiliser la fonction ``sum`` de ``numpy``
2. Calculer le produit des composantes du vecteur **u** sans utiliser la fonction ``prod`` de ``numpy``