math¶Python offre un module math fournissant des fonctions qui opèrent sur les données scalaires natifs (par exemple, float et complex). On suppose que les fonctions mathématiques doivent opérer sur des tableaux et des matrices et sont donc importées de NumPy.
+ correspond à l'addition
- correspond à la soustraction
* correspond à la multiplication
/ division
// division entière
** puissance ou exposant
Lorsque $x$ et $y$ sont des scalaires, le comportement de ces opérateurs est évident. Quand $x$ et $y$ sont des tableaux ou matrices, le comportement des opérations mathématiques est plus complexe. Les exemples de ce chapitre font référence à des tableaux et, sauf lorsque des différences explicites sont notées, il est prudent de supposer que le comportement des tableaux à 2 dimensions et des matrices est identique.
Les deux opérations - et + se font élément-par-élément.
*)¶L'opération * se fait élément par élément pour les vecteurs et correspond à la multiplication matricielle définie par l'algèbre linéaire dans le cas des matrices.
@)¶L'opérateur de multiplication de matrices @ a été introduit dans Python 3.5. Il ne peut être utilisé que sur deux tableaux et ne peut pas être utilisé pour multiplier un tableau et un scalaire. Si $x$ est $N \times M$ et $y$ est $K \times L$ et que les deux sont des matrices non-scalaires, alors l'opération x@y nécessite la compatibilité des dimensions $M = K$. De manière similaire, l'opération y@xnécessite la compatibilité $L=N$. Lorsque $x$ et $y$ sont deux tableaux, z=x@yproduit un tableau avec $z_{ij} = \sum_{k=1}^M x_{ik}y_{kj}$. Notes : les règles de multiplication pour @ correspondent à celles de la multiplication matricielle à l'exception de la multiplication de scalaires qui n'est pas possible. La multiplication d'un tableau par un scalaire fait appel à * et dot. x@y est identique à x.dot(y) ou np.dot(x,y).
import numpy as np
>>> x = np.array([[1.0, 2],[ 3, 2], [3, 4]])
>>> y = np.array([[9.0, 8],[7, 6]])
>>> x @ y
>>> x.dot(y)
>>> 2 @ x # Error
>>> 2 * x
/)¶La division se fait élément par élément.
**)¶Élever un tableau à une puissance opère élément par élement. Le cas des matrices fait exception où seules les matrices carrées peuvent être élevées à une puissance.
Lorsque $x$ est une matrice carrée et $y$ est un entier positif, x** y produit x*x*...*x ($y$ fois). Lorsque $y$ est un entier négatif, x**y produit inv(x**abs(y)) où inv produit l'inverse, et donc x doit être de rang plein. Python ne prend pas en charge les valeurs non entières pour y, bien que $x^p$ puisse être défini (en algèbre linéaire) à l'aide de valeurs propres et de vecteurs propres pour un sous-ensemble de toutes les matrices.
La transposition de matrice se fait à l'aide de .T ou la fonction transpose. Par exemple, si x est une matrice $M \times N$, transpose(x), x.transpose() et x.T sont tous ses transposés avec les dimensions $N \times M$. En pratique, l’utilisation du .T est la méthode préférée et améliorera la lisibilité du code.
>>> x = np.asmatrix(np.random.randn(2,2))
>>> xpx1 = x.T * x
>>> xpx2 = x.transpose() * x
>>> xpx3 = np.transpose(x) * x
(), [], (,) parenthèses, listes et tuple** puissance~ bitwise NOT *, /, //, % multiplication, division, et modulo +,- addition et soustraction& bitwise AND^ bitwise XOR| bitwise OR<, <=, >, >= opérateurs de comparaisons==, != opérateurs d'égalité in, not, in opérateurs d'identité =, +=, -=, /= opérateurs d'affectation