Préface du traducteur

Bonjour à tous, nous arrivons à la dernière partie. Bonne lecture!
Navigation:

Polynômes mathématiques

NumPy fournit des méthodes pour travailler avec des polynômes. En passant une liste de racines, vous pouvez obtenir les coefficients de l'équation:

>>> np.poly([-1, 1, 1, 10]) array([ 1, -11, 9, 11, -10])

Ici, le tableau renvoie les coefficients correspondant à l'équation:

x^{4} - 11 x^{3} + 9 x^{2} + 11 x - 10

$x ^ 4 - 11x ^ 3 + 9x ^ 2 + 11x - 10$ .
L'opération inverse peut également être effectuée: en passant la liste des coefficients, la fonction racine retournera toutes les racines du polynôme:

 >>> np.roots([1, 4, -2, 3]) array([-4.57974010+0.j , 0.28987005+0.75566815j, 0.28987005-0.75566815j])

Notez que dans cette équation

x^{3} + 4 x^{2} - 2 x + 3

$x ^ 3 + 4x ^ 2 - 2x + 3$ deux racines sont imaginaires.
Les coefficients polynomiaux peuvent être intégrés. Considérons l'intégration

x^{3} + x^{2} + x + 1

$x ^ 3 + x ^ 2 + x + 1$ dans

x^{4} / 4 + x^{3} / 3 + x^{2} / 2 + x + C

$x ^ 4/4 + x ^ 3/3 + x ^ 2/2 + x + C$ . Habituellement, la constante C est nulle:

 >>> np.polyint([1, 1, 1, 1]) array([ 0.25 , 0.33333333, 0.5 , 1. , 0. ])

De même, des dérivés peuvent être pris:

 >>> np.polyder([1./4., 1./3., 1./2., 1., 0.]) array([ 1., 1., 1., 1.])

Les fonctions polyadd, polysub, polymul et polydiv prennent également en charge la sommation, la soustraction, la multiplication et la division des coefficients polynomiaux, respectivement.
La fonction polyvalente substitue la valeur donnée au polynôme. Considérons un polynôme

x^{3} - 2 x^{2} + 2

$x ^ 3 - 2x ^ 2 + 2$ à x = 4:

 >>> np.polyval([1, -2, 0, 2], 4) 34

En conclusion, la fonction polyfit peut être utilisée pour sélectionner (interpoler) un polynôme d'un ordre donné à un ensemble de valeurs:

 >>> x = [1, 2, 3, 4, 5, 6, 7, 8] >>> y = [0, 2, 1, 3, 7, 10, 11, 19] >>> np.polyfit(x, y, 2) array([ 0.375 , -0.88690476, 1.05357143])

Le tableau renvoyé est une liste de coefficients polynomiaux. Des fonctions d'interpolation plus sophistiquées peuvent être trouvées dans SciPy.

Statistiques

En plus des fonctions mean, var et std, NumPy fournit d'autres méthodes pour travailler avec des statistiques dans des tableaux.
La médiane peut être trouvée comme ceci:

 >>> a = np.array([1, 4, 3, 8, 9, 2, 3], float) >>> np.median(a) 3.0

Le coefficient de corrélation pour certaines variables est observé plusieurs fois et peut être trouvé à partir de tableaux de la forme: [[x1, x2, ...], [y1, y2, ...], [z1, z2, ...], .. .], où x, y, z sont des observables quantiques différents et les nombres indiquent le nombre "d'observations":

 >>> a = np.array([[1, 2, 1, 3], [5, 3, 1, 8]], float) >>> c = np.corrcoef(a) >>> c array([[ 1. , 0.72870505], [ 0.72870505, 1. ]])

Nous avons un tableau retourné c [i, j] qui stocke le coefficient de corrélation pour les i-ème et j-ème observables quantiques.
De même, le moment de covariance peut être trouvé:

 >>> np.cov(a) array([[ 0.91666667, 2.08333333], [ 2.08333333, 8.91666667]])

Des nombres aléatoires

Une partie importante de chaque simulation est la possibilité de générer des nombres aléatoires. Pour ce faire, nous utilisons le générateur de nombres pseudo aléatoires intégré dans NumPy dans le sous-module aléatoire. Les nombres sont pseudo aléatoires, dans le sens où ils sont générés de manière déterministe à partir d'un nombre de graines, mais sont dispersés de manière aléatoire dans des similitudes statistiques. Pour générer NumPy utilise un algorithme spécial appelé Mersenne Twister.
Vous pouvez spécifier l'élément générateur d'une séquence de nombres aléatoires comme suit:

 >>> np.random.seed(293423)

La graine est un entier. Chaque programme qui commence par la même graine générera à chaque fois la même séquence de nombres. Cela peut être utile pour le débogage, mais en général, nous n'avons pas besoin de définir la valeur de départ, en fait, lorsque nous exécutons le programme plusieurs fois, nous voulons obtenir une séquence de chiffres différente à chaque fois. Si cette commande n'est pas exécutée, NumPy sélectionne automatiquement une graine aléatoire (basée sur le temps), qui est différente à chaque démarrage du programme.
Un tableau de nombres aléatoires à partir du demi-intervalle [0,0, 1,0) peut être généré comme suit:

 >>> np.random.rand(5) array([ 0.40783762, 0.7550402 , 0.00919317, 0.01713451, 0.95299583])

La fonction rand peut être utilisée pour générer des tableaux bidimensionnels, ou la fonction de remodelage peut être utilisée:

 >>> np.random.rand(2,3) array([[ 0.50431753, 0.48272463, 0.45811345], [ 0.18209476, 0.48631022, 0.49590404]]) >>> np.random.rand(6).reshape((2,3)) array([[ 0.72915152, 0.59423848, 0.25644881], [ 0.75965311, 0.52151819, 0.60084796]])

Pour générer un seul nombre aléatoire sur l'intervalle [0,0, 1,0):

 >>> np.random.random() 0.70110427435769551

Pour générer un entier aléatoire dans la plage [min, max), utilisez la fonction randint (min, max):

 >>> np.random.randint(5, 10) 9

Dans chacun de nos exemples, nous avons généré des nombres à partir d'une distribution uniforme continue. NumPy comprend également des générateurs pour d'autres distributions, telles que: Bêta, binôme, chi carré, Dirichlet, exponentiel, Fischer, Gamma, géométrique, Gambal, hypergéométrique, Laplace, logistique, lognormal, logarithmique, multinomial, multidimensionnel normal, binomial négatif, non central chi carré, Fischer décentré, normal (Gauss), Pareto, Poisson, puissance, Rayleigh, Cauchy, étudiant, triangulaire, Von Mies, Wald, Weibull et Zipf. Regardons deux exemples.
Pour générer à partir d'une distribution de Poisson discrète à λ = 6,0,

 >>> np.random.poisson(6.0) 5

Pour générer un nombre à partir de la distribution normale (gaussienne) avec une valeur moyenne de μ = 1,5 et un écart type σ = 4,0:

 >>> np.random.normal(1.5, 4.0) 0.83636555041094318

Pour obtenir un nombre à partir de la distribution normale (μ = 0, σ = 1), sans spécifier d'arguments:

 >>> np.random.normal() 0.27548716940682932

Pour générer plusieurs valeurs, utilisez l'argument taille:

 >>> np.random.normal(size=5) array([-1.67215088, 0.65813053, -0.70150614, 0.91452499, 0.71440557])

Le module de génération de nombres aléatoires peut également être utilisé pour distribuer aléatoirement des valeurs dans une liste. Cela peut être utile si nous voulons distribuer aléatoirement des valeurs dans une liste:

 >>> l = range(10) >>> l [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] >>> np.random.shuffle(l) >>> l [4, 9, 5, 0, 2, 7, 6, 8, 1, 3]

Notez que la fonction de lecture aléatoire modifie un tableau existant et n'en renvoie pas de nouveau.

Quelques informations supplémentaires

NumPy comprend de nombreuses autres fonctionnalités que nous n'avons pas mentionnées ici. En particulier, ce sont des fonctions pour travailler avec la transformée de Fourier discrète, des opérations plus complexes en algèbre linéaire, tester des tableaux pour la taille / dimension / type, diviser et connecter des tableaux, des histogrammes, créer des tableaux à partir de n'importe quelle donnée de différentes manières, créer et exploiter des tableaux de grille , avec des valeurs spéciales (NaN, Inf), des opérations d'ensemble, la création de différents types de matrices spéciales et le calcul de fonctions mathématiques spéciales (Par exemple: fonctions de Bessel). Vous pouvez également consulter la documentation NumPy pour des détails plus précis.

Modules SciPy

SciPy étend très bien les fonctionnalités de NumPy. Nous ne parlerons pas de ses détails, mais considérons certaines de ses possibilités. La plupart des fonctions SciPy sont disponibles après l'importation du module:

 >>> import scipy

La fonction d'aide fournit des informations utiles sur SciPy:

>>> help(scipy)
Help on package scipy:

NAME
scipy
FILE
c:\python25\lib\site-packages\scipy\__init__.py
DESCRIPTION
SciPy --- A scientific computing package for Python
===================================================
Documentation is available in the docstrings and
online at http://docs.scipy.org.

Contents
--------
SciPy imports all the functions from the NumPy namespace, and in
addition provides:

Available subpackages
---------------------
odr --- Orthogonal Distance Regression [*]
misc --- Various utilities that don't have
another home.sparse.linalg.eigen.arpack --- Eigenvalue solver using iterative methods. [*]
fftpack --- Discrete Fourier Transform algorithms[*]
io --- Data input and output [*]
sparse.linalg.eigen.lobpcg --- Locally Optimal Block Preconditioned Conjugate Gradient Method (LOBPCG) [*]
special --- Airy Functions [*]
lib.blas --- Wrappers to BLAS library [*]
sparse.linalg.eigen --- Sparse Eigenvalue Solvers [*]
stats --- Statistical Functions [*]
lib --- Python wrappers to external libraries [*]
lib.lapack --- Wrappers to LAPACK library [*]
maxentropy --- Routines for fitting maximum entropymodels [*]
integrate --- Integration routines [*]
ndimage --- n-dimensional image package [*]
linalg --- Linear algebra routines [*]
spatial --- Spatial data structures and algorithms[*]
interpolate --- Interpolation Tools [*]
sparse.linalg --- Sparse Linear Algebra [*]
sparse.linalg.dsolve.umfpack --- :Interface to the UMFPACK library: [*]
sparse.linalg.dsolve --- Linear Solvers [*]
optimize --- Optimization Tools [*]
cluster --- Vector Quantization / Kmeans [*]
signal --- Signal Processing Tools [*]
sparse --- Sparse Matrices [*]
[*] - using a package requires explicit import (see pkgload)
...

Notez que certains sous-modules nécessitent directement une importation supplémentaire, qui sont marqués d'une étoile:

 >>> import scipy >>> import scipy.interpolate

Les fonctions de chaque module sont bien documentées dans les docstrings internes et dans la documentation officielle. La plupart d'entre eux fournissent directement des fonctions pour travailler avec des algorithmes numériques et ils sont très faciles à utiliser. Ainsi, SciPy peut économiser un temps gigantesque dans les calculs scientifiques, car Il fournit des fonctions déjà écrites et testées.
Nous ne considérerons pas SciPy en détail, mais le tableau ci-dessous couvrira certaines de ses fonctionnalités:

Module	À quoi sert
scipy.constants	Ensemble de constantes mathématiques et physiques
scipy.special	De nombreuses fonctions spéciales pour la physique mathématique, telles que: Airy, elliptique, Bessel, gamma, beta, hypergéométrique, cylindre parabolique, Mathieu, onde sphérique, Struve, Kelvin.
scipy.integrate	Fonctions pour travailler avec l'intégration numérique en utilisant les méthodes de trapèze, Simpson, Romberg et autres. Fournit également des méthodes pour travailler avec des équations différentielles complètes.
scipy.optimize	Méthodes standard haut / bas pour travailler avec des fonctions utilisateur génériques. Algorithmes inclus: Nelder - Mead, Pull ( Powell's ), gradients conjugués, Bruden - Fletcher - Goldfarb - Channo, moindres carrés, optimisation conditionnelle, recuit simulé, recherche exhaustive, Brent, Newton, bissection, Broyden, Anderson et recherche linéaire.
scipy.linalg	Fonctionnalité plus large pour travailler avec l'algèbre linéaire que dans NumPy. Fournit plus d'options pour utiliser des fonctions spéciales et rapides pour des objets spécifiques (par exemple: une matrice à trois diagonales). Méthodes incluses: recherche d'une matrice non dégénérée, recherche d'un déterminant, solution de systèmes d'équations linéaires, calcul de normes et d'une matrice pseudoinverse, décomposition spectrale, décomposition singulière, décomposition LU, décomposition Cholesky, décomposition QR, décomposition Schur, et de nombreuses autres opérations mathématiques pour travailler avec des matrices.
scipy.sparse	Fonctions pour travailler avec de grandes matrices clairsemées
scipy.interpolate	Méthodes et classes d'interpolation d'objets pouvant être utilisées pour des données numériques discrètes. L'interpolation linéaire et spline ( traducteur de notes : représentation mathématique des courbes lisses ) est disponible pour les ensembles de données unidimensionnels et bidimensionnels.
scipy.fftpack	Méthodes de traitement des transformées de Fourier.
scipy.signal	Méthodes de traitement des signaux, par exemple: convolution de fonction, corrélation, transformée de Fourier discrète, lissage B-spline, filtrage, etc., etc.
scipy.stats	Une grande bibliothèque de fonctions statistiques et de distributions pour travailler avec des ensembles de données.

Un grand groupe de développeurs continue de développer en permanence de nouvelles fonctionnalités SciPy. Une bonne approche pratique est la suivante: si vous envisagez d'implémenter des fonctions et des méthodes numériques dans votre code, vous pouvez d'abord consulter la documentation originale de SciPy. Il est possible que quelqu'un ait déjà implémenté et contribué à SciPy.

Postface

Notre série d'articles est terminée. Merci à tous ceux qui ont lu et pris le temps. J'espère également que vous avez apporté des informations utiles et appris quelque chose de nouveau. Continuez à développer et à apprendre de nouvelles choses! A bientôt.

NumPy en Python. Partie 4