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

Contenu supprimé Contenu ajouté
calcul vectorisé
Ligne 58 :
plt.hist(B, bins=10, density=1)
</source>
 
== 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 :
 
<source lang="python">
x = np.linspace(0, 2*np.pi, 50) # 50 points entre 0 et 2π
y = np.sin(x)
plt.plot(x, y)
</source>
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>.
 
Outre le tranchage ''({{lang|en|slicing}})'', on peut utiliser deux autres méthodes pour extraire certaines valeurs d'une matrice :
* utiliser un vecteur ou une matrice d'indices, Python extrait alors les valeurs correspondant aux indices ;
* 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 :
 
<source lang="python">
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])
</source>
 
'''Exercice'''
Écrire un programme Python mettant en œuvre le [[w:crible d'Érathostène|crible d'Érathostène]] pour trouver les nombres premiers inférieurs à une valeur donnée.
 
{{boîte déroulante début|Solution}}
<source lang="python">
#!/usr/bin/env python
# coding: utf-8
 
import numpy as np
import matplotlib.pyplot as plt
 
# ***************
# ***************
# ** Fonctions **
# ***************
# ***************
 
def eratosthene(limite):
# Détermine la liste des nombres premiers entre 1 et N
# par le crible d'Ératosthène
# Entrées : limite : nombre entier, N
# Sorties : liste : vecteur d'entiers,liste des nombres premiers
indices = (np.ones(limite) == 1) # vecteur de booléens tous à True
# à la fin, indice(i-1) est True si i est premier, False sinon
indices[0]=False # 1 n'est pas premier
imax = int(limite)
i = 2 # initialisation
repete = (i <= imax)
while repete:
if indices[i-1]:
jmax = int(limite/i)
j = np.arange(1, jmax)+1
indices[i*j-1]=False # élimination des multiples de i
test = (i*jmax == imax)
i = i + 1
repete = i*i < limite # condition d'arrêt
liste0 = np.arange(limite)
liste = liste0[indices]+1
return liste
 
# *************************
# *************************
# ** Programme principal **
# *************************
# *************************
 
print("***** Recherche de nombres premiers par le crible d'Ératosthène *****\n")
 
nmax = eval(input("Entrez la valeur maximale : "))
resultat = eratosthene(nmax)
 
print("\n", resultat.shape[0], "nombres premiers entre 1 et", nmax, ":\n")
print(resultat)
 
plt.plot(resultat, np.zeros_like(resultat), "|")
</source>
{{boîte déroulante fin}}
 
== Fonctions et méthodes de base ==
 
== Notes et références ==