1. Introduction à sympy.series
1.1 Qu'est-ce que sympy.series ?
Le module sympy.series de SymPy permet de réaliser des développements en série de fonctions mathématiques. Il est particulièrement utile pour les calculs symboliques de séries de Taylor, de Maclaurin, et d'autres développements asymptotiques.
1.2 Importation du module
|
1 2 3 4 5 6 7 |
import sympy as sp from sympy import series, Symbol, sin, cos, exp, log, oo """ Cette instruction Python importe des éléments spécifiques du module SymPy, une bibliothèque de mathématiques symboliques. Contrairement à import sympy as sp qui importe tout le module, cette syntaxe importe uniquement les fonctions et classes nécessaires. """ # Alternative: importer spécifiquement from sympy.series.series import series |
2. Développements en Série de Base
2.1 Série de Taylor avec series()
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
# Définir une variable symbolique x = sp.Symbol('x') # Développement de Taylor de sin(x) autour de 0 serie_sin = sp.series(sp.sin(x), x, 0, 6) print("Série de sin(x) jusqu'à l'ordre 5:") print(serie_sin) # Développement de cos(x) autour de π/2 serie_cos = sp.series(sp.cos(x), x, sp.pi/2, 4) print("\nSérie de cos(x) autour de π/2:") print(serie_cos) # Développement de exp(x) autour de 0 serie_exp = sp.series(sp.exp(x), x, 0, 5) print("\nSérie de exp(x):") print(serie_exp) |
2.2 Série de Maclaurin (cas particulier)
La série de Maclaurin est un cas particulier de la série de Taylor autour de 0 :
|
1 2 3 4 5 6 7 8 9 10 |
# Série de Maclaurin pour ln(1+x) serie_ln = sp.series(sp.log(1 + x), x, 0, 7) print("Série de Maclaurin de ln(1+x):") print(serie_ln) # Série de Maclaurin pour (1+x)^a (binomial) a = sp.Symbol('a') serie_binom = sp.series((1 + x)**a, x, 0, 5) print("\nSérie binomiale (1+x)^a:") print(serie_binom) |
3. Paramètres et Options Avancées
3.1 Contrôle de l'ordre et de la direction
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
x = sp.Symbol('x') # Développement avec ordre spécifique serie = sp.series(sp.exp(x), x, 0, 8) print("exp(x) à l'ordre 7:") print(serie) # Direction de la limite from sympy import limit, Limit # Limite bilatérale lim_bilat = limit(sp.sin(x)/x, x, 0) print(f"\nLimite bilatérale sin(x)/x: {lim_bilat}") # Limites unilatérales lim_plus = limit(1/x, x, 0, dir='+') lim_moins = limit(1/x, x, 0, dir='-') print(f"Limite 1/x à droite: {lim_plus}") print(f"Limite 1/x à gauche: {lim_moins}") |
3.2 Manipulation du terme O(x^n)
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
x = sp.Symbol('x') # Récupérer la série sans le terme O serie_complete = sp.series(sp.cos(x), x, 0, 6) print("Série complète avec O:") print(serie_complete) # Extraire la partie polynomiale partie_polynomiale = serie_complete.removeO() print("\nPartie polynomiale seulement:") print(partie_polynomiale) # Calculer le terme O séparément terme_O = serie_complete - partie_polynomiale print("\nTerme O:") print(terme_O) # Développement sans terme O serie_sans_O = sp.series(sp.sin(x), x, 0, 6).removeO() print("\nSérie de sin(x) sans O:") print(serie_sans_O) |
4. Série de Fourier et Développements Spéciaux
4.1 Série de Fourier avec fourier_series()
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
from sympy import fourier_series, pi from sympy.abc import x # Définir une fonction périodique f = x**2 # Calculer la série de Fourier sur [-π, π] fs = fourier_series(f, (x, -pi, pi)) print("Série de Fourier de x²:") print(fs) # Tronquer la série fs_trunc = fs.truncate(5) print("\nSérie de Fourier tronquée à 5 termes:") print(fs_trunc) # Coefficients de Fourier print("\nCoefficient a0:") print(fs.a0) print("\nCoefficients an:") for n in range(1, 4): print(f"a{n} = {fs.an_coefficient(n)}") print("\nCoefficients bn:") for n in range(1, 4): print(f"b{n} = {fs.bn_coefficient(n)}") |
4.2 Développements asymptotiques
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
from sympy import exp, oo x = sp.Symbol('x') # Développement asymptotique pour x → ∞ serie_asympt = sp.series(exp(1/x), x, oo, 5) print("Développement asymptotique de exp(1/x) pour x → ∞:") print(serie_asympt) # Développement asymptotique de la fonction Gamma from sympy import gamma serie_gamma = sp.series(gamma(x), x, oo, 3) print("\nDéveloppement asymptotique de Γ(x):") print(serie_gamma) # Série de Laurent (développement avec puissances négatives) from sympy import cot serie_laurent = sp.series(cot(x), x, 0, 6) print("\nSérie de Laurent de cot(x):") print(serie_laurent) |
5. Applications et Exemples Concrets
5.1 Approximation numérique
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
import sympy as sp import numpy as np x = sp.Symbol('x') # Série de Taylor pour sin(x) serie_sin = sp.series(sp.sin(x), x, 0, 8).removeO() print("Approximation de sin(x) par série:") print(serie_sin) # Convertir en fonction numérique f_approx = sp.lambdify(x, serie_sin, 'numpy') # Comparaison avec la vraie fonction x_vals = np.linspace(-2, 2, 100) sin_exact = np.sin(x_vals) sin_approx = f_approx(x_vals) print(f"\nErreur maximale sur [-2, 2]: {np.max(np.abs(sin_exact - sin_approx)):.6f}") # Approximation de fonctions plus complexes serie_complexe = sp.series(sp.exp(sp.sin(x)), x, 0, 6).removeO() print("\nApproximation de exp(sin(x)):") print(serie_complexe) |
5.2 Calcul de limites avec développement en série
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
from sympy import limit, sin, tan x = sp.Symbol('x') # Limite difficile sans développement en série expr = (sin(x) - tan(x)) / x**3 lim_calc = limit(expr, x, 0) print(f"Limite de (sin(x) - tan(x))/x³ quand x→0: {lim_calc}") # Utilisation du développement en série pour vérifier serie_sin = sp.series(sin(x), x, 0, 6) serie_tan = sp.series(tan(x), x, 0, 6) expr_series = sp.series((sin(x) - tan(x)) / x**3, x, 0, 6) print("\nDéveloppement en série de l'expression:") print(expr_series) # Calcul de limite avec série lim_par_serie = expr_series.removeO().subs(x, 0) print(f"\nLimite calculée par série: {lim_par_serie}") |
5.3 Résolution d'équations différentielles par méthode des séries
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
from sympy import Function, dsolve, Eq, Derivative x = sp.Symbol('x') y = Function('y') # Équation différentielle: y'' + y = 0 eq_diff = Eq(Derivative(y(x), x, x) + y(x), 0) # Résolution avec développement en série solution_series = dsolve(eq_diff, y(x), hint='series', n=8, x0=0) print("Solution en série de y'' + y = 0:") print(solution_series) # Extraction des coefficients if hasattr(solution_series.rhs, 'removeO'): solution_poly = solution_series.rhs.removeO() print("\nSolution polynomiale:") print(solution_poly) # Coefficients coeffs = solution_poly.as_coefficients_dict() print("\nCoefficients de la série:") for terme, coeff in coeffs.items(): print(f"{terme}: {coeff}") |
6. Fonctions Utilitaires et Bonnes Pratiques
6.1 Conversion entre différents types de séries
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
from sympy import Sum, oo, factorial x = sp.Symbol('x') n = sp.Symbol('n', integer=True, positive=True) # Série de Taylor comme somme infinie serie_somme = Sum(x**n / factorial(n), (n, 0, oo)) print("Représentation de exp(x) comme série infinie:") print(serie_somme) # Évaluation partielle serie_partielle = serie_somme.doit().subs(oo, 6).removeO() print("\nÉvaluation partielle (6 termes):") print(serie_partielle) # Conversion d'une série en polynôme serie_taylor = sp.series(sp.cos(x), x, 0, 8) poly_taylor = sp.Poly(serie_taylor.removeO(), x) print("\nPolynôme de Taylor de cos(x):") print(poly_taylor) print(f"Degré: {poly_taylor.degree()}") |
6.2 Validation et test de convergence
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 |
import sympy as sp x = sp.Symbol('x') # Rayon de convergence (pour les séries entières) def rayon_convergence(serie, point=0): """ Estimation simple du rayon de convergence """ # Extraire les coefficients coeffs = [] termes = serie.removeO().as_ordered_terms() for terme in termes: if terme.has(x): coeffs.append(terme.coeff(x)) if not coeffs: return sp.oo # Ratio test simplifié ratios = [] for i in range(1, len(coeffs)): if coeffs[i-1] != 0: ratio = abs(coeffs[i] / coeffs[i-1]) ratios.append(ratio) if ratios: R = 1 / max(ratios) return R else: return sp.oo # Test avec une série géométrique serie_geo = sp.series(1/(1-x), x, 0, 10) R = rayon_convergence(serie_geo) print(f"Rayon de convergence estimé de 1/(1-x): {R}") print("Valeur exacte (théorique): 1") # Test de convergence numérique print("\nTest de convergence pour x = 0.5:") valeur_exacte = 1/(1-0.5) for n in [3, 5, 7, 10]: approx = sp.series(1/(1-x), x, 0, n).removeO().subs(x, 0.5) erreur = abs(valeur_exacte - approx) print(f"Ordre {n}: {approx:.6f}, erreur: {erreur:.6f}") |
6.3 Fonction utilitaire complète
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 |
from sympy import series, Symbol, latex def developper_serie(fonction, variable, point, ordre, format_output='sympy'): """ Fonction utilitaire pour développer en série avec options de formatage """ # Calcul de la série serie_calc = series(fonction, variable, point, ordre) # Formatage de sortie if format_output == 'sympy': return serie_calc elif format_output == 'latex': partie_poly = serie_calc.removeO() terme_o = serie_calc - partie_poly latex_str = r"\begin{aligned}" latex_str += r"f(x) &= " + latex(partie_poly) + r" + " + latex(terme_o) + r"\\" latex_str += r"&\text{où }" + latex(terme_o) + r"\text{ est le reste}" latex_str += r"\end{aligned}" return latex_str elif format_output == 'numeric': # Créer une fonction d'approximation f_approx = sp.lambdify(variable, serie_calc.removeO(), 'numpy') return f_approx elif format_output == 'coefficients': # Extraire les coefficients poly = serie_calc.removeO().as_poly(variable) if poly: coeffs = poly.all_coeffs() return {f"c{i}": coeff for i, coeff in enumerate(reversed(coeffs))} else: return {} # Exemple d'utilisation x = Symbol('x') resultat = developper_serie(sp.exp(x), x, 0, 6, format_output='coefficients') print("Coefficients de la série de Taylor de exp(x):") for coeff, valeur in resultat.items(): print(f"{coeff}: {valeur}") # Version LaTeX latex_output = developper_serie(sp.sin(x), x, 0, 5, format_output='latex') print("\nReprésentation LaTeX:") print(latex_output) |
Younes Derfoufi CRMEF OUJDA
