Code Python Qui Calcule N'importe Quelle Dérivée : Calculateur Gratuit en Ligne

Cas d'usage Dérivée symbolique simple (x², sin(x), ln(x)…) Dérivée d'ordre n (f'', f''', f⁽ⁿ⁾) Dérivée partielle ∂f/∂x d'une fonction multivariée Dérivée numérique (tableau NumPy, différences finies) Dérivée numérique précise (scipy.misc.derivative) Dérivée automatique pour machine learning (torch.autograd) Jacobien et Hessien d'un système

Problème : x(t) = −t³ + 6t² + 2. Trouver les temps de vitesse nulle et leur nature.

from sympy import *
t = symbols('t')
x = -t**3 + 6*t**2 + 2
v = diff(x, t)        # vitesse : -3t² + 12t
a = diff(x, t, 2)     # accélération : -6t + 12

t_ext = solve(v, t)   # Résoudre v = 0
print("t extremums :", t_ext)  # [0, 4]

for t0 in t_ext:
    print(f"t={t0}: x={x.subs(t,t0)}, a={a.subs(t,t0)}")
# t=0: x=2, a=12 (minimum, a>0)
# t=4: x=34, a=-12 (maximum, a<0)

Problème : Demande Q(p) = 1000·e^(−0,05p). Calculer l'élasticité ε = (dQ/dp)·(p/Q) pour p variant de 10 à 100.

import numpy as np

def Q(p): return 1000 * np.exp(-0.05 * p)
def dQ_dp(p): return -0.05 * Q(p)  # Analytique ici

p = np.linspace(10, 100, 91)
elasticite = dQ_dp(p) * p / Q(p)
# Pour une demande exponentielle : ε = -0.05*p (constant ici)

print("Élasticité à p=20 :", elasticite[10])   # -1.0
print("Élasticité à p=40 :", elasticite[30])   # -2.0
print("Marché unitaire à p =", 1/0.05, "=", 20.0)
# Elastic si |ε| > 1 ↔ p > 20

Problème : Programme Python qui accepte une expression en entrée et retourne la dérivée symbolique avec tableau de valeurs.

from sympy import *
import numpy as np

def derivateur(expr_str, var='x', a=-5, b=5, n=20):
    """Dérive symboliquement + évalue sur [a,b]"""
    x = symbols(var)
    f = sympify(expr_str)
    df = diff(f, x)

    print(f"f(x) = {f}")
    print(f"f'(x) = {df}")
    print(f"f'(x) simplifiée = {simplify(df)}")

    # Tableau de valeurs
    x_vals = np.linspace(a, b, n)
    f_num = lambdify(x, f, 'numpy')
    df_num = lambdify(x, df, 'numpy')

    print("\n  x     | f(x)   | f'(x)")
    print("-" * 30)
    for xi in x_vals[::5]:
        print(f"  {xi:5.2f} | {float(f_num(xi)):6.3f} | {float(df_num(xi)):6.3f}")
    return df

# Tests
derivateur("x**3 - 2*x + 1")
derivateur("sin(x)*exp(-x)")
derivateur("ln(x**2 + 1)")

Erreur 1 — Utiliser math.log au lieu de sympy.ln
✖ from math import log; diff(log(x), x) — NameError ou erreur silencieuse
✔ from sympy import ln, log; diff(ln(x), x) — retourne 1/x
Règle : Dans SymPy, toujours utiliser les fonctions SymPy (sin, cos, exp, ln). Les fonctions du module math opèrent sur des flottants, pas des symboles. Importer avec from sympy import * charge toutes les fonctions symboliques.

Erreur 2 — Choisir h trop petit en différences finies numériques
✖ h = 1e-15 → erreur catastrophique par annulation numérique
✔ h = 1e-5 à 1e-7 → précision optimale en float64
Explication : Pour h = 1e-15, f(x+h) − f(x) souffre d'annulation catastrophique (les chiffres significatifs s'annulent). La valeur optimale de h est ≈ ε_machine^(1/2) ≈ 1,5×10⁻⁸ pour les différences centrales. scipy.misc.derivative gère cela automatiquement.

Erreur 3 — Oublier require_grad=True avec PyTorch
✖ x = torch.tensor(2.0); f = x**2; f.backward() → RuntimeError: element 0 of tensors does not require grad
✔ x = torch.tensor(2.0, requires_grad=True); f = x**2; f.backward()
Règle : PyTorch ne calcule le gradient que pour les tenseurs avec requires_grad=True. Pour les opérations en mode inférence (pas d'entraînement), utiliser with torch.no_grad(): pour économiser la mémoire.

Préparez vos maths avec des exercices corrigés

Exercices · Corrigés · PDF · Hors-ligne