def compeq3():
"""Comparaison graphe de convergence y' = 1-y^2 avec y(0) = 2 pour t dans [0,1] avec la méthode d'Euler explicite et RK2"""
equations.a = -1.
equations.b = 1.
t0, y0 = 0., 2.
T = 1.
h = 0.2
#Définition de la boucle for
for i in range(1, 6, 1):
N = int(T / h) #Nombre d'itérations
[t, y1] = methodes.euler_explicite(t0, h, N, y0, equations.f_poly)
[t, y2] = methodes.RK2(t0, h, N, y0, equations.f_poly)
# Solution exacte aux mêmes instants
z1 = equations.sol_poly2(t)
# Calcul de l'erreur maximum relative
e1 = np.nanmax(np.abs((z1 - y1) / z1))
e2 = np.nanmax(np.abs((z1 - y2) / z1))
plt.plot(h, e1, 'b-+')
plt.plot(h, e2, 'r-+')
h = h / 2
plt.xscale('log')
plt.yscale('log')
plt.xlabel('h')
plt.ylabel('e1')
plt.title("Erreur en fonction du pas h")
plt.legend()
plt.show()
def comptrig1():
""" Comparaison graphe convergence de y' = a*y(t) + (1-a)*cos(t) -(1-a)*sin(t) avec y(0) = 1 pour t dans [0,5] avec les 4 méthodes et a = -1"""
equations.a = -1.
t0, y0 = 0., 1.
T = 5.
h = np.array([0.5, 0.1, 0.01])
#Définition de la boucle for
for i in range(0, 3, 1):
N = int(T / h[i]) #Nombre d'itérations
[t, y1] = methodes.euler_explicite(t0, h[i], N, y0, equations.f_trig)
[t, y2] = methodes.RK2(t0, h[i], N, y0, equations.f_trig)
[t, y3] = methodes.saute_mouton(t0, h[i], N, y0, equations.f_trig)
[t, y4] = methodes.trapezePC(t0, h[i], N, y0, equations.f_trig)
# Solution exacte aux mêmes instants
z1 = equations.sol_trig(t)
#Graphe des solutions exactes et approchées
plt.figure(i)
plt.plot(t, y1, 'b-+')
plt.plot(t, y2, 'r-+')
plt.plot(t, y3, 'g-+')
plt.plot(t, y4, 'm-+')
plt.plot(t, z1, 'k')
plt.xlabel('t')
plt.ylabel('y')
plt.title("Comparatif des différentes méthodes pour h =" + str(h[i]))
# Calcul de l'erreur maximum relative
e1 = np.max(np.abs((z1 - y1) / z1))
e2 = np.max(np.abs((z1 - y2) / z1))
e3 = np.max(np.abs((z1 - y3) / z1))
e4 = np.max(np.abs((z1 - y4) / z1))
plt.figure(3)
plt.plot(h[i], e1, 'b-+', label='Méthode Euler explicite')
plt.legend()
plt.plot(h[i], e2, 'r-+', label='Méthode du RK2')
plt.legend()
plt.plot(h[i], e3, 'g-+', label='Méthode saute-mouton')
plt.legend()
plt.plot(h[i], e4, 'm-+', label='Méthode trapèze PC')
plt.legend()
plt.xscale('log')
plt.yscale('log')
plt.xlabel('h')
plt.ylabel('e1,e2,e3,e4')
plt.title("Erreur en fonction du pas h")
plt.show()
def eulereq1() :
# Résolution approchée de y' = 1-y avec y(0) = 5 pour t dans [0,1] avec méthode d'Euler explicite
equations.a = -1.
equations.b = 1.
t0,y0 = 0.,5.
T = 1.
h = 0.2
print("Valeur de l'erreur en fonction de h")
#Définition de la boucle for
for i in range(0,6,1) :
N = int(T/h) #Nombre d'itérations
[t,y1] = methodes.euler_explicite(t0,h,N,y0,equations.f_affine)
# Solution exacte aux mêmes instants
z1 = equations.sol_affine(t,y0)
# Calcul de l'erreur maximum relative
e1 = np.max(np.abs((z1-y1)/z1))
#Graphe des solutions exactes et approchées
plt.figure(1)
plt.plot(t,y1,'b-+')
plt.plot(t,z1,'r')
plt.xlabel('t')
plt.ylabel('y')
plt.title("Méthode d'Euler explicite")
# Écriture de l'erreur en fonction de h
print("{0} | {1}".format(h,e1))
plt.figure(2)
plt.plot(h,e1,'b-+',label = 'Pour h = '+ str(h))
h = h/2
plt.xscale('log')
plt.yscale('log')
plt.xlabel('h')
plt.ylabel('e1')
plt.title("Erreur en fonction du pas h")
plt.legend()
plt.show()
import numpy as np
#import matplotlib.pyplot as plt
from pylab import * #permet d'eviter l'utilisation de plat devant les parametres graphiques
import methodes
import equations
# Résolution approchée de y' = 2-y avec y(0) = 3 pour t dans [0,5]
equations.a = -1. #on affecte a la valeur a dans equations la valeur de -1 en terme d'entier (presence du point apres le nombre)
equations.b = 2. # on affecte a la veleur b de equations la valeur 2
t0,y0 = 0.,3.
T = 5.
# Avec un pas de 0.1, il faut donc 50 iterations
N,h = 50,0.1
[t,y1] = methodes.euler_explicite(t0,h,N,y0,equations.f_affine)
# Solution exacte aux mêmes instants
z1 = equations.sol_affine(t,y0)
# Calcul de l'erreur maximum relative
e1 = np.max(np.abs((z1-y1)/z1))
# Graphe des solutions exactes et approchées
plot(t,y1,'b-+',label='solution approchée h=0.1')
plot(t,z1,'r-',label='solution exacte')
xlabel('t')
ylabel('y')
title("Méthode d'Euler explicite")
legend()
savefig('eq_affine.png')
show()
print(len(y1))
print(len(z1))
import methodes
import equations
#Resolution approchée de y'=1-y avec y(0)=5 dans [0,1]
equations.a=-1.
equations.b=1.
t0=0.
y0=5.
T=1.
h=[0.2,0.1,0.05,0.025,0.0125,0.00625]
N=[5,10,20,40,80,160]
erreur=zeros(6) #de taille 6 car l'on considere 6 h differents
for i in range(1,6,1):
# t tableau des subdivisions ( c'est un vecteur)
# y vecteurs des solutions calculees au subdivisons t
[t,ycal]=methodes.euler_explicite(t0,h[i],N[i],y0,equations.f_affine)
yexact=equations.sol_affine(t,y0)
erreur[i]=max(abs((ycal-yexact)/yexact))
#Ecriture de l erreur en fonction de h
print("Valeur de h : "+str(h[i])+" et son erreur associe "+str(erreur[i]))
plot(h,erreur)
xscale('log')
title("Erreur en fonction du pas h en echelle logarithmique")
xlabel('erreur logarithmique')
ylabel('pas de subdivision')
grid("on")
#plusieurs methodes pour mettre en echelle logarithmique
#loglog() met les deux axes en echelles logarithmiques
show()
import numpy as np import matplotlib.pyplot as plt import methodes import equations from pylab import * #nous avons copié collé des bouts de programme, en changeant le pas à chaque fois, puis nous avons affiché chaque pas et l'erreur associée par un print t0,y0 = 0.,5. T = 1. N,h1 = 50,0.2 [t,y1] = methodes.euler_explicite(t0,h1,N,y0,equations.f_affine) # Solution exacte aux mêmes instants z1 = equations.sol_affine(t,y0) # Calcul de l'erreur maximum relative e1 = np.max(np.abs((z1-y1)/z1)) N,h2 = 50,0.1 [t,y1] = methodes.euler_explicite(t0,h2,N,y0,equations.f_affine) # Solution exacte aux mêmes instants z1 = equations.sol_affine(t,y0) # Calcul de l'erreur maximum relative e2 = np.max(np.abs((z1-y1)/z1)) N,h3 = 50,0.05 [t,y1] = methodes.euler_explicite(t0,h3,N,y0,equations.f_affine)
#Resolution approchée de y'=1-y^2 avec y(0)=0 dans [0,1]
equations.a = -1.
equations.b = 1.
t0 = int(input("Choisir une valeur pour t0 : "))
y0 = int(
input("chosir une valeur pour y0 : ")
) # on doit convertir en chiffre car une entree de l'utilisateur est considerer comme string
T = 1.
h = [0.2, 0.1, 0.05, 0.025, 0.0125, 0.00625]
N = [5, 10, 20, 40, 80, 160]
erreur = zeros(6)
#on calcul en fonction du la condition initiale la valeur du paramètre C
C = ((1 / (y0 - 1)) + (1 / 2) * np.exp(-2 * t0)) / np.exp(2 * t0)
for i in range(1, 6, 1):
# t tableau des subdivisions ( c'est un vecteur)
# y vecteurs des solutions calculees au subdivisons t
[t, ycal] = methodes.euler_explicite(t0, h[i], N[i], y0, f_polynome)
#valeur obtenue par calcul sur feuille
yexact = 1 + (1 / ((C * np.exp(2 * t)) - (1 / 2) * np.exp(-2 * t)))
erreur[i] = max(abs((ycal - yexact)))
#Ecriture de l erreur en fonction de h
print("Valeur de h : " + str(h[i]) + " et son erreur associe " +
str(erreur[i]))
plot(h, erreur)
#xscale('log')
#plusieurs methodes pour mettre en echelle logarithmique
#loglog() #met les deux axes en echelles logarithmiques
show()