Chap7 simulation numérique

[Simulation numérique] ESPRIMS’
Mariem ZAOUALI | Chapitre 7 : Simulation numérique 1
Chapitre 7 : Simulation numérique
Les points abordés dans ce chapitre :
 Système de numération
 Manipulation de Numpy, matlibplot et scipy
1. Système de numération
a. Représentation du nombre dans une base b
Nous représentons un nombre dans un système de numération par position :
 Nous disposons d’un jeu fini (souvent court) de chiffres pour écrire les
nombres.
 La signification de chaque chiffre dépend de sa position dans le nombre
Pour écrire un nombre entier en base 10 :
= × 10
Avec k∈ et ∀ , un entier naturel tel que 0 ≤ ≤ 9. Nous disposons de 10
chiffres : 0,1,2,3,4,5,6,7,8,9 pour représenter un nombre dans la base 10.
Exemple : Ecrire 1458 comme une combinaison linéaire de puissance de 10.
Solution : 1458 = 1 × 10 + 4 × 10 + 5 × 10
Pour écrire un nombre entier en base 2 :
= × 2
Avec k∈ et ∀ , un entier naturel tel que 0 ≤ ≤ 1. Nous disposons de 2 chiffres :
0,1, pour représenter un nombre dans la base 2. Ceci fait que le plus grand nombre
codé sur n bits est 2 − 1.
Exemple 1 : Convertissez 1101 en base 10.
Solution : = 1 × 1 + 0 × 2 + 1 × 2 + 1 × 2 = 1 + 0 + 4 + 8 = 13
Exemple 2 : Quel est le plus grand entier naturel codable sur 32 bits, écrit en base
10 ?
Solution : pour la base 2 : 2 − 1.
Pour passer de la base 10 à la base 2, nous utilisons la méthode suivante : Nous
divisons le nombre à convertir par 2. Nous re-divisons le quotient obtenu par 2
jusqu’à obtenir un quotient nul. Le nombre que nous cherchons sera la succession du

Mariem ZAOUALI | Système de numération 2
dernier reste obtenu jusqu’au premier organisé de gauche à droite. La figure
suivante illustre un exemple de conversion :
Figure 1 Conversion de la base 10 vers la base 2
Pour écrire un nombre entier en base b :
= ×
Avec k∈ et ∀ , un entier naturel tel que 0 ≤ ≤ − 1. Ceci fait que le plus
grand nombre codé sur n bits est − 1.
Exemple : Donner l’écriture décimale (3221)4.
Solution : = 1 × 1 + 2 × 4 + 2 × 4 + 3 × 4 = 233
Pour passer de la base décimale à la base b, nous utilisons la méthode précédente
de la division successive. La figure suivante montre un exemple de conversion :
Figure 2 Exemple de conversion de la base décimale vers la base 4
Pour passer de l’octal en binaire, nous remplaçons chaque chiffre octal par les trois
bits correspondants. Pour passer du binaire en octal, nous parcourons le nombre
binaire de la droite vers la gauche en regroupant les chiffres binaires par paquets de
3 (en complétant éventuellement par des zéros). Il suffit ensuite de remplacer
chaque paquet de 3 par le chiffre octal.
Exemple : 1001101011 à le convertir en base octale

Solution :00 1001101011 nous rajoutons les deux 0 pour pouvoir découper ce nombre
en des paquets de 3 chiffres ainsi :
D’où le nombre que nous cherchons est 1153 en base octale.
En hexadécimale, nous disposons de 16 chiffres :
Pour passer de l’hexadécimal en binaire, nous remplaçons chaque chiffre
hexadécimal par les quatre bits correspondants. Pour passer du binaire en
hexadécimal, nous parcourons le nombre binaire de la droite vers la gauche en
regroupant les chiffres binaires par paquets de 4 (en complétant éventuellement par
des zéros). Il suffit ensuite de remplacer chaque paquet de 4 par le chiffre
hexadécimal.
Exemple :
b. Dépassement
Côté ordinateur, si nous disposons de processeur de 32 bits, les entiers sont codés sur
4 octets (soit 32 bits). Exemple :
00010100001111000010000100110010
Si nous disposons de processeur de 64 bits, les entiers sont codés sur 8 octets (soit 64
bits). Exemple :
00000000 00000000 00000000 00000000 00010100 00111100 00100001 00110010
Dans le cas d’un nombre binaire, le bit de poids fort est le bit ayant dans une
représentation donnée la plus grande valeur (celui de gauche dans la
représentation positionnelle habituelle). Alors que le bit de poids faible est celui
ayant dans une représentation donnée la moindre valeur. Une valeur qui dépasse
celle là induit en une erreur de dépassement de capacité.
La représentation des entiers relatifs peut causer ce dépassement et ça peut coûter
très cher. La mission d’ARIANE 5 s’est terminée juste après 37 secondes du lancement
de la fusée. L’erreur provient du calcul de l’accélération horizontale qui est un
traitement élaboré pour la fusée ARIANE 4, dont l’accélération maximale pouvait
être codée sur 16 bits or les accélérations sont 5 fois plus fortes pour ARIANE 5.

Figure 3 Mission ARIANE 5
c. Opérations élémentaires : cas de la base 2
L’addition
Le principe de l’addition de deux nombres binaires est donné par le tableau suivant :
a b s=a+b r
0 0 0 0
0 1 1 0
1 0 1 0
1 1 0 1
Avec r est la retenue. Si nous avons à sommer 1+1 avec une retenue égale à 1, nous
mettons 1 et nous retenons 1.
En se basant sur ce tableau, nous pouvons calculer des nombres plus larges sur 16
bits :
Retenues 1 1 1 1 1 1 1 1 1 1
A 1 0 1 1 1 0 1 0 1 0 0 1 0 0 1 1
B 0 0 1 1 0 1 0 0 0 1 1 0 1 1 0 1
Somme 1 1 1 0 1 1 1 1 0 0 0 0 0 0 0 0
Si la somme des deux nombres provoque une retenue supplémentaire engendrant
un nombre sur 17 bits, nous parlons de dépassement de retenue. Des solutions
existent pour remédier à cela (retranchement de la retenue).
La représentation du nombre relatif
Le problème de la représentation des nombres relatifs se pose assez rapidement
lorsque l’on veut manipuler des mots formés par des bits à cause de l’absence des
symboles +/-. La représentation des nombres relatifs en base 2 consiste à utiliser un
bit supplémentaire pour le signe à gauche. Le bit de signe des nombres négatifs
dans la représentation binaire signée prend la valeur 1.

Mariem ZAOUALI | Numpy 5
Exemple : comment la représentation de (2)10 en binaire avec 4 bits (3 bits + 1 bit de
signe) en binaire signé.
 Je prends le nombre en question 010
 Je l’inverse 101
 Je rajoute 1 : 110
 Je rajoute à gauche le bit de signe 1110
Prenons un autre exemple (4)10 :
 Je prends le nombre en question 100
 Je l’inverse 011
 Je rajoute 1 : 100
 Je rajoute à gauche le bit de signe 1100
De ce fait, pour un nombre de bits donné, certaines valeurs sont impossible à
représenter en binaire signé.
2. Numpy
Pour pouvoir charger numpy, vous devez l’installer. Pour ce faire, ouvrez l’invite de
commande. Tapez pip install numpy. (il faut déjà inclure le répertoire de python et
celui de scripts dans les variables d’environnement). Dans ce qui suit, nous allons
considérer que les variables en minuscules sont des vecteurs ou un tableau
unidimensionnel et les variables en majuscules sont des matrices ou des tableaux à
deux dimensions.
a. Création des tableaux unidimensionnels et plus
Numpy est un module python conçu pour le calcul scientifique. Numpy a plusieurs
caractéristiques intéressantes, en voici quelques exemples :
 Les tableaux de Numpy sont des tableaux de taille N et représentent le
composant principal du calcul scientifique de Python
 Numpy présente des outils pour intégrer votre code avec un code existant
écrit en C,C++ ou Fortran
 Numpy offre des outils pour effectuer des opérations de l’algèbre linéaire,
générer des nombres aléatoires etc.
Les tableaux de Numpy sont destinés à représenter des vecteurs et des matrices.
Contrairement aux listes de Python augmentent de tailles automatiquement, les
tableaux du module Numpy ont une taille fixe qu’on désigne lors de leurs création.
De plus, leurs éléments sont du même type.
Par défaut, les éléments de ces tableaux sont des nombres. Commençons par la
construction d’un vecteur vide et d’une matrice vide.

Nous pouvons définir un tableau à deux dimensions. Pour ce faire, nous utilisons les
tuples. Dans ce cas, le premier argument renseigne sur le nombre des lignes et le
deuxième argument désigne le nombre de colonnes dans notre futur tableau.
Les deux méthodes zero_vector et zero_matrix vont permettre de créer
respectivement des vecteurs et des matrices initialisés par des zéros.
Nous pouvons aussi construire des tableaux avec la fonction np.ones et son index est
identique à la syntaxe de la fonction de zero.
Nous pouvons également utiliser la fonction np.empty(.) pour allouer un espace
mémoire pour un tableau sans qu’il soit initialisé.
Nous pouvons créer des tableaux numpy avec des valeurs spécifiques et nous
utilisons dans ce cas la fonction np.array. L’argument d’entrée de cette fonction est
une séquence de nombres.
Parfois, vous aurez besoin de transposer votre tableau ce qui veut dire que les lignes
deviennent des colonnes et vice versa.
La fonction numpy.arange(start(op),stop,step(op),dtype(op)) permet de retourner
un intervalle de nombre stocker dans un ndarry. Noter la différence
entre numpy.arange() et range() :
 numpy.arange() retourne un objet de type numpy.ndarray.
 range() retourne un objet de type range.

b. Indices et partitionnement des tableaux (slicing)
Indépendamment de sa dimension, vecteur ou matrice, nous pouvons indexer et
partitionner un tableau numpy. Les indices dans un vecteur commencent de 0. Dans
un tableau de deux dimensions, le premier indice concerne la ligne alors que le
deuxième spécifie la colonne. C’est dans la même logique.
Nous pouvons partitionner les tableaux numpy. Les mêmes règles sont maintenues,
nous commençons par le premier indice et nous n’atteignons jamais le dernier.
Nous pouvons additionner deux tableaux numpy ayant la même taille !
Un autre exemple :
Prenons le cas où notre tableau est multidimensionnel, le partitionnement avec
l’opérateur ‘ :’ nous fait retourner soit la ligne, soit la colonne toute entière.
Pour le cas d’un tableau de deux dimensions, l’usage d’un seul indice retourne la
ligne concernée, ce qui est cohérent avec la construction de 2D des tableaux sous
forme de listes de listes, où les listes internes correspondent aux lignes du tableau.

c. Indexation des tableaux
Les tableaux de numpy peuvent être indexés avec d’autres tableaux ou des
séquences comme les listes. Prenons quelques exemples :
Dans cet exemple, l’indice ou ind, a été défini comme étant une liste, mais nous
pouvons le définir en tant que tableau numpy.
Les tableaux numpy peuvent aussi être indexés par des indices logiques. En effet,
comme nous pouvons avoir un tableau de nombres, nous pouvons avoir des
tableaux remplis par des valeurs logiques true ou false.
Nous pouvons utiliser le tableau booléen, qu’on appelle aussi, tableau logique, pour
indexer un autre vecteur. Dans ce cas, Python retourne les éléments du tableau
ayant la valeur True dans le tableau logique.
Il est important de faire attention à ce niveau car ceci peut générer des erreurs.
Quand vous partitionnez votre tableau en utilisant l’opérateur « : », vous obtenez un
aperçu de l’objet. Ceci veut dire que si vous le modifiez, le tableau original sera aussi
modifié et c’est contrairement à ce que vous obtenez quand vous indexez un
tableau ! Dans ce cas, ce que vous obtenez n’est qu’une copie des données
originales.

d. Fonctions utiles pour les tableaux numpy
Numpy offre un ensemble de façons pour construire des tableaux avec des valeurs
de départ et de terminaison fixées de sorte que les autres éléments sont espacés de
manière uniforme.
Dans ce cas, numpy a créé un tableau linéairement espacés commençant de 0 et
se terminant à 100. Maintenant, nous nous intéressons à la construction d’un tableau
avec un total de 10 nombres à générer.
Mais faites attention, le premier argument à entrer dans la méthode logspace est le
log de la première valeur. Ce qui veut dire, si nous voulons commencer de 10, le
premier argument est 1 = log(10). De même pour le deuxième argument, qui
correspond à la valeur du dernier point de ce tableau qui est 100 et donc nous
mettons log(100)=2. Le troisième argument correspond comme précédemment au
nombre des éléments dans notre tableau. Le résultat est un tableau de 10 éléments,
le premier élément est 10 et le dernier est 100. Toutes les valeurs sont uniformément
espacées dans l’espace logarithmique. Prenons un autre exemple :
Pour déterminer le nombre d’éléments dans un tableau, nous utilisons shape :
size, nous retourne le nombre d’éléments du tableau.

Remarquez que vous n’avez pas de parenthèses devant shape et size car ce sont
des attributs des tableaux et non pas des méthodes.
Parfois, nous avons besoin de vérifier si un ou tous les éléments d’un tableau vérifient
une certaine condition logique. Nous utilisons la fonction np.any(.) ou np.all(.) pour le
faire.
Exemple :
e. Application de numpy dans l’algèbre linéaire
La transposée
Le rang d’une matrice
Inverse d’une matrice : np.linalg.inv(a) inverse d’une matrice carrée
Attention, il faut d’abord savoir si la matrice est inversible pour l’inverser, ou encore
rester critique vis à vis du résultat retourné. L’exemple suivant est caractéristique. (ici,
Les valeurs très grandes laissent tout de même planer un certain soupçon que la
matrice n’est pas inversible !)

Rappel : Une matrice carrée d'ordre
rang
Pour la résolution d’un système linéaire :
carrée et b un vecteur ou une matrice (avec condition de compatibilité)
Calcul du déterminant : np.linalg.det(a)
D’autres fonctionnalités à utiliser à savoir
 eye(n) : matrice d’identité
 diag(d0,…dn) : matrice diagonale de coefficients diagonaux d0..dn
 trace(A), transpose(A),power(A,n), linalg.inv(A)
inverse de la matrice A.
Enfin, nous présentons le module random de numpy. On supp
numpy.random a été importé sous le nom
Fonction
npr.randint(a)
npr.randint(a,b)
npr.random(a,b,n)
npr.random()
npr.sample(n)
npr.sample(tuple)
Mariem ZAOUALI |
Une matrice carrée d'ordre est inversible si et seulement si elle est de
résolution d’un système linéaire : np.linalg.solve(a,b) où a est une matrice
un vecteur ou une matrice (avec condition de compatibilité)
np.linalg.det(a) bien sûr !
D’autres fonctionnalités à utiliser à savoir :
: matrice d’identité
: matrice diagonale de coefficients diagonaux d0..dn
trace(A), transpose(A),power(A,n), linalg.inv(A) : trace, transposé, puissance,
inverse de la matrice A.
Enfin, nous présentons le module random de numpy. On supp
importé sous le nom npr.
Traitement à faire
Génère aléatoirement un entier de 0 à
a-1 inclus, de façon uniforme
b-1 inclus, de façon unifrome
Génère un tableau 1xn d’entiers
aléatoirement choisis uniformément
entre a et b-1
Génère aléatoirement un réel de [0,1[
de façon uniforme
Génère un np.array 1 ligne n colonnes
rempli aléatoirement par des rée
[0,1[ choisis uniformément
De même pour un tableau
multidimensionnel de taille définie par le
ESPRIMS’
| Numpy 11
est inversible si et seulement si elle est de
est une matrice
un vecteur ou une matrice (avec condition de compatibilité)
: matrice diagonale de coefficients diagonaux d0..dn
: trace, transposé, puissance,
Enfin, nous présentons le module random de numpy. On suppose que
1 inclus, de façon uniforme
us, de façon unifrome
Génère un tableau 1xn d’entiers
aléatoirement choisis uniformément
Génère aléatoirement un réel de [0,1[
Génère un np.array 1 ligne n colonnes
rempli aléatoirement par des réels de
[0,1[ choisis uniformément
De même pour un tableau
multidimensionnel de taille définie par le

Mariem ZAOUALI | Matplotlib 12
tuple
3. Matplotlib
Tout d’abord, ouvrez l’invite de commande pour installer numpy.
Tapez pip install matplotlib. (il faut déjà inclure le répertoire de
python et celui de scripts dans les variables d’environnement)
Matplotlib est une librairie qui produit des figures de qualité pour dessiner les courbes.
Nous pouvons les utiliser en mode prompt ou script. Matplotlib est une très large
bibliothèque et sa maitrise peut prendre du temps. Mais d’habitude, nous n’avons
pas besoin de tout savoir sur cette bibliothèque. Nous nous intéressons à pyplot.
Pyplot est une collection qui permet à matplotlib de fonctionner comme Matlab.
Pyplot est surtout intéressant quand on l’utilise en mode prompt. Nous l’utiliserons
pour visualiser les données.
Grâce à pyplot, nous pouvons tester des commandes sur la figure et la courbe en
cours. Nous utiliserons des tableaux numpy pour stocker les données que nous
voulons tracer leur graphique (ou courbe). Nous pouvons aussi utiliser les listes,
occasionnellement.
Comme vous l’avez bien remarqué, dire matplotlib.pyplot n’est pas pratique, du
coup nous utiliserons import matplotlib.pyplot as plt.
Puisque l’indexation de Python commence de 0, le premier élément du tableau
apparaîtra à la localisation x égale à 0. Le deuxième élément à x égale à 1 etc.
Nous pouvons utiliser une courbe pour indexer la deuxième.
Maintenant, affichons les courbes avec quelques modifications sur le rendu.

Mariem ZAOUALI | Matplotlib 13
Testons maintenant ce code :
a. import numpy as np
b. import matplotlib.pyplot as plt
c. x = np.linspace(0, 2*np.pi, 30)
d. y1 = np.cos(x)
e. y2 = np.sin(x)
f. plt.plot(x, y1, label="cos(x)")
g. plt.plot(x, y2, label="sin(x)")
h. plt.legend()
i. plt.show()
Qu’affiche-t-il?
_________________________________________________________________________
Ecrivons ce script et testons-le:
L’affichage nous donne :

Mariem ZAOUALI | Scipy 14
Et finalement, spécifions les intervalles de nos axes avec axis, les légendes avec le
mot clé label dans la méthode plot et l’appellation de la méthode legend.
Finalement, enregistrons notre figure sous forme de fichier pdf avec la méthode
savefig.
Vérifier maintenant que votre fichier pdf existe dans le répertoire où vous avez
enregistré votre script !
4. Scipy
Avec ce module, nous nous intéressons particulièrement aux problèmes scientifiques
suivants :
a. Résolution d’équations différentielles du premier ordre
La forme générale d’une équation de premier ordre est la suivante :

= ( ( ), )
( ) =
Pour résoudre cette équation, nous avons recours à une solution approchée. L’une
des méthodes est la méthode d’Euler :
 Nous cherchons à résoudre sur [t0,T] l’équation de la forme :
y' = f(y(t),t) avec y(t0) = y0
 Si y(t) est de classe C1 alors, connaissant y(ti ), nous pouvons évaluer de façon
approchée, y(ti+1)avec :
y(ti+1) = y(ti ) + y’(ti )(ti+1 −ti )
 Avec y’ = f(y(t),t), il vient y(ti+1) = y(ti ) + f(y(ti ),ti )(ti+1 −ti ).
 Sauf que nous ne connaissons pas les images y(ti ) sauf pour t0 = a.
 Nous calculons donc une valeur approchée 1 de y(t1) ainsi :
y(t1) ≈ 1= y0 + f(y0,t0)(t1 −t0)
 Par récurrence, nous déterminons tous les termes de la suite ( i) via le schéma
numérique d’Euler explicite :
i+1 = i+ f( i ,ti )(ti+1 −ti )
 Si en plus, le pas de discrétisation h = ti+1 −ti est constant : i+1 = i+1+ f( i,ti )h
avec ti = t0 + i.h
L’implémentation de la méthode d’Euler en python est la suivante :
Fonctions prédéfinies en python
Il s’agit du module integrate de la bibliothèque scipy qui permet de résoudre une
équation différentielle de premier ordre avec la fonction odeint :
b. Méthode de recherche de zéro d’une fonction
Résoudre une équation revient à rechercher le(s) zéros d’une fonction. Nous
montrons dans cette section deux méthodes :
 La recherche dichotomique du zéro d’une fonction
 La méthode de Newton

Principe de la méthode de dichotomie
Nous cherchons la racine x de l’équation f(x)=0 sous les conditions suivantes :
Soit [a,b] l’intervalle de recherche :
 f continue sur [a,b]
 f change de signe sur [a,b], f(a)f(b)<0
 Théorème des valeurs intermédiaires = existence d’au moins un 0 de f dans
[a,b]
Le principe de la recherche dichotomique est le suivant :
1. Nous coupons en deux récursivement l’intervalle de recherche courant
[ak ,bk ] en maintenant la condition f(ak ).f(bk ) < 0,
2. A chaque itération x ∈ [ak ,bk ],
3. Condition d’arrêt : soit ε l’erreur absolue maximale tolérée. Nous arrêtons
l’algorithme à l’itération n vérifiant bn −an < ε.
4. La valeur xdic renvoyée est alors telle que | xdic −x| ≤ ε /2 .
L’implémentation en python est la suivante :
Principe de la méthode de Newton
Considérons la courbe suivante :
Figure 4 Courbe de l'équation x²-2
Analysons les valeurs des abscisses un des points successifs de la tangente à cette
courbe, nous aurons :

u0 = 5, u1 = 2,7, u2 = 1,72, u3 = 1,441 395 349 u4 = 1,414 469 585 9
Nous remarquons que la suite un va converger vers √2 qui est la racine de l’équation
x²-2. La méthode de Newton repose sur ce principe :
 Nous approchons f par la tangente à sa courbe en Cf en u0 i.e :
f(x) = f(u0) + f’(u0)(x −u0) +O(x −u0)
 Nous approximons le zéro x de f par celui de sa tangente, u1
 Nous réitérons la méthode à partir d’u1
 Nous construisons ainsi la suite (un)n des zéros des tangentes à Cf en un
 Nous espérons que la suite converge vers x et si oui en un temps raisonnable
Conditions à respecter (nécessaires mais pas suffisantes) : connaître f et f’.
L’implémentation en Python est la suivante :
Attention ! La convergence globale de cet algorithme n’est pas assurée ! Il se peut
qu’il ne s’arrête pas ou renvoyer une valeur erronée. Nous privilégions la méthode
de Newton puisqu’elle est plus rapide si la fonction est convexe et on connaît qu’elle
a une racine. Sinon, on utilise la méthode dichotomique car elle est plus robuste.
Fonctions prédéfinies en python :
Pour la méthode de dichotomie, c’est la fonction bisect du module optimize de
scipy :
Pour la méthode de Newton, c’est la fonction newton du module optimize de scipy :

c. Méthode d’intégration
Le but est d’aborder le calcul numérique de l’intégrale d’une fonction f sur un
domaine fini délimité par ses bornes a et b :
( )
Méthode de rectangles
Le principe de la méthode est le suivant :
 Nous décomposons l’intervalle [a,b] en N intervalles Ik de longueur h : [a,a +
h], [a + h,a + 2h], . . ., [a + kh,a + (k + 1)h], . . . [b −h,b].
 Avec : Nh = b −a soit h = b −a N . h est appelé le pas d’intégration de
l’algorithme.
 Sur chaque intervalle Ik = [a + kh,a + (k + 1)h], nous approchons la fonction f
par la fonction : x → f(xk) où xk = a + kh.
Géométriquement, nous approchons l’aire sous la courbe représentative de f par la
somme des aires des rectangles de hauteur f(xk) et de largeur (xk+1 −xk ).
Figure 5 Méthode de rectangles
En Python, nous pouvont écrire la fonction suivante :

Méthode de trapèzes
Nous procèdons de manière analogue à la méthode des rectangles.
 Nous décomposons l’intervalle [a,b] en N intervalles Ik de longueur h : [a,a +
h], [a + h,a + 2h], . . ., [a + kh,a + (k + 1)h], . . . [b −h,b].
 Avec : Nh = b −a soit h = b −a N . h est appelé le pas d’intégration de
l’algorithme.
 C’est le choix de la fonction approchant f sur Ik = [a+kh,a+ (k + 1)h] qui est
différent : : x →
( ) ( )
(x −xk ) + f(xk ) avec xk = a + kh
Géométriquement, nous approchons l’aire sous la courbe représentative de f par la
somme des aires des trapèzes de largeur (xk+1 −xk ).
Figure 6 Méthode de trapèzes
En Python, nous pouvons écrire la fonction suivante :

Fonction prédéfinie en python
Python propose la fonction quad du module integrate de la bibliothèque scipy.
²
>>> from scipy import integrate
>>> x2 = lambda x: x**2
>>> integrate.quad(x2, 0, 4)
(21.333333333333332, 2.3684757858670003e-13)

Chap7 simulation numérique

Contenu connexe

Tendances

Similaire à Chap7 simulation numérique

Plus de Mariem ZAOUALI

Dernier

Chap7 simulation numérique