Transcript LYCÉE THIERS - 2013/2014 INFORMATIQUE

´ THIERS - 2013/2014
LYCEE
INFORMATIQUE - MPSI
´
INTERROGATION ECRITE
N◦ 3 - CORRECTION
Exercice 1. Le code python `
a utiliser est :
>>> import numpy as np
>>> A = np.array([[2,1,-2,1],[1,2,1,-1],[1,-1,1,-1],[-1,1,2,1]])
>>> B = np.array([-2,1,4,-1])
>>> np.linalg.solve(A,B)
array([ 1., -1., 1., -1.])
Le syst`eme a pour solution : x = 1, y = −1, z = 1, t = −1. S = {(1, −1, 1, −1)} .
Exercice 2. Voici le code python `
a utiliser (avec romberg()) :
>>> import numpy as np
>>> from scipy import integrate
>>> f = lambda x: x * np.cos(x)
>>> integrate.romberg(f,0,np.pi)
-2.0000000000000013
ou encore avec quad() :
>>> integrate.quad(f,0,np.pi)
(-2.0, 3.4718116504071706e-14)
Z
Le r´esultat est tr`es proche de −2 :
π
x · cos(x) · dx ≈ −2 .
0
Ce n’est pas tr`es ´etonnant puisqu’une IPP montre que le r´esultat exact est -2.
Exercice 3. Voici le code python `
a utiliser :
import numpy as np
import matplotlib.pyplot as plt
from scipy import integrate
phi = lambda y,t: -y * t**0.5
t = np.linspace(0,4,100)
y0 = 1
y = integrate.odeint(phi,y0,t)
plt.plot(t,y)
1
2
´
INTERROGATION ECRITE
N◦ 3 - CORRECTION
Ce qui produit la figure suivante :
Graphiquement, la valeur y(4) semble ˆetre nulle.
Exercice 4. Voici une impl´ementation de la fonction eqdiff2() :
def eqdiff2(a,b,y0,y1,f):
"""R´
esout le probl`
eme de Cauchy y’’+ay’+by = f(t)
avec conditions initiales y(0) = y0 et y’(0) = y1"""
import numpy as np
import matplotlib.pyplot as plt
from scipy import integrate
phi = lambda y,t: np.array([y[1], f(t)-a*y[1]-b*y[0]])
t = np.linspace(0,1,100)
y0 = np.array([y0,y1])
y = integrate.odeint(phi,y0,t)
plt.plot(t,y)
´ THIERS - 2013/2014
LYCEE
INFORMATIQUE - MPSI
3
Exercice 5. Voici le code python pour la m´ethode de Lagrange :
def lagrange method(f,a,b,n):
"""Recherche d’une racine par la m´
ethode de Lagrange"""
for k in range(n):
x = (a * f(b) - b * f(a)) / float(f(b) - f(a))
if (f(a) * f(x) > 0):
a = x
else:
b = x
return x
Exercice 6.
1) Le code python pour la m´ethode de Runge-Kutta 2 est (on peut s’inspirer du code pour
Euler-Cauchy ou Runge-Kutta 4 du cours n◦ 10) :
def rk2(phi,a,b,y0,n):
"""M´
ethode de Runge-Kutta 2 pour r´
esoudre le probl`
eme de Cauchy
y’ = phi(y,x) avec condition initiale y(0) = y0 sur [a,b] """
import numpy as np
x = np.linspace(a,b,n+1)
y = np.empty(n+1)
y[0] = y0
h = (b-a) / float(n)
for k in range(n):
y1 = y[k] + h/2 * phi(y[k],x[k])
y2 = phi(y1,x[k] + h/2)
y[k+1] = y[k] + h * y2
return y
2) Cet algorithme est de complexit´e (temporelle) lin´eaire O(n) en moyenne et dans le
pire des cas : en effet les cr´eations des tableaux x et y avec linspace et empty sont
de complexit´es au plus lin´eaires, et la boucle for s’impl´emente n fois. Toutes les autres
op´erations ont une dur´ee born´ee ne d´ependant pas de n.
Remarquons que la complexit´e en espace m´emoire est aussi lin´eaire (`a cause des tableaux
x et y qui prennent chacun n+1 espaces en m´emoires × l’espace de stockage d’un float).