import numpy as np
from .config import est_pedagogique
[docs]
def rectangle_erreur(f_derivee, a, b, n=1):
"""
Calcule l'erreur theorique pour la methode des rectangles.
Args:
f_derivee (float): Valeur de la derivee premiere sur [a, b].
a (float): Borne inferieure.
b (float): Borne superieure.
n (int): Nombre de sous-intervalles.
Returns:
float: Erreur estimee.
"""
h = (b - a) / n
return (h * (b - a) / 2) * np.abs(f_derivee)
[docs]
def point_milieu_erreur(f_derivee2, a, b, n=1):
"""
Calcule l'erreur theorique pour la methode du point milieu.
Args:
f_derivee2 (float): Valeur de la derivee seconde sur [a, b].
a (float): Borne inferieure.
b (float): Borne superieure.
n (int): Nombre de sous-intervalles.
Returns:
float: Erreur estimee.
"""
h = (b - a) / n
return ((b - a) * h**2 / 24) * np.abs(f_derivee2)
def trapeze_erreur(f_derivee2, a, b, n=1):
h = (b - a) / n
return ((b - a) * h**2 / 12) * np.abs(f_derivee2)
def simpson_erreur(f_derivee4, a, b, n=1):
h = (b - a) / n
return ((b - a) * h**4 / 180) * np.abs(f_derivee4)
[docs]
def rectangle(f, a, b, type='gauche', pedagogique=None):
"""
Methode d'integration numerique des rectangles simples.
Args:
f (callable): Fonction a integrer.
a (float): Borne inferieure.
b (float): Borne superieure.
type (str): 'gauche' ou 'droite'.
pedagogique (bool, optional): Affiche les etapes si True.
Returns:
float: Valeur de l'integrale.
"""
h = b - a
val = f(a) * h if type == 'gauche' else f(b) * h
if est_pedagogique(pedagogique):
print(f"[Pedagogique] Rectangle simple ({type}): h={h}, Aire={val}")
return val
def point_milieu(f, a, b, pedagogique=None):
h = b - a
mil = (a + b) / 2
val = f(mil) * h
if est_pedagogique(pedagogique):
print(f"[Pedagogique] Point milieu: h={h}, mil={mil}, Aire={val}")
return val
def trapeze(f, a, b, pedagogique=None):
h = b - a
val = (h / 2) * (f(a) + f(b))
if est_pedagogique(pedagogique):
print(f"[Pedagogique] Trapeze simple: h={h}, Aire={val}")
return val
[docs]
def simpson(f, a, b, pedagogique=None):
"""
Methode de Simpson simple (1/3).
Args:
f (callable): Fonction a integrer.
a (float): Borne inferieure.
b (float): Borne superieure.
pedagogique (bool, optional): Affiche les etapes si True.
Returns:
float: Valeur de l'integrale.
"""
h = (b - a) / 2
mil = (a + b) / 2
val = (h / 3) * (f(a) + 4 * f(mil) + f(b))
if est_pedagogique(pedagogique):
print(f"[Pedagogique] Simpson simple: h={h}, Aire={val}")
return val
def point_milieu_compose(f, a, b, n, pedagogique=None):
h = (b - a) / n
x = np.linspace(a + h/2, b - h/2, n)
val = h * np.sum(f(x))
if est_pedagogique(pedagogique):
print(f"[Pedagogique] Point milieu compose: n={n}, h={h}, Resultat={val}")
return val
def trapeze_compose(f, a, b, n, pedagogique=None):
x = np.linspace(a, b, n + 1)
h = (b - a) / n
y = f(x)
val = (h / 2) * (y[0] + 2 * np.sum(y[1:-1]) + y[-1])
if est_pedagogique(pedagogique):
print(f"[Pedagogique] Trapeze compose: n={n}, h={h}, Resultat={val}")
return val
[docs]
def simpson_compose(f, a, b, n, pedagogique=None):
"""
Methode de Simpson composee.
Args:
f (callable): Fonction a integrer.
a (float): Borne inferieure.
b (float): Borne superieure.
n (int): Nombre de sous-intervalles (doit etre pair).
pedagogique (bool, optional): Affiche les etapes si True.
Returns:
float: Valeur de l'integrale.
"""
if n % 2 != 0:
raise ValueError("n doit etre pair")
h = (b - a) / n
x = np.linspace(a, b, n + 1)
y = f(x)
val = (h / 3) * (y[0] + 4 * np.sum(y[1:-1:2]) + 2 * np.sum(y[2:-2:2]) + y[-1])
if est_pedagogique(pedagogique):
print(f"[Pedagogique] Simpson compose: n={n}, h={h}, Resultat={val}")
return val
[docs]
def gauss_legendre(f, a, b, n, pedagogique=None):
nodes, weights = np.polynomial.legendre.leggauss(n)
m_nodes = 0.5 * (nodes + 1) * (b - a) + a
m_weights = 0.5 * weights * (b - a)
val = np.sum(m_weights * f(m_nodes))
if est_pedagogique(pedagogique):
print(f"[Pedagogique] Gauss-Legendre (n={n}): Resultat={val}")
return val
def gauss_nodes_weights(n):
return np.polynomial.legendre.leggauss(n)
def newton_cotes(f, a, b, n, pedagogique=None):
if n == 1: return trapeze(f, a, b, pedagogique)
if n == 2: return simpson(f, a, b, pedagogique)
if n == 3:
h = (b - a) / 3
x = np.linspace(a, b, 4)
val = (3 * h / 8) * (f(x[0]) + 3*f(x[1]) + 3*f(x[2]) + f(x[3]))
if est_pedagogique(pedagogique): print(f"[Pedagogique] Newton-Cotes (n=3): {val}")
return val
raise NotImplementedError("Seulement n=1,2,3 implementes")
def change_interval(f, a, b):
return lambda t: f(0.5 * (t + 1) * (b - a) + a) * 0.5 * (b - a)
def integration_erreur(method, f_deriv, a, b, n=1):
if method == "trapeze": return trapeze_erreur(f_deriv, a, b, n)
if method == "simpson": return simpson_erreur(f_deriv, a, b, n)
if method == "point_milieu": return point_milieu_erreur(f_deriv, a, b, n)
if method == "rectangle": return rectangle_erreur(f_deriv, a, b, n)
return None