sympy

Par mkurman · zorai

Utilisez cette compétence pour travailler avec les mathématiques symboliques en Python. Cette compétence doit être utilisée pour les tâches de calcul symbolique, notamment la résolution algébrique d'équations, les opérations de calcul infinitésimal (dérivées, intégrales, limites), la manipulation d'expressions algébriques, le travail matriciel symbolique, les calculs en physique, les problèmes de théorie des nombres, les calculs géométriques et la génération de code exécutable à partir d'expressions mathématiques. Appliquez cette compétence lorsque l'utilisateur a besoin de résultats symboliques exacts plutôt que d'approximations numériques, ou lorsqu'il travaille avec des formules mathématiques contenant des variables et des paramètres.

npx skills add https://github.com/mkurman/zorai --skill sympy

SymPy - Mathématiques symboliques en Python

Aperçu

SymPy est une bibliothèque Python pour les mathématiques symboliques qui permet le calcul exact en utilisant des symboles mathématiques plutôt que des approximations numériques. Cette compétence fournit des conseils complets pour effectuer l'algèbre symbolique, le calcul, l'algèbre linéaire, la résolution d'équations, les calculs de physique et la génération de code avec SymPy.

Quand utiliser cette compétence

Utilisez cette compétence pour :

  • Résoudre des équations symboliquement (algébriques, différentielles, systèmes d'équations)
  • Effectuer des opérations de calcul (dérivées, intégrales, limites, séries)
  • Manipuler et simplifier des expressions algébriques
  • Travailler avec des matrices et de l'algèbre linéaire symboliquement
  • Effectuer des calculs de physique (mécanique, mécanique quantique, analyse vectorielle)
  • Calculs de théorie des nombres (nombres premiers, factorisation, arithmétique modulaire)
  • Calculs géométriques (géométrie 2D/3D, géométrie analytique)
  • Convertir des expressions mathématiques en code exécutable (Python, C, Fortran)
  • Générer des résultats LaTeX ou d'autres sorties formatées
  • Avoir besoin de résultats mathématiques exacts (par exemple, sqrt(2) et non 1.414...)

Capacités principales

1. Bases du calcul symbolique

Créer des symboles et des expressions :

from sympy import symbols, Symbol
x, y, z = symbols('x y z')
expr = x**2 + 2*x + 1

# Avec des hypothèses
x = symbols('x', real=True, positive=True)
n = symbols('n', integer=True)

Simplification et manipulation :

from sympy import simplify, expand, factor, cancel
simplify(sin(x)**2 + cos(x)**2)  # Retourne 1
expand((x + 1)**3)  # x**3 + 3*x**2 + 3*x + 1
factor(x**2 - 1)    # (x - 1)*(x + 1)

Pour les bases détaillées : Voir references/core-capabilities.md

2. Calcul

Dérivées :

from sympy import diff
diff(x**2, x)        # 2*x
diff(x**4, x, 3)     # 24*x (dérivée troisième)
diff(x**2*y**3, x, y)  # 6*x*y**2 (dérivées partielles)

Intégrales :

from sympy import integrate, oo
integrate(x**2, x)              # x**3/3 (indéfinie)
integrate(x**2, (x, 0, 1))      # 1/3 (définie)
integrate(exp(-x), (x, 0, oo))  # 1 (impropre)

Limites et séries :

from sympy import limit, series
limit(sin(x)/x, x, 0)  # 1
series(exp(x), x, 0, 6)  # 1 + x + x**2/2 + x**3/6 + x**4/24 + x**5/120 + O(x**6)

Pour les opérations de calcul détaillées : Voir references/core-capabilities.md

3. Résolution d'équations

Équations algébriques :

from sympy import solveset, solve, Eq
solveset(x**2 - 4, x)  # {-2, 2}
solve(Eq(x**2, 4), x)  # [-2, 2]

Systèmes d'équations :

from sympy import linsolve, nonlinsolve
linsolve([x + y - 2, x - y], x, y)  # {(1, 1)} (linéaire)
nonlinsolve([x**2 + y - 2, x + y**2 - 3], x, y)  # (non-linéaire)

Équations différentielles :

from sympy import Function, dsolve, Derivative
f = symbols('f', cls=Function)
dsolve(Derivative(f(x), x) - f(x), f(x))  # Eq(f(x), C1*exp(x))

Pour les méthodes de résolution détaillées : Voir references/core-capabilities.md

4. Matrices et algèbre linéaire

Création et opérations sur des matrices :

from sympy import Matrix, eye, zeros
M = Matrix([[1, 2], [3, 4]])
M_inv = M**-1  # Inverse
M.det()        # Déterminant
M.T            # Transposée

Valeurs propres et vecteurs propres :

eigenvals = M.eigenvals()  # {valeur_propre: multiplicité}
eigenvects = M.eigenvects()  # [(val_propre, mult, [vecteurs_propres])]
P, D = M.diagonalize()  # M = P*D*P^-1

Résoudre des systèmes linéaires :

A = Matrix([[1, 2], [3, 4]])
b = Matrix([5, 6])
x = A.solve(b)  # Résoudre Ax = b

Pour l'algèbre linéaire complète : Voir references/matrices-linear-algebra.md

5. Physique et mécanique

Mécanique classique :

from sympy.physics.mechanics import dynamicsymbols, LagrangesMethod
from sympy import symbols

# Définir le système
q = dynamicsymbols('q')
m, g, l = symbols('m g l')

# Lagrangien (T - V)
L = m*(l*q.diff())**2/2 - m*g*l*(1 - cos(q))

# Appliquer la méthode de Lagrange
LM = LagrangesMethod(L, [q])

Analyse vectorielle :

from sympy.physics.vector import ReferenceFrame, dot, cross
N = ReferenceFrame('N')
v1 = 3*N.x + 4*N.y
v2 = 1*N.x + 2*N.z
dot(v1, v2)  # Produit scalaire
cross(v1, v2)  # Produit vectoriel

Mécanique quantique :

from sympy.physics.quantum import Ket, Bra, Commutator
psi = Ket('psi')
A = Operator('A')
comm = Commutator(A, B).doit()

Pour les capacités de physique détaillées : Voir references/physics-mechanics.md

6. Mathématiques avancées

La compétence inclut un support complet pour :

  • Géométrie : Géométrie analytique 2D/3D, points, lignes, cercles, polygones, transformations
  • Théorie des nombres : Nombres premiers, factorisation, PGCD/PPCM, arithmétique modulaire, équations diophantiennes
  • Combinatoire : Permutations, combinaisons, partitions, théorie des groupes
  • Logique et ensembles : Logique booléenne, théorie des ensembles, ensembles finis et infinis
  • Statistiques : Distributions de probabilité, variables aléatoires, espérance, variance
  • Fonctions spéciales : Gamma, Bessel, polynômes orthogonaux, fonctions hypergéométriques
  • Polynômes : Algèbre polynomiale, racines, factorisation, bases de Groebner

Pour les sujets avancés détaillés : Voir references/advanced-topics.md

7. Génération de code et sortie

Convertir en fonctions exécutables :

from sympy import lambdify
import numpy as np

expr = x**2 + 2*x + 1
f = lambdify(x, expr, 'numpy')  # Créer une fonction NumPy
x_vals = np.linspace(0, 10, 100)
y_vals = f(x_vals)  # Évaluation numérique rapide

Générer du code C/Fortran :

from sympy.utilities.codegen import codegen
[(c_name, c_code), (h_name, h_header)] = codegen(
    ('my_func', expr), 'C'
)

Sortie LaTeX :

from sympy import latex
latex_str = latex(expr)  # Convertir en LaTeX pour les documents

Pour la génération de code complète : Voir references/code-generation-printing.md

Travailler avec SymPy : bonnes pratiques

1. Toujours définir les symboles en premier

from sympy import symbols
x, y, z = symbols('x y z')
# Maintenant x, y, z peuvent être utilisés dans des expressions

2. Utiliser les hypothèses pour une meilleure simplification

x = symbols('x', positive=True, real=True)
sqrt(x**2)  # Retourne x (pas Abs(x)) grâce à l'hypothèse positive

Hypothèses courantes : real, positive, negative, integer, rational, complex, even, odd

3. Utiliser l'arithmétique exacte

from sympy import Rational, S
# Correct (exact) :
expr = Rational(1, 2) * x
expr = S(1)/2 * x

# Incorrect (virgule flottante) :
expr = 0.5 * x  # Crée une valeur approximative

4. Évaluation numérique quand nécessaire

from sympy import pi, sqrt
result = sqrt(8) + pi
result.evalf()    # 5.96371554103586
result.evalf(50)  # 50 chiffres de précision

5. Convertir en NumPy pour les performances

# Lent pour de nombreuses évaluations :
for x_val in range(1000):
    result = expr.subs(x, x_val).evalf()

# Rapide :
f = lambdify(x, expr, 'numpy')
results = f(np.arange(1000))

6. Utiliser les solveurs appropriés

  • solveset : Équations algébriques (principale)
  • linsolve : Systèmes linéaires
  • nonlinsolve : Systèmes non-linéaires
  • dsolve : Équations différentielles
  • solve : Usage général (hérité, mais flexible)

Structure des fichiers de référence

Cette compétence utilise des fichiers de référence modulaires pour différentes capacités :

  1. core-capabilities.md : Symboles, algèbre, calcul, simplification, résolution d'équations

    • Charger quand : Calcul symbolique basique, calcul, ou résolution d'équations

  2. matrices-linear-algebra.md : Opérations matricielles, valeurs propres, systèmes linéaires

    • Charger quand : Travail avec des matrices ou des problèmes d'algèbre linéaire

  3. physics-mechanics.md : Mécanique classique, mécanique quantique, vecteurs, unités

    • Charger quand : Calculs de physique ou problèmes de mécanique

  4. advanced-topics.md : Géométrie, théorie des nombres, combinatoire, logique, statistiques

    • Charger quand : Sujets mathématiques avancés au-delà de l'algèbre et du calcul basiques

  5. code-generation-printing.md : Lambdify, codegen, sortie LaTeX, impression

    • Charger quand : Convertir des expressions en code ou générer une sortie formatée

Motifs de cas d'usage courants

Motif 1 : Résoudre et vérifier

from sympy import symbols, solve, simplify
x = symbols('x')

# Résoudre l'équation
equation = x**2 - 5*x + 6
solutions = solve(equation, x)  # [2, 3]

# Vérifier les solutions
for sol in solutions:
    result = simplify(equation.subs(x, sol))
    assert result == 0

Motif 2 : Pipeline symbolique vers numérique

# 1. Définir le problème symbolique
x, y = symbols('x y')
expr = sin(x) + cos(y)

# 2. Manipuler symboliquement
simplified = simplify(expr)
derivative = diff(simplified, x)

# 3. Convertir en fonction numérique
f = lambdify((x, y), derivative, 'numpy')

# 4. Évaluer numériquement
results = f(x_data, y_data)

Motif 3 : Documenter les résultats mathématiques

# Calculer le résultat symboliquement
integral_expr = Integral(x**2, (x, 0, 1))
result = integral_expr.doit()

# Générer la documentation
print(f"LaTeX: {latex(integral_expr)} = {latex(result)}")
print(f"Pretty: {pretty(integral_expr)} = {pretty(result)}")
print(f"Numerical: {result.evalf()}")

Intégration avec les workflows scientifiques

Avec NumPy

import numpy as np
from sympy import symbols, lambdify

x = symbols('x')
expr = x**2 + 2*x + 1

f = lambdify(x, expr, 'numpy')
x_array = np.linspace(-5, 5, 100)
y_array = f(x_array)

Avec Matplotlib

import matplotlib.pyplot as plt
import numpy as np
from sympy import symbols, lambdify, sin

x = symbols('x')
expr = sin(x) / x

f = lambdify(x, expr, 'numpy')
x_vals = np.linspace(-10, 10, 1000)
y_vals = f(x_vals)

plt.plot(x_vals, y_vals)
plt.show()

Avec SciPy

from scipy.optimize import fsolve
from sympy import symbols, lambdify

# Définir l'équation symboliquement
x = symbols('x')
equation = x**3 - 2*x - 5

# Convertir en fonction numérique
f = lambdify(x, equation, 'numpy')

# Résoudre numériquement avec une estimation initiale
solution = fsolve(f, 2)

Référence rapide : fonctions les plus courantes

# Symboles
from sympy import symbols, Symbol
x, y = symbols('x y')

# Opérations basiques
from sympy import simplify, expand, factor, collect, cancel
from sympy import sqrt, exp, log, sin, cos, tan, pi, E, I, oo

# Calcul
from sympy import diff, integrate, limit, series, Derivative, Integral

# Résolution
from sympy import solve, solveset, linsolve, nonlinsolve, dsolve

# Matrices
from sympy import Matrix, eye, zeros, ones, diag

# Logique et ensembles
from sympy import And, Or, Not, Implies, FiniteSet, Interval, Union

# Sortie
from sympy import latex, pprint, lambdify, init_printing

# Utilitaires
from sympy import evalf, N, nsimplify

Exemples de démarrage

Exemple 1 : Résoudre une équation quadratique

from sympy import symbols, solve, sqrt
x = symbols('x')
solution = solve(x**2 - 5*x + 6, x)
# [2, 3]

Exemple 2 : Calculer une dérivée

from sympy import symbols, diff, sin
x = symbols('x')
f = sin(x**2)
df_dx = diff(f, x)
# 2*x*cos(x**2)

Exemple 3 : Évaluer une intégrale

from sympy import symbols, integrate, exp
x = symbols('x')
integral = integrate(x * exp(-x**2), (x, 0, oo))
# 1/2

Exemple 4 : Valeurs propres d'une matrice

from sympy import Matrix
M = Matrix([[1, 2], [2, 1]])
eigenvals = M.eigenvals()
# {3: 1, -1: 1}

Exemple 5 : Générer une fonction Python

from sympy import symbols, lambdify
import numpy as np
x = symbols('x')
expr = x**2 + 2*x + 1
f = lambdify(x, expr, 'numpy')
f(np.array([1, 2, 3]))
# array([ 4,  9, 16])

Résolution des problèmes courants

  1. "NameError: name 'x' is not defined"

    • Solution : Toujours définir les symboles en utilisant symbols() avant utilisation

  2. Résultats numériques inattendus

    • Problème : Utiliser des nombres en virgule flottante comme 0.5 au lieu de Rational(1, 2)
    • Solution : Utiliser Rational() ou S() pour l'arithmétique exacte

  3. Performance lente dans les boucles

    • Problème : Utiliser subs() et evalf() à répétition
    • Solution : Utiliser lambdify() pour créer une fonction numérique rapide

  4. "Can't solve this equation"

    • Essayer différents solveurs : solve, solveset, nsolve (numérique)
    • Vérifier si l'équation est résoluble algébriquement
    • Utiliser des méthodes numériques s'il n'existe pas de solution fermée

  5. La simplification ne fonctionne pas comme prévu

    • Essayer différentes fonctions de simplification : simplify, factor, expand, trigsimp
    • Ajouter des hypothèses aux symboles (par exemple, positive=True)
    • Utiliser simplify(expr, force=True) pour une simplification agressive

Ressources supplémentaires

Skills similaires

quality-playbook
github / awesome-copilot

Générer un système qualité complet et personnalisé pour tout projet logiciel.

34 530
migrate
launchdarkly / agent-skills

Migrer une application vers LaunchDarkly AgentControl en cinq étapes guidées.

16
onboarding
launchdarkly / agent-skills

Intégrer le SDK LaunchDarkly dans un projet existant, de la configuration aux premiers feature flags.

16
wiki
factory-ai / factory-plugins

Générer une wiki interconnectée à partir d'un dépôt de code analysé en profondeur.

80
chatgpt-apps
openai / skills

Générer des scaffolds d'apps ChatGPT conformes au SDK MCP Apps, docs en premier.

21 423