Ingenieurie Numerique PDF

L’informatique en classes préparatoires (Samir ANTER) 73 L’informatique en classes préparatoires (Samir ANTER) 74
Résolution numérique des équations :

Exercices ingénierie numérique et
f ( x) = 0 ∀x ∈[a, b] (E)
simulation Il s’agit de déterminer la solution numérique l ∈ [a, b] de l’équation (E) avec une
précision p donnée.
Extrait de l’épreuve zéro de mathématiquesoption MP en CCP
2015
Le code doit être écrit en langage Python (ou Scilab). En particulier, on prendra soin de
bien respecter l'indentation.
1. Écrire une fonction factorielle qui prend en argument un entier naturel n et
renvoie n! (on n'acceptera pas bien sûr de réponse utilisant la propre fonction
factorielle du module math de Python ou Scilab).
Méthode de la dichotomie
2. Écrire une fonction seuil qui prend en argument un entier M et renvoie le plus
petit entier naturel n tel que n! > M. Étant donnée (a, b) ∈ R 2 et une fonction f ( x) continue sur l’intervalle [a, b] telle que
3. Écrire une fonction booléenne nommée est_divisible, qui prend en f (a) × f (b) < 0. Soit p ∈R la précision considérée. La méthode de dichotomie consiste à :
argument un entier naturel n et renvoie True si n!est divisible par n + 1 et
False sinon. a+b
- Calculer la valeur m = puis on coupe l’intervalle en deux en fonction du signe du
4. On considère la fonction suivante nommée mystere : 2
produit f (a) × f (m) :
def mystere(n) :
o Si f (a) × f (m) < 0 alors on considère l’intervalle [a, m] .
s = 0
o Si f (a) × f (m) ≥ 0 alors on considère l’intervalle [m, b] .
for k in range(1,n+1):
- Si l’amplitude de l’intervalle est inferieure à la précision p considérée, on arrête le
s = s + factorielle(k) processus, sinon on calcule une nouvelle valeur de m.
return s 1. Écrivez la fonction dichotomie(f, a, b, epsilon) permettant de retourner les
bornes de l’intervalle qui encadre la solution de l’équation (E) dont l’amplitude est
d. Quelle valeur renvoie mystere(4) ? inférieur à epsilon.
e. Déterminer le nombre de multiplications qu'effectue mystere(n). (a) En utilisant une fonction itérative
f. Proposer une amélioration du script de la fonction mystere afin d'obtenir (b) En utilisant une fonction récursive.
une complexité linéaire.
2. Écrivez un programme de test pour f ( x) = x 2 -10, a = 1, b = 10 et p = 10−4
Calcule de π
Applications
3. Ecrire la fonction pi(epsilon)permettant de calculer la valeur approchée de π en
utilisant le développement suivant : En utilisant les fonctions usuelles du module mathématique de Python, appliquez la
dichotomie entre [2, 4] à la fonction sin pour trouver une valeur approchée de π .
π 1 1 1 1 1
= 1 − + − + − + ... Comparez la valeur obtenue par cette méthode avec celle obtenue avec la méthode de
4 3 5 7 9 11
développement limité utilisé plus haut.
1
et en s’arrêtant lorsque le terme du développement soit plus petit qu’un réel epsilon. De la même façon, calculez la valeur approché de 2.
k
4. Ecrire un programme principal permettant de tester la fonction pi sur différentes valeurs
d’epsilon.
Samir Anter professeur d’informatique au CPGE Selmane el farissi-SALE et Ibn ghazi – Rabat Samir Anter professeur d’informatique au CPGE Selmane el farissi-SALE et Ibn ghazi – Rabat
Facebook : https://www.facebook.com/groups/infocpge/Email : antersamir@gmail.com Facebook : https://www.facebook.com/groups/infocpge/Email : antersamir@gmail.com
Principe de Lagrange Questions

1. Écrivez la fonction lagrange(f, a, b, epsilon) permettant de retourner la valeur
L’idée de la méthode de Lagrangeest très simple: pour une fonction f continue sur un
de am représentant la valeur approximative de la solution de l’équation f ( x) = 0.
intervalle [a, b] , on trace le segment [AB] où A = (a, f (a)) et B = (b, f (b)). Si le segment
reste au-dessus du graphe de f alors la fonction s’annule sur l’intervalle [a ', b] où (a ', 0) est 2. Écrivez un programme de test pour f ( x) = sin( x), a = 3, b = 4 et epsilon = 10−4
le point d’intersection de la droite (AB) avec l’axe des abscisses. La droite (AB) s’appelle la
Méthode de newton (tangente)
sécante. On recommence en partant maintenant de l’intervalle [a ', b] pour obtenir une valeur
a ''. La méthode de Newton consiste à remplacer la sécante de la méthode précédente par la
tangente.
Partons d’une fonction dérivable f :[a, b] → ° et d’un point u0 ∈[a, b].On appelle
(u1 , 0) l’intersection de la tangente au graphe de f en (u0 , f (u0 )) avec l’axe des abscisses. Si
u1 ∈[a, b] alors on recommence l’opération avec la tangente au point d’abscisse u1 . Ce
processus conduit à la définition d’une suite récurrente :
f (un )
u0 ∈ [a,b]( f 0) et un +1 = un −
f '(un )
L’hypothèse fconvexe signifie exactement que pour tout x ', x dans [a, b] la sécante Justification
entre ( x, f ( x)) et ( x ', f ( x ')) est au-dessus du graphe de f. La tangente au point d’abscisse un a pour équation : y = f '(un )( x − un ) + f (un ).Donc le
Justification point (un +1 , 0) appartenant à la tangente (et à l’axe des abscisses) vérifiant ainsi
L’équation de la droite passant par les deux points A = (a, f (a)) et B = (b, f (b)) est f (un )
0 = f '(un )(un+1 − un ) + f (un ) . D’où un +1 = un −
f (b) − f (a) f '(un )
y = ( x − a) + f (a) .
b−a Questions
Cette droite coupe l’axe des abscisses en ( a ', 0) qui vérifie donc 1. Écrivez la fonction newton( f , g , u0 , epsilon) permettant de retourner la valeur de am
f (b) − f (a) b−a représentant la valeur approximative de la solution de l’équation f ( x) = 0 ou
0 = (a '− a) + f (a) ainsi a' = a − f (a )
b−a f (b) − f (a) g ( x) = f '( x).
2. Écrivez un programme de test pour f ( x) = sin( x), u 0 = 4 et epsilon = 10 −4
La bibliothèque matplotlib plt.plot(X,Y,'b')

plt.legend(('f'),loc=2)
La bibliothèque matplotlib fournit des outils pour tracer des courbes et afficher des
images. plt.xlabel('x')
plt.ylabel('y')
Syntaxe Foncions de sous module pyplot de matplotlib.
plot Tracer une courbe à partir d’un tableau de valeurs plt.title("f(x)=exp(-x)*cos(2*pi*x)")
show Pour ouvrir une fenêtre et afficher l’image crée plt.show()
xlabel, ylabel Donner un nom aux axes
grid Ajouter une grille Dérivation numérique
title Titre du graphique
legend Ajouter une légende Pour calculer une valeur approchée de la dérivé d’une fonction numérique en un point,
f ( x) − f ( x0 )
Exemple : une première approche consiste à calculer un taux d’accroissement . Si la
x − x0
Traçons la courbe de la fonction : f ( x) = x 2 + 3x − 5 fonction f est suffisement régulière, alors f ( x0 + h) = f ( x0 ) + hf '( x0 ) + O(h) ce qui veut dire
f ( x0 + h) − f ( x0 )
import matplotlib.pyplot as plt que : f '( x0 ) = + O(h) Ainsi, la dérivée peut être approximée par la valeur
h
import numpy as np f ( x0 + h) − f ( x0 )
.
def f(x): h
return x**2+3*x-5 Voici une implémentation possible du calcule d’une valeur approchée d’une dérivée.
X=np.arange(-50,50,0.1) def derive1(f,x,h) :
Y=[f(x) for x in X]
return (f(x+h)-f(x))/h
plt.plot(X,Y,'b')
plt.legend(('f'),loc=2) Exemple :
plt.xlabel('x') import matplotlib.pyplot as plt
plt.ylabel('y') import numpy as np
plt.title("f(x)=x²+3x-5") def f(x):
plt.show() return np.cos(x)
Question : def g(x):
return -np.sin(x)
Tracer la courbe de la fonction f ( x) = e− x cos(2π x)
X=np.arange(0,5,0.1)
Réponse : Y=[g(x) for x in X]
plt.plot(X,Y,'r')
import matplotlib.pyplot as plt
DY1=[derive1f(f,x,0.01) for x in X]
import numpy as np
plt.plot(X,DY,'o')
def f(x):
plt.legend(("df","g"),loc=2)
return np.exp(-x)*np.cos(2*np.pi*x)
plt.title("f(x)=x²+3x-5")
X=np.arange(-10,10,0.1)
plt.show()
Y=[f(x) for x in X]
Question :Modifier la valeur de h et observer la différence. plt.plot(X,Y,'r')

En théorie, il suffit de prensdre h tres petit pour obtenir une grande précision dans le plt.plot(X,DY1,'bo')
calcul de la dérivée. Une deuxième méthode consiste à combiner f ( x + h) et f ( x − h) pour plt.plot(X,DY2,'go')
obtenir une meilleure approximation comme le prouve le calcul suivant. plt.legend(("g","derive1","derive2"),loc=2)
⎧ h² 2 plt.title("Dérivation (h="+str(h)+")")
⎪⎪ f ( x + h) = f ( x) + h. f '( x) + 2 f "( x) + o(h ) plt.show()
⎨
⎪ f ( x − h) = f ( x) − h. f '( x) + h² f "( x) + o(h 2 ) Intégration numérique
⎪⎩ 2
Soit une fonction f à valeur réelles, continue par morceaux sur un intervalle [a,b]. On
f ( x + h) − f ( x − h)
⇒ f '( x) = + o(h²) souhaite calculer une valeur approchée de l’intégrale ∫ f ( x)dx .
b
2h a
Cette formule approxime mieux la dérivé pour une même valeur de h ∈ ]0,1[ , car 1. Méthode des rectangles
l’erreur est ici en o( h ²) et non plus en o(h) . La méthode des rectangles consiste à approximer la fonction f par une fonction en
Voici le code en python : b−a
escalier. On considère un entier n et un pas de subdivision . Pour tout entier k de [0,n],
n
def derive2(f,x,h) :
b−a
on pose ak = a + k . Sur l’intervalle [ak , ak +1 ] , on approxime f par la fonction constante
return (f(x+h)-f(x-h))/(2*h) n
⎛ a + ak +1 ⎞
Exemple : égale à f ⎜ k ⎟.
⎝ 2 ⎠
import numpy as np
return (f(x+h)-f(x))/h
return (f(x+h)-f(x-h))/(2*h)
On prend, comme valeur approchée de l’intégrale de f sur [a,b], l’intégrale de la

fonction en escalier ainsi construite, c’est-à-dire la somme des aires des rectangles. Ainsi :
def f(x):
b b − a n −1 ⎛ b−a b−a ⎞
return np.cos(x)
∫a f ( x)dx ; ∑f
n k =0
⎜a +
⎝ 2n
+k
n ⎠
⎟
def g(x):
return -np.sin(x) Une implémentation en python est comme suit :
h=0.5 def rectangle(f,a,b,n) :
X=np.arange(0,5,0.1) pas=(b-a)/n
Y=[g(x) for x in X] s=0
DY1=[derive1(f,x,h) for x in X] for k in range(n) :
DY2=[derive2(f,x,h) for x in X] s=s+f(a+(1/2+k)*pas)
return s*pas
Exemple : b b − a ⎛ f (a ) + f (b) n −1 ⎞
import matplotlib.pyplot as plt ∫a f ( x)dx ; ⎜ + ∑ f (ak ) ⎟
import numpy as np n ⎜⎝ 2 k =1
⎟
⎠
#import random as rand
import math
def f(x):
return np.sin(x)
def p(x):
return -np.cos(x)

def rectangle(f,a,b,n) :
pas=(b-a)/n
s=0 Ainsi en python on obtient :
for k in range(n) :
def trapeze(f,a,b,n) :
s=s+f(a+(1/2+k)*pas)
return s*pas pas=(b-a)/n
s=0
n=10
N=100 for k in range(n) :
A=np.linspace(-5,5,N)#np.arange(-3,3,0.1) s=s+f(a+k*pas)
B=np.linspace(-1,1,N)#np.arange(-4,2,0.1)
X=[i for i in range(len(A))] return pas*(((f(a)+f(b))/2)+s)
Y1=[] Exemple :
Y2=[]

import numpy as np
for i in range(len(A)):
import random as rand
Y1.append(p(B[i])-p(A[i]))
import math
Y2.append(rectangle(f,A[i],B[i],n))
def f(x):

return np.sin(x)
plt.plot(X,Y1,'g')
def p(x):
plt.plot(X,Y2,'bo')
return -np.cos(x)

def trapeze(f,a,b,n) :
plt.legend(("int exact","rectangle"),loc=2)
pas=(b-a)/n
plt.title("Exemple d'integration de sin(x)")
s=0
plt.show()
for k in range(n) :
2. Méthode des trapèzes s=s+f(a+k*pas)
return pas*(((f(a)+f(b))/2)+s)
La méthode des trapèzes consiste à approximer la fonction f par une fonction continue n=100
affine par morceaux. Ceux-ci coïncident avec la fonction f aux points de la subdivision(figure N=100
A=np.linspace(-5,5,N)#np.arange(-3,3,0.1)
ci-dessous).
b−a X=[i for i in range(len(A))]
En notant ak = a + k les points de la subdivision du segment [a,b], l’aire de chaque Y1=[]
n Y2=[]
b − a f (ak ) + f (ak +1) for i in range(len(A)):
trapèze est égale à . Ainsi :
n 2 Y1.append(p(B[i])-p(A[i]))
Y2.append(trapeze(f,A[i],B[i],n))

plt.plot(X,Y1,'g') plt.plot(X,Y1,'g')
plt.plot(X,Y2,'bo') plt.plot(X,Y2,'bo')
plt.plot(X,Y3,'r-')
plt.legend(("pint exact","trapeze"),loc=2)
plt.title("Exemple integration sin(x)") plt.legend(("p","rectangle","trapeze"),loc=2)
plt.show() plt.title("comparaison entre les deux méthodes pour f(x)= sin(x)")
plt.show()
3. Comparaison entre la méthodes des trapèzes et la méthodes des réctangles On remarque que, pour la même valeur de n, la méthode des réctangles donne de bons
résultat que la méthodes des trapèzes.
Dans cette partie, nous allons comparer les deux méthodes. Pour ce faire nous allons
considérer la même valeur n et on trace les courbes pour les deux méthodes. Résolution approchée d'une équation différentielle
Exemple : Les équations différentielles modélisent de nombreux problèmes physiques (la chute
import matplotlib.pyplot as plt d'un corps, la trajectoire d'un satellite, la propagation d'une épidémie, la cinétique chimique,
import numpy as np etc). Dans de rares cas on est capable de trouver une solution analytique mais le plus souvent
import random as rand on utilisera des techniques numériques afin de s'approcher de la solution. Les problèmes
import math deviennent rapidement complexes. Les méthodes d'analyse numérique permettront
def f(x):
d'approcher les solutions réelles sans toutefois les atteindre.
return np.sin(x)
def p(x):
return -np.cos(x) Soit le système suivant :
⎧ y '(t ) = f (t , y (t )) ∀t ∈ [t0 , t0 + T ]
def rectangle(f,a,b,n) : ⎨
pas=(b-a)/n ⎩ y (t0 ) = y0 avec y∈R
s=0 La recherche des solutions d'un tel système d'équations s'appelle
for k in range(n) : • résoudre un problème de Cauchy.
s=s+f(a+(1/2+k)*pas) • f est de classe C1 sur un intervalle donné. C'est d'ailleurs la condition nécessaire
return s*pas afin que les méthodes numériques utilisées puissent donner une valeur aussi
proche possible de la solution exacte.
def trapeze(f,a,b,n) : 1. Méthode d'Euler
pas=(b-a)/n
Cette méthode, la plus ancienne et la plus simple. On considère une équation
s=0
for k in range(n) : différentielle d'ordre 1 sous forme y ' = f (t , y ) , avec la condition initiale y(t0 ) = y0
s=s+f(a+k*pas)
Le principe est d'approcher la solution y sur [a, b] par une fonction affine par morceaux,
return pas*(((f(a)+f(b))/2)+s)
en opérant une discrétisation du paramètre. Soit
n=10 b−a
N=100 tk = a + kh où h = est le pas
n
A=np.linspace(-5,5,N)#np.arange(-
3,3,0.1) La fonction affine par morceaux joindra donc les points de coordonnées (tk , yk ) et il
s'agit de proposer un algorithme pour construire les yk à partir de y0 . Sur chaque intervalle
X=[i for i in range(len(A))]
Y1=[] [tk , tk +1] on prend pour pente du segment affine celle que suggère l'équation f (tk , yk )
Y2=[]
Y3=[] Pour ce faire, nous allons définir la fonction euler. Elle prendra en entrée une fonction
for i in range(len(A)): f , les bornes a et b de l’intervalle d’étude, la condition initiale y0 et le pas h. Plus
Y1.append(p(B[i])-p(A[i])) précisément : avec ces données, la fonction va déterminer les approximations de la solution de
Y2.append(rectangle(f,A[i],B[i],n))
Y3.append(trapeze(f,A[i],B[i],n))
y ' = f (t , y ) avec la condition initiale y(a) = y0 , en rendant un tableau de temps et un tableau (a). Tracer la courbe de la fonction obtenue.
de valeurs approchées par la méthode d’Euler. Les temps sont les a + kh majorés par b. (b). Tracer la courbe de la solution exacte.
Ces tableaux sont construits à l’aide de listes auxquelles on adjoint les nouveaux termes (c). Qu’est-ce que vous remarquez ?
calculés.
(d). Modifier la valeur du pas et comparer les courbes obtenues.
Euler 1 :
def euler(f,a,b,y0,h):
import numpy as np
y=y0
def euler(f,a,b,y0,h):
t=a
y=y0
yy =[]
t=a
temps = []
yy =[] #liste des ordonnées
while t<= b:
tt =[] #liste des abscices
yy.append(y)
t=a
temps.append(t)
while t<= b:
t=t+h
yy.append(y)
y =y+ h * f(t,y)
tt.append(t)
return temps, yy
y =y+ h * f(t,y)
Euler2 :
t=t+h
def euler2(f,y0,z0,a,b,h):
return tt, yy
yy=[]
def f(t,y):
zz=[]
return t**2*y
tt=[]
def y(t):
t=a
return np.exp((t**3)/3)
y=y0
h=0.03
z=z0
a=0
while t<=b:
b=1
yy.append(y)
y0=1
zz.append(z)
tt,yy=euler (f,a,b,y0,h)
tt.append(t)

t=t+h
x=np.arange(a,b,h)
y,z=y+h*z,z+h*f(t,y,z)
y2=[]
return tt,yy,zz
for t in x:
2. Exemple : y2.append(y(t))
Illustrons l’utilisation de la fonction euler pour trouver une solution approchée de

l’équation différentielle y ' = y , intégrée sur l’intervalle [0,5] avec la condition initiale
plt.plot(tt,yy,'o')
y (0) = 1
Exercices ingénierie numérique et

plt.plot(x,y2,'r')

plt.legend(('Euler', 'Sol Exact'),loc=2) simulation
plt.title("y\'= t**2*y et y(0)=1")
plt.show()

Correction
Décomposition LU Cholesky Extrait de l’épreuve zéro de mathématiques option MP en CCP
2015
1. def factorielle(n):
if n>1:
return n*factorielle(n-1)
return 1
2. def seuil(M):
n=1
while factorielle(n)<=M:
n+=1
return n
3. def est_divisible(n):
if factorielle(n)%n==0:
return True
return False
4.
(a) mystere(n)=33
(b) Complexité de la fonction mystere:
n
n(n + 1)
∑i =
i =1 2
= O(n²)
(c) def newMystere(n):

p=1
s=0
for k in range(1,n+1):
p=p*k
s=s+p
return s return a

Solution numérique de l’équation f ( x) = 0 ∀x ∈[a, b] (E)
Méthode de newton (tangente)
Méthode de la dichotomie
def f(x): def newton(f, g, a,epsilon) : # g est la dérivé de f
return x**2-10 u=a
Fonction Itérative v=u-(f(u)/g(u))
def dicho(f, a,b,epsilon): while abs(v-u)>epsilon :
while b-a>epsilon: u=v
m=(a+b)/2 v= v-(f(v)/g(v))
if f(a)*f(m)<0: return v
b=m Résolution approchée d'une équation différentielle

else: import matplotlib.pyplot as plt
a=m import numpy as np
return (a,b) def euler(f,a,b,y0,h):
Fonction récursive y=y0
def dichoRec (f, a, b, epsilon): t=a
if b-a>epsilon: yy =[y0]
if f(a)*f((a+b)/2)<0: tt =[a]
return dichoRec (f,a,(a+b)/2,epsilon) while t+h <= b:
else: y += h * f(t,y)
return dichoRec (f,(a+b)/2,b,epsilon) yy.append(y)
return (a,b) t+=h

tt.append(t)
Méthode de lagrange
return tt, yy
def lagrange(f, a,b,epsilon) :
#Exemple (Tracer la solution)
u=a
def f(t,y):
a=a-f(a)*(b-a)/(f(b)-f(a))
return y
while a-u>epsilon:
tt,yy=euler (f,0,5,1,0.1)
u=a
plt.plot(tt,yy,'o')
a = a-f(a)*(b-a)/(f(b)-f(a))
x=np.arange(0,5,0.01)
y=np.exp(x) x[i]=s/l[i][i]
plt.plot(x,y,'r') return x
plt.legend(('Euler', 'exp'), ######################################

def remontee(u,b):
loc=2)
n=len(u)
plt.title("y'=y et y(0)=1")
x=[None]*n
plt.show()
x[n-1]=b[n-1]/u[n-1][n-1]
Décomposition LU Cholesky for i in range(n-2,-1,-1):
from math import sqrt s=b[i]
def cholesky(A): for j in range(i+1,n):
n=len(A) s=s-u[i][j]*x[j]
c=[[0.0]*n for i in range(n)] x[i]=s/u[i][i]
for i in range(n): return x
s=0 ######################################
for k in range(i): #Fonction retournant L
s=s+c[k][i]**2 def L(A) :
if A[i][i]<=s: n=len(A)
return None C=cholesky(A)
c[i][i]=sqrt(A[i][i]-s) L=[[0]*n for i in range(n)]
for j in range(i+1,n): for i in range(n) :
s=0 for j in range(i+1) :
for k in range(i): L[i][j]=C[j][i]/C[j][j]
s=s+c[k][i]*c[k][j] return L
c[i][j]=(A[i][j]-s)/c[i][i] ######################################
return c #Fonction retournant U
####################################### def U(A) :
def descente(l,y): n=len(A)
n=len(l) C=cholesky(A)
x=[None]*n U=[[0]*n for i in range(n)]
x[0]=y[0]/l[0][0] for i in range(n) :
for i in range(1,n): for j in range(i,n) :
s=y[i] U[i][j]=C[i][j]*C[i][i]
for j in range(i): return U
s=s-l[i][j]*x[j] ############################
#Résolution du système Ax=b print('U=')

def LU(A,b): afficher(u)
l=L(A) print('X=\n',x)
u=U(A) #Resultat
y=descente(l,b) C=
x=remontee(u,y) | 1.0 -1.0 0.0 |
return x | 0.0 2.0 1.0 |
################################# | 0.0 0.0 1.0 |

#Affichage d’une matrice
L=
def afficher(M):
| 1.0 0 0 |
m=0
|-1.0 1.0 0 |
for l in M:
| 0.0 0.5 1.0 |
for c in l:
if len(str(c))>m: U=
m=len(str(c)) | 1.0 -1.0 0.0 |
for l in M: | 0 4.0 2.0 |
print("|", end="") | 0 0 1.0 |

for c in l: X=
s="%"+str(m)+"s" [1.0, 1.0, -2.0]
print(s %c, end=" ")
Pivot de Gauss
print("|")
def afficher(M):
print()
#Affichage d’une matrice
######################################
m=0
#Exemple
for l in M:
A=[[1,-1,0],[-1,5,2],[0,2,2]]
for c in l:
b=[0,0,-2]
if len(str(c))>m:
C=cholesky(A)
m=len(str(c))
l=L(A)
for l in M:
u=U(A)
print("|", end="")
x=LU(A,b)
for c in l:
print('C=')
s="%"+str(m)+"s"
afficher(C)
print(s %c, end=" ")
print('L=')
print("|")
afficher(l)
print()
#----------------------------------------- n=len(M)
def echanger(M,i,j): X=[0]*n
#Echanger la ligne i et j for k in range(n-1,-1,-1):
M[i],M[j]=M[j],M[i] s=0
#----------------------------------------- for i in range(k+1,n):
def pivot(M, i): s=s+M[k][i]*X[i]
#Trouver le pivot max du iéme inconu X[k]=(b[k]-s)/M[k][k]
n=len(M) return X
pivot_max=i #-----------------------------------------
for j in range(i+1,n): def resolution(M,b):
if abs(M[j][i])>abs(M[i][pivot_max]): triangularisation(M,b)
pivot_max=j X=remontee(M,b)
return pivot_max afficher(M)
#----------------------------------------- print(b)
def transvection_ligne(M, i, j, m): return X
# Li <- Li + m*Lj #-----------------------------------------
n=len(M[0]) #Exemple
for k in range(n): A=[[3,2,-1],[-2,-1,-3],[4,2,4]]
M[i][k]=M[i][k]+m*M[j][k] b=[2,-1,1]
#----------------------------------------- X=resolution(A,b)
def triangularisation(M,b): Print("X=")
n=len(M) print(X)
for i in range(n): #-----------------------------------------
j = pivot(M, i) #Résultat
if j != i: X=[-14.0, 21.0, 4.0]
echanger(M, i, j)
echanger(b, i, j)
for k in range(i+1, n):
x = M[k][i]/M[i][i]
transvection_ligne(M, k, i, -x)
b[k]=b[k]-x*b[i]
#-----------------------------------------
def remontee(M,b):
#résolution du système triangulaire supérieur M*X=b

Ingenieurie Numerique PDF

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Ingenieurie Numerique PDF

Загружено:

Авторское право:

Доступные форматы

L’informatique en classes préparatoires (Samir ANTER) 73 L’informatique en classes préparatoires (Samir ANTER) 74

Résolution numérique des équations :

Principe de Lagrange Questions

La bibliothèque matplotlib plt.plot(X,Y,'b')

Question :Modifier la valeur de h et observer la différence. plt.plot(X,Y,'r')

Exercices ingénierie numérique et

(c) def newMystere(n):

Fonction Itérative v=u-(f(u)/g(u))

def dicho(f, a,b,epsilon): while abs(v-u)>epsilon :

while b-a>epsilon: u=v

b=m Résolution approchée d'une équation différentielle

Fonction récursive y=y0

def dichoRec (f, a, b, epsilon): t=a

return dichoRec (f,a,(a+b)/2,epsilon) while t+h <= b:

return dichoRec (f,(a+b)/2,b,epsilon) yy.append(y)

return (a,b) t+=h

plt.legend(('Euler', 'exp'), ######################################

#Résolution du système Ax=b print('U=')

m=len(str(c)) | 1.0 -1.0 0.0 |

for l in M: | 0 4.0 2.0 |

print("|", end="") | 0 0 1.0 |

Вам также может понравиться