app/corpus/Classes_Extensions.py

# Importation des modules nécessaires

import re           # Module pour les expressions régulières
from sympy import symbols, oo, latex, Interval  # Importation des classes SymPy
from sympy import *
import random as rd
import math as m
from sympy.series.sequences import RecursiveSeq
from src.scripts.Mes_fctions.Mes_fctions_d_alg_lineaire_bis import pxsl_pow
import re  
from src.scripts.pxs_runtime import get_pxs_lang, myst

class pxs_Interval(Interval):
    """
    Classe personnalisée héritant de Interval de SymPy
    Permet un affichage formaté des intervalles avec :
    - Séparateurs de milliers pour les grands nombres
    - Notation française pour l'infini et les intervalles

    :pxs_trigger: |
    intervalle mathématique, domaine de définition, domaine d'étude,
    ensemble solution, ensemble image, image d'un intervalle par une fonction,
    tableau de variations intervalle, tableau de signes, borne,
    ]a;b[, [a;b], ]-\infty, +\infty[, intervalle ouvert fermé semi-ouvert,
    notation française intervalle, TVI intervalle de continuité,
    f\left(\left]...\\right]\\right), domaine de continuité, domaine de dérivabilité,
    intervalle de convexité, intervalle de monotonie,
    croissante sur I, décroissante sur I, continue sur I
    :pxs_returns: |
        Instance de classe héritant de sympy.Interval. À utiliser comme
        un Interval SymPy classique mais avec la méthode .print() pour
        obtenir l'affichage LaTeX francisé.
    :pxs_example: |
        I = pxs_Interval(-oo, 5, True, False)  # ]-∞ ; 5]
        # Dans MyST : $D = \\py{I.print()}$
    :pxs_antipattern: Utiliser sympy.Interval(...) puis latex() qui produit la notation anglo-saxonne (a, b].
    """
    @classmethod
    def from_Interval(cls, interval):
        """
        Convertit un Interval standard en pxs_Interval.

        :pxs_trigger: conversion Interval SymPy vers pxs_Interval, upcast intervalle, résultat solveset/domain
        :pxs_returns: |
            Une instance pxs_Interval reprenant les mêmes bornes et
            ouvertures que l'Interval SymPy fourni.
        :pxs_example: |
            I_sympy = Interval(0, 1, True, False)
            I_pxs = pxs_Interval.from_Interval(I_sympy)
            # Dans MyST : $\\py{I_pxs.print()}$
        :pxs_antipattern: Recréer manuellement pxs_Interval(I.start, I.end, I.left_open, I.right_open).
        """
        if not isinstance(interval, Interval):
            raise TypeError("L'objet fourni n'est pas un Interval")
        return cls(interval.start, interval.end,
                   left_open=interval.left_open,
                   right_open=interval.right_open)


    def print(self):
        """
        Méthode pour générer une représentation LaTeX formatée de l'intervalle
        
        Returns:
            str: Chaîne LaTeX formatée selon les conventions françaises

        :pxs_trigger: intervalle français, notation ]a,b[, borne infinie, affichage LaTeX intervalle, séparateur milliers intervalle
        :pxs_returns: |
            Chaîne LaTeX (objet myst) représentant l'intervalle avec délimiteurs
            français (]a,b[) ou anglais ((a,b)) selon pxs_lang, séparateurs de
            milliers pour les grands entiers, et \\infty pour les bornes infinies.
            À injecter dans MyST via \\py{...}.
        :pxs_example: |
            I = pxs_Interval(-oo, 1000, True, False)
            intervalle_latex = I.print()
            # Dans MyST : $x \\in \\py{intervalle_latex}$
            # Rendu FR : $x \\in \\left]-\\infty;1\\ 000\\right]$
        :pxs_antipattern: Concaténer manuellement f"]{a};{b}[" ou utiliser latex(Interval(...)) qui donne la notation anglo-saxonne (a, b).
        """
        
        # Formatage de la borne gauche si elle n'est pas -∞
        if self.left != -oo:
            # Exemple: 1000 devient "1\ 000"
            if isinstance(self.left, (int, Integer)):
                left_formate = f"{int(self.left):,}".replace(",", r"\ ")
            else:
                left_formate = latex(self.left)
        else:
            left_formate = myst(r""" -\infty """)
            
        
        # Formatage de la borne gauche si elle n'est pas -∞
        if self.right != oo:
            # Exemple: 1000 devient "1\ 000"
            if isinstance(self.right, (int, Integer)):
                right_formate = f"{int(self.right):,}".replace(",", r"\ ")
            else:
                right_formate = latex(self.right)
        else:
            right_formate = myst(r""" \inftys """)
        # Application des conventions françaises si la langue est française
        # Note: pxs_lang doit être définie ailleurs dans le programme
        pxs_lang = get_pxs_lang()
        if pxs_lang == "fr":  
            l_delim = r'\left[' if not self.left_open else r'\left]'
            r_delim = r'\right]' if not self.right_open else r'\right['
        if pxs_lang == "en":  
            l_delim = r'\left[' if not self.left_open else r'\left('
            r_delim = r'\right]' if not self.right_open else r'\right)'
        
            # Conversion des crochets selon la notation française
            # En français: ]a,b[ au lieu de (a,b) pour les intervalles ouverts
        if pxs_lang == "fr":
            Inter_latex = myst(r""" \py{l_delim}\py{left_formate};\py{right_formate}\py{r_delim} """, globals(), locals()) 
        else:
            Inter_latex = myst(r""" \py{l_delim}\py{left_formate},\py{right_formate}\py{r_delim} """, globals(), locals()) 
        
        # Retour de la chaîne LaTeX formatée
        return Inter_latex
    

# Tests
# \begin{python}
# # Code Python : Ecrivez ci-dessous votre code Python
# import sympy 
# import random as rd
# from sympy import *

# from pyxiscience.Mes_fctions_d_alg_generale import *
# from pyxiscience.Classes_Extensions import *

# \end{python}


# ## Test de la classe interval de Sympy versus l'extension de PyxiScience



# \begin{python}
# I1 = Interval(1, oo, True, True)
# I2 = Interval(1, oo, False, True)
# I3 = Interval(1, oo, False, False)
# I4 = Interval(1, oo, False, False)

# Id1 = Interval(1, 2, True, True)
# Id2 = Interval(1, 2, False, True)
# Id3 = Interval(1, 2, True, False)
# Id4 = Interval(1, 2, False, False)



# I1_latex = latex(I1)
# I2_latex = latex(I2)
# I3_latex = latex(I3)
# I4_latex = latex(I4)





# Inter_1 = pxs_Interval(1, oo, True, True)
# Inter_2 = pxs_Interval(1, oo, False, True)
# Inter_3 = pxs_Interval(1, oo, False, False)
# Inter_4 = pxs_Interval(1, oo, False, False)

# Interd_1 = pxs_Interval(1, 2, True, True)
# Interd_2 = pxs_Interval(1, 2, False, True)
# Interd_3 = pxs_Interval(1, 2, True, False)
# Interd_4 = pxs_Interval(1, 2, False, False)


# \end{python}

# $I = \py{I1}$

# C'est normal car on appelle l'objet python directement...




# ## Avec interval de Sympy


# \begin{equation*}
# &I_1 = \py{I1_latex}&
# &I_2 = \py{I2_latex}&
# &I_3 = \py{I3_latex}&
# &I_4 = \py{I4_latex}&\\

# &Id_1 = \py{Interd_1.print()}&
# &Id_2 = \py{Interd_2.print()}&
# &Id_3 = \py{Interd_3.print()}&
# &Id_4 = \py{Interd_4.print()}&
# \end{equation*}



# ## Avec pxs_interval
# \begin{equation*}
# &I_1 = \py{Inter_1.print()}&
# &I_2 = \py{Inter_2.print()}&
# &I_3 = \py{Inter_3.print()}&
# &I_4 = \py{Inter_4.print()}&\\

# &Id_1 = \py{Interd_1.print()}&
# &Id_2 = \py{Interd_2.print()}&
# &Id_3 = \py{Interd_3.print()}&
# &Id_4 = \py{Interd_4.print()}&
# \end{equation*}






#from sympy import *

class ReverseString:
    """
    Classe utilitaire pour inverser l'ordre de tri des chaînes de caractères.
    Utilisée pour trier les variables dans l'ordre inverse alphabétique.

    :pxs_trigger: tri inverse alphabétique, ordre descendant variables, clé de tri personnalisée polynôme
    :pxs_returns: |
        Wrapper autour d'une chaîne dont __lt__ est inversé, à utiliser comme
        key dans sorted() pour trier de z vers a au lieu de a vers z.
    :pxs_example: |
        vars_sorted = sorted(["y", "x", "z"], key=ReverseString)
        # → ["z", "y", "x"]
    :pxs_antipattern: Utiliser sorted(..., reverse=True) qui inverse TOUT le tri y compris la clé principale (puissance).
    """
    def __init__(self, string):
        """
        Initialise le wrapper autour de la chaîne à inverser.

        :pxs_trigger: instanciation interne classe ReverseString
        :pxs_returns: |
            Instance ReverseString encapsulant la chaîne fournie.
        :pxs_example: |
            wrap = ReverseString("x")
            # Utilisé typiquement via sorted(..., key=ReverseString)
        :pxs_antipattern: Appeler ReverseString directement dans du code pédagogique — c'est un utilitaire interne de tri.
        """
        self.string = string
    
    def __lt__(self, other):
        """
        Comparaison inversée pour le tri descendant.

        :pxs_trigger: comparaison tri inverse interne
        :pxs_returns: |
            bool : True si self.string > other.string (comparaison inversée).
        :pxs_example: |
            ReverseString("a") < ReverseString("b")  # False (car 'a' < 'b' devient inversé)
        :pxs_antipattern: Appeler __lt__ directement au lieu de laisser Python l'utiliser via sorted().
        """
        return self.string > other.string  # Inversion de la comparaison
    
    def __eq__(self, other):
        """
        Égalité standard entre chaînes.

        :pxs_trigger: égalité interne ReverseString
        :pxs_returns: |
            bool : True si les deux chaînes encapsulées sont identiques.
        :pxs_example: |
            ReverseString("x") == ReverseString("x")  # True
        :pxs_antipattern: Appeler __eq__ directement au lieu d'utiliser ==.
        """
        return self.string == other.string

class pxs_Poly(Poly):
    """
    Extension de la classe Poly de SymPy avec une méthode d'affichage personnalisée.
    Permet d'afficher les polynômes avec un formatage LaTeX personnalisé et une factorisation optionnelle.

    :pxs_trigger: polynôme pédagogique, trinôme second degré, affichage LaTeX polynôme, discriminant racines factorisation
    :pxs_returns: |
        Classe héritant de sympy.Poly, avec méthodes pxsl_print, pxsl_discriminant,
        pxsl_solution, pxs_factor et pxs_generate pour usage pédagogique en MyST.
    :pxs_example: |
        p = pxs_Poly(x**2 + 3*x - 4, x)
        # Dans MyST : $P(x) = \\py{p.pxsl_print()}$
    :pxs_antipattern: Utiliser sympy.Poly puis latex() et écrire à la main le calcul du discriminant ou des racines.
    """

    @classmethod
    def pxs_generate(cls, x = Symbol("x"), lim_coeff = 9, nb_root = None):
        """
        Génère un polynôme du second degré avec des coefficients aléatoires non nuls,
        en contrôlant optionnellement le nombre de racines réelles.
    
        Args:
            x: Variable symbolique du polynôme (par défaut Symbol("x"))
            lim_coeff: Valeur maximale absolue des coefficients (par défaut 9)
            nb_root: Nombre de racines réelles souhaité (0, 1, 2 ou None pour aléatoire)
        
        Returns:
            Un objet pxs_Poly représentant le polynôme ax² + bx + c généré

        :pxs_trigger: générer trinôme aléatoire, exercice second degré avec n racines, discriminant positif/négatif/nul contrôlé
        :pxs_returns: |
            Un objet pxs_Poly de la forme ax² + bx + c avec a, b, c entiers
            non nuls, et discriminant contrôlé selon nb_root (0, 1, 2 ou aléatoire).
        :pxs_example: |
            p = pxs_Poly.pxs_generate(nb_root=2)
            # Trinôme à 2 racines réelles distinctes, coeffs dans [-9,9]\\{0}
            # Dans MyST : $P(x) = \\py{p.pxsl_print()}$
        :pxs_antipattern: Tirer a, b, c au hasard avec random.randint puis vérifier le signe du discriminant dans une boucle while.
        """
        # Génération aléatoire des signes pour chaque coefficient
        sign_coeff = [rd.choice([-1,1]), rd.choice([-1,1]), rd.choice([-1,1])]

        # Génération des coefficients a, b, c (tous non nuls)
        # Valeurs entre 1 et lim_coeff, multipliées par leur signe
        a = sign_coeff[0] * rd.randint(1, lim_coeff)
        b = sign_coeff[1] * rd.randint(1, lim_coeff)
        c = sign_coeff[2] * rd.randint(1, lim_coeff)

        # Création du polynôme initial
        p = Poly(a * x**2 + b * x + c, x)
        
        # Si aucune contrainte sur le nombre de racines, retourner le polynôme tel quel
        if nb_root is None:
            return p

        # CAS 1 : On veut 0 racine réelle (Δ < 0)
        # Condition : b² < 4ac, donc a et c doivent être de même signe
        if nb_root == 0 and p.discriminant() >= 0:
            # Forcer a et c à avoir le même signe (on utilise sign[0] pour les deux)
        	c = sign_coeff[0] * rd.randint(1,9)
            # Choisir b tel que b < 2√(ac) pour garantir Δ < 0
        	b = sign_coeff[1] * rd.randint(1, int(2 * m.sqrt(a * c)-1))

        # CAS 2 : On veut 1 racine double (Δ = 0)
        # Condition : b² = 4ac, donc b = ±2√(ac)
        if nb_root == 1 and p.discriminant() != 0:
            # Pour faciliter, on choisit a et c comme des carrés parfaits
            a = sign_coeff[0] * rd.randint(1, int(m.sqrt(lim_coeff)))**2
            c = sign_coeff[0] * rd.randint(1, int(m.sqrt(lim_coeff)))**2
            
            # Vérifier qu'on ne dépasse pas la limite des coefficients
            if a >= lim_coeff and c >= lim_coeff:
                # Si les deux sont trop grands, prendre des valeurs égales plus petites
                a = sign_coeff[0] * rd.randint(1, lim_coeff)
                c = a

            # Calculer b pour avoir exactement Δ = 0
            b = rd.choice([-1,1]) * int(2 * m.sqrt(a * c))

        # CAS 3 : On veut 2 racines distinctes (Δ > 0)
        # Condition : b² > 4ac, donc c < b²/(4a)
        if nb_root == 2 and p.discriminant() <= 0 :
            # Choisir c dans l'intervalle qui garantit Δ > 0
            # c doit être inférieur à b²/(4a) - 1 pour avoir une marge
            c = sign_coeff[2] * rd.randint(-lim_coeff, min(int(b**2 / (4 * a)) - 1, lim_coeff)) 
            
            # S'assurer que c n'est pas nul (tous les coefficients doivent être non nuls)
            while c == 0:
                c = sign_coeff[0] * rd.randint(-lim_coeff, int(b**2 / (4 * a)) - 1) 

        # Retourner le polynôme avec les coefficients ajustés
        return cls(a * x**2 + b * x + c, x)
    
    def pxsl_print(self, variable=None, ascending=False, displaystyle=True, factor=False):
        """
        Affiche le polynôme avec un formatage LaTeX personnalisé.
        
        Paramètres:
        - variable: Variable principale pour l'organisation/factorisation (None = auto-détection)
        - ascending: Si True, trie par puissances croissantes, sinon décroissantes
        - displaystyle: Si True, utilise le style d'affichage LaTeX étendu
        - factor: Si True, factorise le polynôme par rapport à la variable spécifiée
        
        Retourne:
        - String: Expression LaTeX formatée

        :pxs_trigger: afficher polynôme pédagogique, ordre puissances croissantes/décroissantes, factoriser par variable, polynôme deux variables
        :pxs_returns: |
            Chaîne LaTeX (str) représentant le polynôme avec termes triés selon
            'variable' et 'ascending', coefficients 1/-1 simplifiés, et
            optionnellement factorisé par 'variable' si factor=True.
        :pxs_example: |
            p = pxs_Poly(3*x*y - x**2 + y**2 + x + 2)
            # Dans MyST : $P = \\py{p.pxsl_print(variable=x)}$
            # Avec factor=True : $P = \\py{p.pxsl_print(variable=x, factor=True)}$
        :pxs_antipattern: Utiliser latex(poly.as_expr()) qui trie mal les termes multi-variables et n'offre pas la factorisation par variable.
        """
        
        def is_numeric_key(key):
            """
            Vérifie si une clé est numérique (pour filtrer les constantes).
            Utilisée pour séparer les variables des constantes numériques.
            """
            try:
                float(key)
                return True
            except (ValueError, TypeError):
                return False

        # Convertir le polynôme en expression SymPy
        expr = self.as_expr()

        # Auto-détection de la variable si non spécifiée
        if variable is None:
            variables = sorted(expr.free_symbols, key=str)
            if not variables: 
                return latex(expr)  # Retourne directement si pas de variables
        else:
            variables = variable 
    
        # MODE FACTORISATION : traitement spécial quand factor=True
        if factor and variable is not None:
            # Utilise la fonction collect() de SymPy pour factoriser par la variable
            factored_expr = collect(expr, variable)
            
            # Dictionnaire pour organiser les termes par puissance de la variable
            terms_by_power = {}
            constant_terms = []  # Termes qui ne contiennent pas la variable
            
            # Analyser chaque terme de l'expression factorisée
            for term in Add.make_args(factored_expr):
                if term.has(variable):
                    # Trouver la puissance de la variable dans ce terme
                    power = 0
                    coeff = term
                    
                    # Recherche de la puissance (de 10 à 1 pour prendre la plus haute)
                    for p in range(10, 0, -1):
                        c = term.coeff(variable, p)  # Coefficient de variable^p
                        if c != 0:
                            power = p
                            coeff = c
                            break
                    
                    # Stocker le coefficient pour cette puissance
                    if power > 0:
                        terms_by_power[power] = coeff
                else:
                    # Terme constant (ne contient pas la variable)
                    constant_terms.append(term)
            
            # Construction de l'affichage avec la variable APRÈS le coefficient
            result_terms = []
            
            # Traiter les termes par puissance décroissante
            for power in sorted(terms_by_power.keys(), reverse=True):
                coeff = terms_by_power[power]
                
                if power == 1:
                    # Cas spécial : puissance 1 (pas d'exposant affiché)
                    if coeff == 1:
                        result_terms.append(f"{latex(variable)}")
                    elif coeff == -1:
                        result_terms.append(f"-{latex(variable)}")
                    else:
                        coeff_str = latex(coeff)
                        # Ajouter des parenthèses si le coefficient est complexe
                        if len(str(coeff).split()) > 1 or '+' in coeff_str or '-' in coeff_str[1:]:
                            result_terms.append(f"({coeff_str}){latex(variable)}")
                        else:
                            result_terms.append(f"{coeff_str}{latex(variable)}")
                else:
                    # Puissances supérieures à 1
                    if coeff == 1:
                        result_terms.append(f"{latex(variable)}^{{{power}}}")
                    elif coeff == -1:
                        result_terms.append(f"-{latex(variable)}^{{{power}}}")
                    else:
                        coeff_str = latex(coeff)
                        # Ajouter des parenthèses si le coefficient est complexe
                        if len(str(coeff).split()) > 1 or '+' in coeff_str or '-' in coeff_str[1:]:
                            result_terms.append(f"({coeff_str}){latex(variable)}^{{{power}}}")
                        else:
                            result_terms.append(f"{coeff_str}{latex(variable)}^{{{power}}}")
            
            # Ajouter les termes constants à la fin
            for term in constant_terms:
                result_terms.append(latex(term))
            
            # Assemblage final avec gestion des signes
            if not result_terms:
                return "0"
            
            result = result_terms[0]
            for term in result_terms[1:]:
                if term.startswith('-'):
                    result += term  # Pas de '+' avant un terme négatif
                else:
                    result += f"+{term}"
            
            return result
    
        # MODE NORMAL : affichage standard sans factorisation
        terms = []
        
        # Analyser chaque terme de l'expression pour extraire puissances et coefficients
        for term in Add.make_args(expr):
            power = 0  # Puissance de la variable principale (0 pour les constantes)
            rest = 1   # Coefficient/reste du terme
            
            # Traitement quand aucune variable n'est spécifiée (auto-détection)
            if variable is None:
                powers = 0  # Somme de toutes les puissances du terme (pour le tri)
                entire_power_dict = term.as_powers_dict()
                
                # Filtrer les clés numériques (constantes)
                keys_to_remove = []
                for key in entire_power_dict.keys():
                    try:
                        float(key)
                        keys_to_remove.append(key)
                    except (ValueError, TypeError):
                        pass  # La clé n'est pas numérique, on la garde
                
                # Créer un dictionnaire sans les constantes numériques
                power_dict = {k: v for k, v in entire_power_dict.items() if not is_numeric_key(k)}
                
                try:
                    # Choisir la variable "principale" (la plus grande alphabétiquement)
                    variable = max(power_dict.keys())
                    power = power_dict[variable]
                    rest = term / (variable ** power) if variable else term
                except (ValueError, TypeError):
                    # Pas de variable trouvée, c'est un terme constant
                    variable = None
                    rest = term
                
                # Calculer la somme totale des puissances pour le tri
                powers = sum(power_dict.values())
                terms.append((powers, power, variable, False, rest))
                variable = None  # Reset pour le prochain terme
                
            else:
                # Variable spécifiée : analyser chaque facteur du terme
                for factor in Mul.make_args(term):
                    if factor.has(variable):
                        # Ce facteur contient la variable
                        power_dict = factor.as_powers_dict()
                        power = power_dict[variable]
                        # Diviser par la variable à la puissance pour isoler le coefficient
                        rest *= factor / (variable ** power)
                    else:
                        # Ce facteur ne contient pas la variable, c'est part du coefficient
                        rest *= factor
                
                # Déterminer si le terme contient d'autres variables (pour le tri)
                if variable is not None:
                    has_other_var = False
                    if len(expr.free_symbols) > 1:
                        # Vérifie si le coefficient contient d'autres variables
                        has_other_var = len(rest.free_symbols) > 0
            
                    terms.append((power, power, variable, has_other_var, rest))
    
        # TRI DES TERMES selon les paramètres spécifiés
        if variable is None:
            # Tri global par somme des puissances, puis par puissance individuelle, puis par nom de variable
            if ascending:
                terms.sort(key=lambda x: (x[0], x[1], ReverseString(str(x[2]))))
            else:
                terms.sort(key=lambda x: (x[0], x[1], ReverseString(str(x[2]))), reverse=True)
        else:
            # Tri par puissance de la variable spécifiée
            if ascending:
                # Ordre croissant des puissances, termes avec autres variables après
                terms.sort(key=lambda x: (x[1], x[3]))
            else:
                # Ordre décroissant des puissances, termes avec autres variables après
                terms.sort(key=lambda x: (x[1], x[3]), reverse=True)
    
        # CONSTRUCTION DE L'EXPRESSION LATEX FINALE
        result = ""
    
        for i, (powers, power, variable, has_other_var, coeff) in enumerate(terms):
            # Analyse du coefficient pour la gestion des signes
            is_negative = latex(coeff).startswith('-')

            # Vérification si le coefficient est +1 ou -1 (pour simplifier l'affichage)
            try:
                is_One = coeff == 1
            except TypeError:
                is_One = False
            try:
                is_minus_One = coeff == -1
            except TypeError:
                is_minus_One = False
        
            # CONSTRUCTION DU TERME selon sa puissance
            if power == 0:
                # Terme constant (pas de variable)
                term = f"{latex(coeff)}"
            elif power == 1:
                # Puissance 1 (variable sans exposant)
                if is_One:
                    term = f"{latex(variable)}"
                elif is_minus_One:
                    term = f"-{latex(variable)}"
                else:
                    if displaystyle:
                        term = f"\\displaystyle {latex(coeff)}{latex(variable)}"
                    else:
                        term = f"{latex(coeff)}{latex(variable)}"
            else:
                # Puissances supérieures à 1
                if is_One:
                    term = f"{latex(variable)}^{power}"
                elif is_minus_One:
                    term = f"-{latex(variable)}^{power}"
                else:
                    if displaystyle:
                        term = f"\\displaystyle {latex(coeff)}{latex(variable)}^{power}"
                    else:
                        term = f"{latex(coeff)}{latex(variable)}^{power}"
        
            # GESTION DES SIGNES pour l'assemblage final
            if i == 0 or is_negative:
                # Premier terme ou terme négatif : pas de '+' devant
                result += term
            else:
                # Terme positif : ajouter un '+'
                result += f" +{term}"
    
        # Retourner l'expression LaTeX complète
        return result
    
    def pxsl_discriminant(self, mult = "\\times", formula = True):
        """
        Calcule et affiche le discriminant d'une équation du second degré au format LaTeX.
    
        Args:
            mult: Symbole de multiplication à utiliser (par défaut \times en LaTeX)
    
        Returns:
            Un objet myst contenant l'affichage LaTeX du calcul du discriminant

        :pxs_trigger: calcul discriminant, Delta = b²-4ac, étapes substitution trinôme, exercice second degré
        :pxs_returns: |
            Objet myst contenant le calcul multi-lignes du discriminant au
            format LaTeX aligné (utilisable dans un environnement equation*+split),
            avec ou sans la formule littérale Δ = b²-4ac en première ligne.
        :pxs_example: |
            p = pxs_Poly(x**2 - 5*x + 6, x)
            calc = p.pxsl_discriminant()
            # Dans MyST :
            # \\begin{equation*}\\begin{split}
            # \\py{calc}
            # \\end{split}\\end{equation*}
        :pxs_antipattern: Écrire à la main "\\Delta = b^2-4ac = {b**2} - 4*{a}*{c} = ..." avec f-strings et risquer les signes négatifs mal parenthésés.
        """
        # Récupération de tous les coefficients de l'équation (a, b, c)
        coeffs = self.all_coeffs()

        # Génération de l'affichage LaTeX du calcul du discriminant
        # avec les étapes de substitution et de calcul
        if formula:
            return myst(r""" 
        \Delta &= b^2-4ac\\
        &= \py{pxsl_pow(coeffs[1],2)} - 4 \py{mult}\py{pxsl_pow(coeffs[0],1)} \py{mult}\py{pxsl_pow(coeffs[2],1)}\\
        &=\py{latex(self.discriminant())}"""
        ,globals(), locals())
        else:
            return myst(r""" 
        \Delta &= \py{pxsl_pow(coeffs[1],2)} - 4 \py{mult}\py{pxsl_pow(coeffs[0],1)} \py{mult}\py{pxsl_pow(coeffs[2],1)}\\
        &=\py{latex(self.discriminant())}"""
        ,globals(), locals())

    def pxsl_solution(self, mult = "\\times", formula = True):
        """
        Affiche la ou les solutions d'une équation du second degré au format LaTeX.

        Args:
            mult: Symbole de multiplication à utiliser (par défaut \times en LaTeX)

        Returns:
            Un tuple de 4 éléments (x1_complet, x2_complet, x1_final, x2_final) où :
            - x1_complet, x2_complet : calculs détaillés étape par étape
            - x1_final, x2_final : formes finales simplifiées
            Retourne (None, None, None, None) si pas de solution réelle

        :pxs_trigger: résoudre équation second degré, racines trinôme, x1 x2, formule (-b±√Δ)/2a, solution double
        :pxs_returns: |
            Tuple (x_1_complet, x_2_complet, x_1_final, x_2_final) d'objets myst :
            les deux premiers contiennent le calcul détaillé étape par étape,
            les deux derniers la forme simplifiée finale. Si Δ=0, les deux
            solutions sont égales. Si Δ<0, retourne (None, None, None, None).
        :pxs_example: |
            p = pxs_Poly.pxs_generate(nb_root=2)
            expr_x1, expr_x2, x1, x2 = p.pxsl_solution()
            # Dans MyST :
            # $x_1 = \\py{expr_x1}$, $x_2 = \\py{expr_x2}$
            # Finalement : $x_1 = \\py{x1}$ et $x_2 = \\py{x2}$
        :pxs_antipattern: Calculer sqrt(disc) puis composer une f-string "-b - sqrt(D) / 2a" à la main, en oubliant la simplification des fractions ou la réduction de √Δ.
        """
        # Récupération de tous les coefficients de l'équation (a, b, c)
        coeffs = self.all_coeffs()

        # Vérifier si le discriminant peut être simplifié (contient des facteurs carrés)
        factors = factorint(self.discriminant())
        is_reducible = False
        for prime, power in factors.items():
            if power >= 2:
                is_reducible = True
    
        # Préparer l'affichage des coefficients avec parenthèses si négatifs
        if self.discriminant() >= 0:
            coeff_fin = [pxsl_pow(coeff, 1) for coeff in coeffs]
        
        # CAS 1 : Discriminant strictement positif (2 solutions distinctes)
        if self.discriminant() > 0:
            # Calcul détaillé de x1 = (-b - √Δ) / 2a
            if formula:
                x_1 = myst(r""" \displaystyle{\frac{-b-\sqrt{\Delta}}{2a}}=\displaystyle{\frac{-\py{coeff_fin[1]}-\sqrt{\py{self.discriminant()}}}{2\py{mult}\py{coeff_fin[0]}}}=\displaystyle{\frac{\py{-coeffs[1]}-\py{latex(sqrt(self.discriminant()))}}{\py{2*coeffs[0]}}}""",globals(), locals())
            else:
                x_1 = myst(r""" \displaystyle{\frac{-\py{coeff_fin[1]}-\sqrt{\py{self.discriminant()}}}{2\py{mult}\py{coeff_fin[0]}}}=\displaystyle{\frac{\py{-coeffs[1]}-\py{latex(sqrt(self.discriminant()))}}{\py{2*coeffs[0]}}}""",globals(), locals())
        
            # Calcul détaillé de x2 = (-b + √Δ) / 2a
            if formula:
                x_2 = myst(r""" \displaystyle{\frac{-b+\sqrt{\Delta}}{2a}}=\displaystyle{\frac{-\py{coeff_fin[1]}+\sqrt{\py{self.discriminant()}}}{2\py{mult}\py{coeff_fin[0]}}}=\displaystyle{\frac{\py{-coeffs[1]}+\py{latex(sqrt(self.discriminant()))}}{\py{2*coeffs[0]}}}""",globals(), locals())
            else:
                x_2 = myst(r""" \displaystyle{\frac{-\py{coeff_fin[1]}+\sqrt{\py{self.discriminant()}}}{2\py{mult}\py{coeff_fin[0]}}}=\displaystyle{\frac{\py{-coeffs[1]}+\py{latex(sqrt(self.discriminant()))}}{\py{2*coeffs[0]}}}""",globals(), locals())
        
            # Si √Δ est un entier (carré parfait), calculer directement les fractions
            if isinstance(sqrt(self.discriminant()),Integer) or isinstance(sqrt(self.discriminant()),Rational):
                x_1 += myst(r""" =\displaystyle{\frac{\py{latex(-coeffs[1]-sqrt(self.discriminant()))}}{\py{2*coeffs[0]}}}""",globals(), locals())
                x_1final = myst(r"""\displaystyle{\py{latex(Rational(-coeffs[1]-sqrt(self.discriminant()),2*coeffs[0]))}} """,globals(), locals())
                x_2 += myst(r""" =\displaystyle{\frac{\py{latex(-coeffs[1]+sqrt(self.discriminant()))}}{\py{2*coeffs[0]}}}""",globals(), locals())
                x_2final = myst(r"""\displaystyle{\py{latex(Rational(-coeffs[1]+sqrt(self.discriminant()),2*coeffs[0]))}} """,globals(), locals())
                return x_1 + myst(r"""= """) + x_1final, x_2 + myst(r""" = """) + x_2final, x_1final, x_2final
        
            # Si √Δ n'est pas un entier, essayer de simplifier l'expression
            else:
                # Si a > 0 et qu'on peut simplifier (PGCD ou racine réductible)
                if coeffs[0] > 0 and (gcd(-coeffs[1],2*coeffs[0]) != 1 or is_reducible):
                    # Séparer la partie rationnelle et la partie irrationnelle
                    x_1final = myst(r"""\displaystyle{\py{latex(Rational(-coeffs[1],2*coeffs[0]))}-\py{latex(sqrt(self.discriminant())/(2*coeffs[0]))}}""", globals(), locals())
                    x_2final = myst(r"""\displaystyle{\py{latex(Rational(-coeffs[1],2*coeffs[0]))}+\py{latex(sqrt(self.discriminant())/(2*coeffs[0]))}}""", globals(), locals())
                    return x_1 + myst(r"""=""") + x_1final, x_2 + myst(r"""=""") + x_2final, x_1final, x_2final
            
                # Si a < 0, ajuster les signes pour un affichage plus propre
                elif coeffs[0] < 0 :
                    x_1final = myst(r"""\displaystyle{\py{latex(Rational(-coeffs[1],2*coeffs[0]))}+\py{latex(sqrt(self.discriminant())/(-2*coeffs[0]))}}""", globals(), locals())
                    x_2final = myst(r"""\displaystyle{\py{latex(Rational(-coeffs[1],2*coeffs[0]))}-\py{latex(sqrt(self.discriminant())/(-2*coeffs[0]))}}""", globals(), locals())
                    return x_1 + myst(r"""= """) + x_1final, x_2 + myst(r"""= """) + x_2final, x_1final, x_2final
            
                # Cas par défaut : garder la forme fractionnaire complète
                else:
                    x_1final = myst(r"""\displaystyle{\frac{\py{-coeffs[1]}-\py{latex(sqrt(self.discriminant()))}}{\py{2*coeffs[0]}}}""",globals(), locals())
                    x_2final = myst(r"""\displaystyle{\frac{\py{-coeffs[1]}+\py{latex(sqrt(self.discriminant()))}}{\py{2*coeffs[0]}}}""",globals(), locals())
                    return x_1, x_2, x_1final, x_2final
    
        # CAS 2 : Discriminant nul (1 solution double)
        if self.discriminant() == 0:
            # Calcul détaillé de x0 = -b / 2a
            x_0 = myst(r""" \displaystyle{\frac{-b}{2a}}=\displaystyle{\frac{-\py{coeff_fin[1]}}{2\py{mult}\py{coeff_fin[0]}}}=\displaystyle{\frac{\py{-coeffs[1]}}{\py{2*coeffs[0]}}}""",globals(), locals())
        
            # Si on peut simplifier la fraction (PGCD > 1 ou a < 0)
            if coeffs[0] > 0 and gcd(-coeffs[1],2*coeffs[0]) != 1:
                x_0final = myst(r"""\displaystyle{\py{latex(Rational(-coeffs[1],2*coeffs[0]))}}""", globals(), locals())
                return x_0 + myst(r"""= """) + x_0final, x_0 + myst(r"""= """) + x_0final, x_0final, x_0final
            elif coeffs[0] < 0 :
                x_0final = myst(r"""\displaystyle{\py{latex(Rational(-coeffs[1],2*coeffs[0]))}}""", globals(), locals())
                return x_0 + myst(r"""= """) + x_0final, x_0 + myst(r"""= """) + x_0final, x_0final, x_0final
        
            # Cas par défaut : garder la forme fractionnaire
            else:
                x_0final = myst(r"""\displaystyle{\frac{\py{-coeffs[1]}}{\py{2*coeffs[0]}}}""",globals(), locals())
                return x_0, x_0, x_0final, x_0final
    
        # CAS 3 : Discriminant négatif (pas de solution réelle)
        if self.discriminant() < 0:
            return None, None, None, None

    def pxs_factor(self, variable = None, display = "\displaystyle"):
        """
        Factorise un polynôme en utilisant sympy.Poly.
        Prend un objet Poly en argument.

        :pxs_trigger: factoriser polynôme par variable dominante, mise en facteur x^n, x²(1 + 1/x + 1/x²), factorisation forcée par plus haut degré
        :pxs_returns: |
            Tuple (myst_expr, factor, term) :
            - myst_expr : chaîne LaTeX "x^n (1 + a/x + ... )" prête à injecter en MyST
            - factor : expression sympy du facteur sorti (variable ** degré)
            - term : expression sympy du contenu entre parenthèses
        :pxs_example: |
            p = pxs_Poly(3*x**2 + 2*x + 1, x)
            expr, fact, term = p.pxs_factor(variable=x)
            # Dans MyST : $P = \\py{expr}$  →  $x^2(3 + 2/x + 1/x^2)$
        :pxs_antipattern: Utiliser sympy.factor() qui cherche une factorisation complète sur Q, ou construire la mise en facteur de x^n à la main avec des f-strings.
        """
    
        # Récupérer la variable (premier générateur)
        if variable is None and len(self.gens) != 1:
            raise ValueError("Il faut spécifier une variable pour factoriser un polynôme à plusieurs variables")
        if variable is None:
            variable = self.gens[0]  # si variable n'est précisé c'est qu'il n'y en a qu'une, on la récupère

        p = pxs_Poly(self, variable)
    
    # Récupérer tous les coefficients (SymPy gère automatiquement l'ordre)
        coeffs = p.all_coeffs()  # Coefficients dans l'ordre décroissant des puissances
        degree_poly = p.degree()
    
        if degree_poly == 0:
            return str(coeffs[0])

        # renvoyer le même terme si y en a qu'un
    
    # Construire la factorisation
        factorized_form = myst(r"""""")
        term = 0
    
    # Parcourir tous les coefficients depuis la plus haute puissance
        for i, coeff in enumerate(coeffs):
            if coeff == 0:
                continue
            current_power = degree_poly - i
        
        # Coefficient relatif au terme principal
            power_diff = degree_poly - current_power
            
        # Gestion du signe
            try:
                if coeff > 0 and i != 0:
                    sign_coeff = "+"
                else:
                    sign_coeff = ""
            except:
                coeff_str = str(coeff)
                if i != 0 and not coeff_str.startswith('-'):
                    sign_coeff = "+"
                else:
                    sign_coeff = ""
            
        # Formatage selon la différence de puissance
            if i == 0:
                term +=coeff
                factorized_form += myst(r"""\py{latex(coeff)}""", globals(), locals())
                continue
            if power_diff == 1:
                term += coeff/variable
            # Division par variable
                if coeff == 1:
                    factorized_form += myst(r"""\py{sign_coeff}\py{display}\py{latex(1/variable)}""", globals(), locals())
                elif coeff == -1:
                    factorized_form += myst(r"""-\py{display}\py{latex(1/variable)}""", globals(), locals())
                else:
                    factorized_form += myst(r"""\py{sign_coeff} \py{display}\py{latex(coeff/variable)}""", globals(), locals())
            else:
                term += coeff/(variable**power_diff)
            # Division par variable^power_diff
                if coeff == 1:
                    factorized_form += myst(r"""\py{sign_coeff}\py{display}\py{latex(1/variable**power_diff)}""", globals(), locals())
                elif coeff == -1:
                    factorized_form += myst(r"""-\py{display}\py{latex(1/variable**power_diff)}""", globals(), locals())
                else:
                    factorized_form += myst(r"""\py{sign_coeff}\py{display}\py{latex(coeff/variable**power_diff)}""", globals(), locals())
    
        # Construire le facteur principal
        factor = variable**degree_poly
        factor_latex = myst(r"""\py{pxsl_pow(variable, degree_poly)}""", globals(), locals())
    
        return myst(r"""\py{factor_latex}\left(\py{factorized_form}\right) """, globals(), locals()), factor, term
    
""" X = Symbol('X')
y = Symbol('y')
x = Symbol('x')
poly = pxs_Poly(3*x**4*y**2+Rational(2,3)*x**2*y+3, x)
poly2 = pxs_Poly(3*x**4*y**2+Rational(2,3)*x**2*y+3)

p1 = pxs_Poly.pxs_generate(nb_root = 2)
p2 = pxs_Poly.pxs_generate(nb_root = 1)
p3 = pxs_Poly.pxs_generate(nb_root = 0)

expr1 = pxs_Poly(1 + x + x**2)
expr2 = pxs_Poly(3*x**2 - 5*x + 7 - 2*x**3)
expr3 = pxs_Poly(3*x*y - x**2 + y**2 + x + 2)
expr4 = pxs_Poly(x/2 - x**2/3 + 5)
expr5 = pxs_Poly(3*X*y + 2*X**2 + y**2 + X + 2)
expr6 = pxs_Poly(3*x**4*y**2+Rational(2,3)*x**2 +x**2*y+3,x)

poly = pxs_Poly.pxs_generate(nb_root = 2)
[expr_x1, expr_x2, x1, x2] = poly.pxsl_solution()
poly = pxs_Poly.pxs_generate(nb_root = 1)
[expr_x0, expr_x0, x0, x0] = poly.pxsl_solution()

\end{python}

Méthode pxs_generate(cls, x = Symbol("x"), lim_coeff = 9, nb_root = None)

$\py{latex(pxs_Poly.pxs_generate().as_expr())}$

$\py{latex(pxs_Poly.pxs_generate(y).as_expr())}$

Modifier la limite des coefficients : $\py{latex(pxs_Poly.pxs_generate(lim_coeff = 2).as_expr())}$

2 racines : $\py{latex(p1.as_expr())}$ $\longrightarrow$ $\Delta = \py{p1.discriminant()}$

1 racine : $\py{latex(p2.as_expr())}$ $\longrightarrow$ $\Delta = \py{p2.discriminant()}$

0 racine : $\py{latex(p3.as_expr())}$ $\longrightarrow$ $\Delta = \py{p3.discriminant()}$

________________________________________________

Méthode pxsl_print(self, variable=None, ascending=False, displaystyle=True, factor = False)

expr1: $\py{expr1.pxsl_print()}$

expr1 en ordre croissant: $\py{expr1.pxsl_print(ascending = True)}$

expr2: $\py{expr2.pxsl_print()}$

expr3: $\py{expr3.pxsl_print()}$

Par rapport à x : $\py{expr3.pxsl_print(variable = x)}$

Par rapport à y : $\py{expr3.pxsl_print(variable = y)}$

expr4: $\py{expr4.pxsl_print()}$

expr4, sans displaystyle: $\py{expr4.pxsl_print(displaystyle = False)}$

expr5: $\py{expr5.pxsl_print()}$

Par rapport à X : $\py{expr5.pxsl_print(variable = X)}$

expr6, Forme développée : $\py{expr6.pxsl_print(factor=False, variable=x)}$

expr6, Forme factorisée en x : $\py{expr6.pxsl_print(factor=True, variable=x)}$
_________________________________________________________

Méthode pxsl_discriminant(self, mult = "\\times")

expr1: 
\begin{equation*}
\begin{split}
\py{expr1.pxsl_discriminant()}
\end{split}
\end{equation*}

expr4: 
\begin{equation*}
\begin{split}
\py{expr4.pxsl_discriminant()}
\end{split}
\end{equation*}

en modifiant le signe multiplié :
\begin{equation*}
\begin{split}
\py{expr4.pxsl_discriminant("\cdot")}
\end{split}
\end{equation*}
_____________________________________________________________

Méthode pxsl_solution(self, mult = "\\times")

2 racines :

\begin{equation*}
x_1 = \py{expr_x1}
\end{equation*}
et
\begin{equation*}
x_2 = \py{expr_x2}.
\end{equation*}

\begin{equation*}
x_1 =\py{x1}\textrm{ et }x_2 = \py{x2}.
\end{equation*}

1 racine : 

\begin{equation*}
x_0 = \py{expr_x0}
\end{equation*}

\begin{equation*}
x_0 =\py{x0}.
\end{equation*}
____________________________________________________________

Méthode pxs_factor(self, variable = None, display = "\displaystyle")

expr1 : $\py{expr1.pxs_factor()[0]}$

factor : $\py{latex(expr1.pxs_factor(variable = x)[1])}$

term : $\py{latex(expr1.pxs_factor(variable = x)[2])}$

expr3: $\py{expr3.pxsl_print()}$

expr3 par rapport à $x$: $\py{expr3.pxs_factor(variable = x)[0]}$

factor : $\py{latex(expr3.pxs_factor(variable = x)[1])}$

term : $\py{latex(expr3.pxs_factor(variable = x)[2])}$

expr3 par rapport à $y$: $\py{expr3.pxs_factor(variable = y)[0]}$

factor : $\py{latex(expr3.pxs_factor(variable = y)[1])}$

term : $\py{latex(expr3.pxs_factor(variable = y)[2])}$
 """



class pxs_SeqFormula(SeqFormula):
    """
    Sous-classe de SeqFormula offrant une méthode de sommation des coefficients.
    La méthode pxsl_summation produit une expression (myst) représentant
    la somme des coefficients de la suite entre deux indices, soit en valeur
    numérique, soit en notation symbolique.

    :pxs_trigger: suite numérique, suite avec somme, SeqFormula pédagogique, somme développée termes successifs
    :pxs_returns: |
        Classe héritant de sympy.SeqFormula, offrant en plus la méthode
        pxsl_summation pour afficher la somme u_min + u_{min+1} + ... + u_{max-1}
        en LaTeX (valeurs numériques ou notation symbolique u_i).
    :pxs_example: |
        u = pxs_SeqFormula(n**2, (n, 0, oo))
        # Dans MyST : $S = \\py{u.pxsl_summation(0, 5)}$
    :pxs_antipattern: Utiliser sympy.SeqFormula puis écrire la somme à la main sans simplification des signes.
    """
    def pxsl_summation(self, min=0, max=9, symbolic=None):
        """
        Génère l'expression de la somme des coefficients u_min + u_{min+1} + ... + u_{max-1}.

        Paramètres:
        - min (int) : indice de départ de la sommation (inclu).
        - max (int) : indice de fin de la sommation (exclu).
        - symbolic (str ou None) : nom du symbole à utiliser pour la notation symbolique;
          si None, on utilise self.coeff(i) pour extraire les valeurs numériques.

        Retourne:
        - expr : un objet myst contenant la somme formatée.

        :pxs_trigger: somme développée suite, u_0 + u_1 + ... + u_n, écriture symbolique ou numérique d'une somme partielle
        :pxs_returns: |
            Objet myst (LaTeX) de la somme développée : soit les valeurs
            numériques des termes avec gestion correcte des signes (+/-),
            soit la notation symbolique "symbolic_0 + symbolic_1 + ...".
        :pxs_example: |
            u = pxs_SeqFormula(2*n + 1, (n, 0, oo))
            somme = u.pxsl_summation(0, 4)  # "1 +3 +5 +7"
            somme_sym = u.pxsl_summation(0, 4, symbolic="u")  # "u_0 + u_1 + u_2 + u_3"
            # Dans MyST : $\\py{somme}$
        :pxs_antipattern: Boucler manuellement en f-string sans gérer le signe (produit "1 + -3" au lieu de "1 - 3").
        """
        if symbolic is None:
            # Cas numérique : on ajoute la valeur de chaque coefficient
            expr = myst(r"""\py{self.coeff(min)} """, globals(), locals())
            for i in range(min + 1, max):
                coeff_i = self.coeff(i)  # on récupère le coefficient numérique
                if coeff_i >= 0:
                    # Ajoute '+ coeff_i' si coefficient positif
                    expr += myst(r""" +\py{coeff_i} """, globals(), locals())
                else:
                    # Ajoute '- |coeff_i|' si coefficient négatif
                    expr += myst(r""" -\py{abs(coeff_i)} """, globals(), locals())
            return expr  # retourne l'expression complète
        else:
            # Cas symbolique : on génère u_min = symbolic_0 puis + symbolic_i
            expr = myst(r"""\py{symbolic}_0 """, globals(), locals())
            for i in range(min + 1, max):
                # On concatène '+ symbolic_i' pour chaque terme suivant
                expr += myst(r"""+\py{symbolic}_\py{i} """, globals(), locals())
            return expr  # retourne la somme symbolique

class pxs_Set:
    """
    Wrapper pédagogique pour l'affichage LaTeX d'ensembles SymPy (Interval, Union,
    Intersection, Complement, Range, ensembles usuels N, N*, Z, R) avec notation
    française et délimiteurs \\llbracket \\rrbracket pour les intervalles entiers.

    :pxs_trigger: ensemble mathématique LaTeX, union intersection complément, N*, Reals, Integers, intervalle d'entiers ⟦a,b⟧, notation française ensembles
    :pxs_returns: |
        Wrapper autour d'un ensemble SymPy (Set) avec une méthode .print()
        produisant une chaîne LaTeX respectant les conventions pédagogiques
        françaises (N*, ]a;b[, ⟦a;b⟧, A ∪ B, A ∩ B, A \\ B).
    :pxs_example: |
        S = pxs_Set(Union(Interval(-oo, 0), Interval(1, 5, False, True)))
        # Dans MyST : $D = \\py{S.print()}$
    :pxs_antipattern: Utiliser directement latex(ensemble) qui donne la notation anglo-saxonne et ne gère pas N*, ⟦a,b⟧, ni les conventions françaises.
    """
    def __init__(self, st):
        """
        Initialise le wrapper autour d'un ensemble SymPy.

        :pxs_trigger: instanciation wrapper pxs_Set autour d'un Set sympy
        :pxs_returns: |
            Instance pxs_Set encapsulant l'ensemble SymPy fourni, prête à
            être affichée via .print().
        :pxs_example: |
            S = pxs_Set(Interval(0, 1))
            latex_str = S.print()
        :pxs_antipattern: Passer une expression qui n'est pas un Set SymPy — la méthode print() suppose la présence d'attributs args cohérents.
        """
        self.s = st

    def print(self):
        """
        Produit la représentation LaTeX de l'ensemble selon les conventions
        pédagogiques françaises PyxiScience.

        :pxs_trigger: afficher ensemble en LaTeX, notation française ensembles, union intersection, ⟦a,b⟧, N*, Reals, domaine de définition composé
        :pxs_returns: |
            Chaîne LaTeX (str) représentant l'ensemble : Reals pour ]-∞,+∞[,
            N, N*, Z pour les ensembles usuels, ⟦a,b⟧ pour les intervalles
            entiers (Range), et A ∪ B / A ∩ B / A \\ B avec parenthésage
            automatique des sous-ensembles composés.
        :pxs_example: |
            D = pxs_Set(Complement(Reals, FiniteSet(0))).print()
            # Dans MyST : $D_f = \\py{D}$
        :pxs_antipattern: Composer manuellement la représentation d'une union/intersection sans gérer le parenthésage des sous-ensembles composés (A ∪ (B ∩ C)).
        """

        def __pxs_parentheses(st):
            #Déterminer si st est composé de plusieurs ensembles
            pxs_st = pxs_Set(st)
            compose = st.args # tuple des composantes de st, et False si aucune
            for x in st.args:
                if not isinstance(x, Set):
                    compose = False

            if compose:
                return fr"\big({pxs_st.print()}\big)"
            return pxs_st.print()

        if isinstance(self.s, Interval) and self.s.left == -oo and self.s.right == oo:
            return latex(Reals)
        elif isinstance(self.s, Interval):
            pxs_st = pxs_Interval.from_Interval(self.s)
            return pxs_st.print()
        if isinstance(self.s, Complement):
            return r" \setminus ".join(map(__pxs_parentheses, self.s.args))
        if isinstance(self.s, (Union, Intersection)):
            op = r" \cap " if isinstance(self.s, Intersection) else r" \cup "
            return fr"{op}".join(map(__pxs_parentheses, self.s.args))
        if isinstance(self.s, Range) and self.s.args[2] == 1:
            if self.s.args[0] == -oo and self.s.args[1] == oo:
                return latex(Integers)
            elif self.s.args[0] == 0 and self.s.args[1] == oo:
                return latex(Naturals)
            elif self.s.args[0] == 1 and self.s.args[1] == oo:
                return r"\N^*"
            else:
                return pxs_Interval(self.s.args[0], self.s.args[1] - 1).print().replace(r"\left[", r"\llbracket").replace(r"\left]", r"\rrbracket").replace(r"\right[", r"\llbracket").replace(r"\right]", r"\rrbracket")
        if self.s == Naturals:
            return r"\N^*"
        if self.s == Naturals0:
            return latex(Naturals)
        else:
            return latex(self.s)
            
            
 # =========================================================================
 # CLASSE pxs_Plotable POUR LA REPRÉSENTATION GRAPHIQUE D'EXPRESSIONS SYMPY
 # =========================================================================

""" PISTES D'AMÉLIORATION :
- Gestion des singularités : retirer les singularités de la liste des abscisses, voire éventuellement plafonner les valeurs extrêmes de la fonction. P. ex :
if max(ordo) > seuil:  # (seuil = 100 par défaut ?)
    # ...limiter l'axe des ordonnées à +seuil
if min(ordo) < - seuil:
    # ... limiter l'axe des ordonnées à - seuil.

- vérifier mais je crois que plot_vars n'est pas utile (sauf peut-être pour les vérifs)
dans plot_surface_partial et contour_partial. Peut sans doute être enlevée des variables de sortie de la fonction auxiliaire associée.

- ajouter une colorbar (peut-être en option) sur les contour.
"""

import matplotlib.pyplot as plt
import sympy as sp
import numpy as np


# # finalement inutile si l'on est obligés d'utiliser numpy pour les tracés 3d...
# def pxs_meshgrid(x, y):
#     """Pour remplacer le meshgrid de Numpy"""
#     n, p = len(x), len(y)
#     X = [x for _ in range(p)]
#     Y = [[yi] * n for yi in y]
#     return X, Y


class pxs_Plotable:
    """
    Cette classe permet de représenter graphiquement des fonctions ou suites mathématiques d'une ou plusieurs variables définies par des expressions SymPy (fraphes 2D, 3D, fonctions partielles, suites).
    
    Voir la documentation de chaque fonction, et la fonction tests_visuels_pxs_Plotable() du fichier de test correspondant
    pour un aperçu graphique général.

    :pxs_trigger: représentation graphique expression SymPy, tracé fonction matplotlib pédagogique, courbe surface contour nuage suite
    :pxs_returns: |
        Classe wrappant une expression SymPy et offrant les méthodes plot,
        plot_partial, plot_surface, plot_surface_partial, contour,
        contour_partial, plot_corde, scatter pour tous les besoins graphiques
        pédagogiques (2D, 3D, suites, fonctions partielles).
    :pxs_example: |
        pex = pxs_Plotable("cos(x)")
        pex.plot(interv=pxs_Interval(0, 2*pi))
        # La figure matplotlib courante est modifiée par effet de bord.
    :pxs_antipattern: Combiner sympy.lambdify + np.linspace + plt.plot à la main, avec titre LaTeX et gestion des bornes infinies réécrits à chaque exercice.
    """

    def __init__(self, expr):
        """
        Initialise un objet pxs_Plotable pour le tracé de fonctions SymPy.

        Cette classe permet de représenter graphiquement des fonctions ou suites mathématiques d'une ou plusieurs variables définies par des expressions SymPy (fraphes 2D, 3D, fonctions partielles, suites).

        Paramètres
        ----------
        expr : str, sympy.Expr
            L'expression mathématique à tracer. Peut être une chaîne de caractères
            (qui sera convertie automatiquement) ou une expression SymPy.

        Exemples
        --------
        >>> from sympy.abc import x, y
        >>> pex1 = pxs_Plotable("cos(x)")
        >>> pex2 = pxs_Plotable(x**2 + y**2)
        >>> pex3 = pxs_Plotable(5)  # fonction constante

        :pxs_trigger: créer objet traçable depuis expression sympy ou chaîne, conversion automatique sympify
        :pxs_returns: |
            Instance pxs_Plotable avec attributs .expr (expression SymPy) et
            .vars (set des variables libres), prête pour l'appel à plot,
            plot_surface, contour, scatter, etc.
        :pxs_example: |
            pex = pxs_Plotable("x**2 + y**2")
            pex.plot_surface()
        :pxs_antipattern: Stocker l'expression sous forme de chaîne et la reconvertir à chaque tracé.
        """

        expr = sp.sympify(expr) # si p. ex expr est une chaîne en entrée
        self.expr = expr
        self.vars = expr.free_symbols

    def plot(self, interv = pxs_Interval(-5, 5), pas = None, ymin = None, ymax = None, title = True, fast = False, **kwargs):

        """
        Trace la courbe représentative d'une fonction d'une variable.

        Cette méthode trace le graphe d'une fonction à une variable ou d'une constante.
        Elle gère automatiquement les bornes infinies et les intervalles ouverts.

        Paramètres
        ----------
        interv : pxs_Interval, optionnel
            L'intervalle de tracé. Par défaut [-5, 5].
        pas : float, optionnel
            Le pas d'échantillonnage. Par défaut (b-a)/1000.
        title : bool, optionnel
            Afficher ou non le titre avec l'expression LaTeX. Par défaut True.
        fast : bool, optionnel
            Mode de tracé rapide utilisant plt directement. Par défaut False.
        **kwargs
            Arguments supplémentaires passés à matplotlib.pyplot.plot.

        Lève
        ----
        ValueError
            Si l'expression contient plus d'une variable libre.

        Exemples
        --------
        >>> from sympy.abc import x
        >>> pex = pxs_Plotable("cos(x)")
        >>> pex.plot()  # Trace cos(x) sur [-5, 5]
        >>> pex.plot(interv=pxs_Interval(0, 2*pi), color="red")
        >>>
        >>> # Intervalle ouvert
        >>> pex_log = pxs_Plotable("log(x)")
        >>> pex_log.plot(interv=pxs_Interval.open(0, 5))

        :pxs_trigger: tracer courbe fonction une variable, graphe f(x) sur intervalle, représentation graphique exercice
        :pxs_returns: |
            None (effet de bord). Dessine la courbe sur l'axe matplotlib
            courant (plt.gca() ou plt.plot si fast=True), avec titre LaTeX
            automatique "Courbe représentative de la fonction x ↦ f(x)".
        :pxs_example: |
            pex = pxs_Plotable("x**2 - 1")
            pex.plot(interv=pxs_Interval(-3, 3), color="blue")
            # Sauvegarde via plt.savefig(...)
        :pxs_antipattern: Utiliser np.linspace + sp.lambdify + plt.plot et composer manuellement le titre LaTeX à chaque exercice.
        """

        a, b = interv.left, interv.right

        # /!\ GADGET DE CLAUDE : Gestion des bornes infinies, est-il bien utile de le garder ?
        if a == -sp.oo:
            a = -100  # Grande valeur négative par défaut
        elif a == sp.oo:
            a = 100   # Grande valeur positive par défaut

        if b == sp.oo:
            b = 100   # Grande valeur positive par défaut
        elif b == -sp.oo:
            b = -100  # Grande valeur négative par défaut


        # pas par défaut : 1000 subdivisions
        if pas is None:
            pas = (b - a) / 1000

        nb_vars = len(self.vars)
        # Fonction constante
        if nb_vars == 0:
            x = sp.Symbol("x")
            var = x # pour le titre
            absc = [a, b]
            c = self.expr.evalf()
            ordo = [c, c]
        # Fonction d'exactement deux variables
        elif nb_vars == 1:
            var = list(self.vars)[0]
            fonction = sp.lambdify(var, self.expr, "math")
            absc = [a + k * pas for k in range(int( (b-a) / pas) + 1)]

            # Cas d'un intervalle ouvert : retrait des bornes
            if interv.left_open:
                absc.pop(0)
            if interv.right_open:
                absc.pop()

            ordo = [fonction(xk) for xk in absc]

        # Cas d'une fonction de plus de deux variables : erreur
        elif nb_vars == 2:
            raise ValueError("Trop de variables dans l'expression. Utiliser plot_partial ou plot_surface")
        else:
            raise ValueError("Trop de variables dans l'expression. Utiliser plot_partial ou plot_surface_partial")

        if fast: # Pour une seule figure, sans avoir à définir des subplots et des axes
            # plt.clf()
            plt.plot(absc, ordo, **kwargs)
            if title:
                plt.title(fr"Courbe représentative de la fonction ${var} \mapsto {sp.latex(self.expr)}$ sur l'intervalle ${sp.latex(interv)}$")
            # plt.show()
        else:
            ax = plt.gca()
            ax.plot(absc, ordo, **kwargs)
            if title:
                ax.set_title(fr"Courbe représentative de la fonction ${var} \mapsto {sp.latex(self.expr)}$ sur l'intervalle ${sp.latex(interv)}$")

            # Si l'utilisateur spécifie des valeurs limites en ordonnées
            if ymin is not None:
                ax.set_ylim(bottom = ymin)
            if ymax is not None:
                ax.set_ylim(top = ymax)

    def plot_partial(self, plot_var = None, fixes = None, **kwargs):

        """
        Trace la courbe d'une fonction partielle en fixant certaines variables.

        Cette méthode permet de tracer une fonction de plusieurs variables en fixant
        toutes les variables sauf une. La figure obtenue est une courbe dans le plan.

        Paramètres
        ----------
        plot_var : sympy.Symbol, optionnel
            La variable selon laquelle tracer. Par défaut, la première variable
            de l'expression.
        fixes : dict, optionnel
            Dictionnaire {variable: valeur} fixant les autres variables.
            Par défaut, toutes les autres variables sont fixées à 0.
        **kwargs
            Arguments supplémentaires passés à la méthode plot().

        Lève
        ----
        ValueError
            Si l'expression est constante, si plot_var n'appartient pas aux variables
            de l'expression, si certaines variables ne sont pas fixées, ou si une
            valeur fixée correspond à une singularité.

        Exemples
        --------
        >>> from sympy.abc import x, y, t
        >>> pex = pxs_Plotable(2*x**2 + 3*y/t)
        >>> # Trace selon x avec y=1, t=1
        >>> pex.plot_partial(x, {y: 1, t: 1})
        >>> # Trace selon t avec x=1, y=1, évite t=0 (singularité)
        >>> pex.plot_partial(t, {x: 1, y: 1}, interv=pxs_Interval.open(0, 5))

        :pxs_trigger: fonction partielle, fixer variables, tracer f(x,y,t) selon x avec y et t fixés, coupe 1D d'une fonction multivariable
        :pxs_returns: |
            None (effet de bord matplotlib). Substitue les variables de fixes
            par leurs valeurs, puis trace la courbe de la fonction partielle
            résultante selon plot_var via pxs_Plotable.plot.
        :pxs_example: |
            pex = pxs_Plotable(2*x**2 + 3*y/t)
            pex.plot_partial(x, {y: 1, t: 1})
            # Trace x ↦ 2x² + 3
        :pxs_antipattern: Faire self.expr.subs({y:1, t:1}) à la main puis reconstruire un pxs_Plotable et appeler plot sans vérifier les singularités ni l'appartenance des variables.
        """

        if fixes is None:
            const_vars = self.vars.copy()
            # Vérification avant suppression
            try:
                const_vars.remove(plot_var)
            except:
                raise ValueError(f"La variable {plot_var} ne fait pas partie des variables de l'expression")
            fixes = {v : 0 for v in const_vars} # par défaut toutes les var fixées valent 0

        if len(self.vars) == 0:
            raise ValueError("L'expression est constante")
        elif plot_var is not None and plot_var not in self.vars:
            raise ValueError(f"La variable {plot_var} ne fait pas partie des variables de l'expression")

        if not self.vars.issubset( set(fixes.keys()).union({plot_var}) ):
            raise ValueError("Certaines variables de l'expression n'ont pas été fixées")

        for k, v in fixes.items():
            if v in sp.singularities(self.expr, k):
                raise ValueError(f"La valeur {v} est une singularité de l'expression par rapport à la variable {k}")


        # Définition des valeurs par défaut de plot_var et fixes (impossible d'appeler self
        # dans les arguments par défaut)
        if plot_var is None:
            plot_var = list(self.vars)[0]

        if fixes is None:
            const_vars = self.vars.copy()
            # Vérification avant suppression
            try:
                const_vars.remove(plot_var)
            except:
                raise ValueError(f"La variable {plot_var} ne fait pas partie des variables de l'expression")
            fixes = {v : 0 for v in const_vars} # par défaut toutes les var fixées valent 0

        fonction_partielle = pxs_Plotable(self.expr.subs(fixes))
        fonction_partielle.plot(**kwargs)

    def __aux_2var(self, interv1, interv2, nb_points):
        """
        Fonction auxiliaire privée utilisée dans les fonctions plot_surface et contour pour discrétiser une fonction de deux variables.

        :pxs_trigger: interne — discrétisation fonction 2 variables pour plot_surface et contour
        :pxs_returns: |
            Tuple (X, Y, Z) de np.ndarray : grille meshgrid des abscisses et
            ordonnées, plus l'évaluation vectorisée de l'expression sur cette grille.
        :pxs_example: |
            # Appelé uniquement en interne par plot_surface et contour
            # X, Y, Z = self.__aux_2var(interv1, interv2, 30)
        :pxs_antipattern: Appeler cette méthode privée directement depuis un exercice au lieu d'utiliser plot_surface ou contour.
        """

        if len(self.vars) != 2:
            raise ValueError("La fonction à tracer doit être une fonction d'exactement deux variables")
        # Convertir les bornes en float "normaux"
        a1, b1 = float(interv1.left), float(interv1.right)
        a2, b2 = float(interv2.left), float(interv2.right)

        x = np.linspace(a1, b1, nb_points)
        y = np.linspace(a2, b2, nb_points)
        # Cas d'un intervalle ouvert
        if interv1.left_open:
            x.pop(0)
        if interv1.right_open:
            x.pop()
        if interv2.left_open:
            y.pop(0)
        if interv2.right_open:
            y.pop()

        X, Y = np.meshgrid(x, y)
        liste_vars = list(self.vars)
        f = sp.lambdify(liste_vars, self.expr, "numpy")
        Z = f(X, Y)

        return X, Y, Z

    def __aux_verif_partial_2var(self, plot_vars, fixes):
        """
        Vérifications à effectuer avant l'utilisation des méthodes de tracé de fonctions partielles à plus de deux variables.

        :pxs_trigger: interne — validation arguments plot_surface_partial et contour_partial
        :pxs_returns: |
            Le dictionnaire fixes complété avec les valeurs par défaut (0)
            pour toutes les variables non explicitement fixées et non présentes
            dans plot_vars. Lève ValueError en cas d'incohérence.
        :pxs_example: |
            # Appelé uniquement en interne par plot_surface_partial et contour_partial
            # fixes = self.__aux_verif_partial_2var([x, y], {z: 1})
        :pxs_antipattern: Dupliquer cette logique de validation dans plot_surface_partial et contour_partial au lieu de centraliser.
        """

        if plot_vars is None:
            lis_vars = list(self.vars)
            plot_vars = lis_vars[:2]

        if len(plot_vars) != 2:
            raise ValueError("plot_vars doit contenir exactement 2 variables")

        if fixes is None:
            const_vars = self.vars.copy()
            # Vérifications avant suppression
            for var in plot_vars:
                try:
                    const_vars.remove(var)
                except:
                    raise ValueError(f"La variable {var} ne fait pas partie des variables de l'expression")

            fixes = {v : 0 for v in const_vars} # par défaut toutes les var fixées valent 0

        for var in plot_vars:
            if var not in self.vars:
                raise ValueError(f"La variable {var} ne fait pas partie des variables de l'expression")

        if fixes is not None:
            for k, v in fixes.items():
                if v in sp.singularities(self.expr, k):
                    raise ValueError(f"La valeur {v} est une singularité de l'expression par rapport à la variable {k}")

        if not self.vars.issubset( set(fixes.keys()).union(set(plot_vars)) ):
            raise ValueError("Certaines variables de l'expression n'ont pas été fixées")

        return fixes


    def plot_surface(self, interv1 = pxs_Interval(-5, 5), interv2 = pxs_Interval(-5, 5), nb_points = 30, cmap = "viridis", title = True, **kwargs):
        """
        Trace la surface représentative d'une fonction de deux variables.

        Cette méthode génère un tracé 3D de la surface définie par une fonction
        à exactement deux variables.

        Paramètres
        ----------
        interv1 : pxs_Interval, optionnel
            Intervalle pour la première variable. Par défaut [-5, 5].
        interv2 : pxs_Interval, optionnel
            Intervalle pour la deuxième variable. Par défaut [-5, 5].
        nb_points : int, optionnel
            Nombre de points par axe pour la grille. Par défaut 30.
        cmap : str, optionnel
            Colormap matplotlib pour la surface. Par défaut "viridis".
        title : bool, optionnel
            Afficher ou non le titre avec l'expression LaTeX. Par défaut True.
        **kwargs
            Arguments supplémentaires passés à matplotlib.Axes3D.plot_surface.

        Lève
        ----
        ValueError
            Si l'expression ne contient pas exactement deux variables libres.

        Exemples
        --------
        >>> from sympy.abc import x, y
        >>> surf1 = pxs_Plotable(x**2 + y**2)  # Paraboloïde
        >>> fig, ax = plt.subplots(subplot_kw={"projection": "3d"})
        >>> surf1.plot_surface(cmap="plasma")
        >>>
        >>> surf2 = pxs_Plotable("sin(x)*cos(y)")  # Surface trigonométrique
        >>> surf2.plot_surface(nb_points=50, cmap="coolwarm")

        :pxs_trigger: surface 3D fonction deux variables, paraboloïde selle de cheval, tracé tridimensionnel matplotlib, z=f(x,y)
        :pxs_returns: |
            None (effet de bord). Dessine la surface 3D sur l'axe 3D courant
            (nécessite subplot_kw={"projection": "3d"}), avec titre LaTeX
            automatique et colormap configurable.
        :pxs_example: |
            surf = pxs_Plotable(x**2 + y**2)
            fig, ax = plt.subplots(subplot_kw={"projection": "3d"})
            surf.plot_surface(cmap="plasma")
        :pxs_antipattern: Construire meshgrid + lambdify + Axes3D.plot_surface à la main pour chaque exercice, sans titre LaTeX normalisé.
        """

        # l'utilisation de numpy semble obligatoire ici :
        # (et si on s'en sert autant le faire partout où ça simplifie les choses non ?)

        # --- ci-dessous : tentative infructueuse de ne pas utiliser numpy... ---

        # a1, b1 = interv1.left.evalf(), interv1.right.evalf() # evalf() pour convetir en float "normaux"
        # h1 = (b1 - a1) / (nb_points - 1)
        # a2, b2 = interv2.left.evalf(), interv2.right.evalf() # idem
        # h2 = (b2 - a2) / (nb_points - 1)
        # x = [a1 + k * h1 for k in range(nb_points)]
        # y = [a2 + k * h2 for k in range(nb_points)]
        # X, Y = pxs_meshgrid(x, y)
        # liste_vars = list(self.vars)
        # f = sp.lambdify(liste_vars, self.expr, "math")
        # Z = [[f(xi, yj).evalf() for xi in x] for yj in y]

        X, Y, Z = self.__aux_2var(interv1, interv2, nb_points)
        liste_vars = list(self.vars)
        ax = plt.gca()
        ax.plot_surface(X, Y, Z, cmap = cmap, **kwargs)

        if title:
            var1, var2 = liste_vars[0], liste_vars[1]
            ax.set_title(fr"Surface représentative de la fonction $({var1}, {var2}) \mapsto {sp.latex(self.expr)}$")



    def plot_surface_partial(self, plot_vars = None, fixes = None, **kwargs):
        """
        Trace la surface d'une fonction partielle en fixant certaines variables.

        Cette méthode permet de tracer une fonction de plus de deux variables en fixant
        toutes les variables sauf deux, générant ainsi une surface 3D. Elle effectue
        automatiquement les vérifications de cohérence.

        Paramètres
        ----------
        plot_vars : list of sympy.Symbol, optionnel
            Liste de deux variables pour les axes de la surface. Par défaut,
            les deux premières variables de l'expression.
        fixes : dict, optionnel
            Dictionnaire {variable: valeur} fixant les autres variables.
            Par défaut, toutes les autres variables sont fixées à 0.
        **kwargs
            Arguments supplémentaires passés à la méthode plot_surface().

        Lève
        ----
        ValueError
            Si plot_vars ne contient pas exactement 2 variables, si les variables
            de plot_vars n'appartiennent pas à l'expression, si certaines variables
            ne sont pas fixées, ou si une valeur fixée correspond à une singularité.

        Exemples
        --------
        >>> from sympy.abc import x, y, z, t
        >>> pex = pxs_Plotable(x**2 + y**2 + z + t)
        >>> fig, ax = plt.subplots(subplot_kw={"projection": "3d"})
        >>> # Surface x-y avec z=1, t=0
        >>> pex.plot_surface_partial([x, y], {z: 1, t: 0})
        >>> # Surface x-z avec y=0, t=1
        >>> pex.plot_surface_partial([x, z], {y: 0, t: 1}, cmap="plasma")

        :pxs_trigger: surface 3D fonction partielle plus de 2 variables, coupe 2D en 3D, fixer certaines variables pour tracer surface, section surface
        :pxs_returns: |
            None (effet de bord). Fixe les variables de fixes, puis trace la
            surface 3D de la fonction partielle sur les deux variables restantes
            (plot_vars) via pxs_Plotable.plot_surface.
        :pxs_example: |
            pex = pxs_Plotable(x**2 + y**2 + z + t)
            fig, ax = plt.subplots(subplot_kw={"projection": "3d"})
            pex.plot_surface_partial([x, y], {z: 1, t: 0})
        :pxs_antipattern: Faire self.expr.subs puis reconstruire un pxs_Plotable et appeler plot_surface sans valider que plot_vars contient exactement 2 variables ni repérer les singularités.
        """

        fixes = self.__aux_verif_partial_2var(plot_vars, fixes)

        fonction_partielle = pxs_Plotable(self.expr.subs(fixes))
        fonction_partielle.plot_surface(**kwargs)

    def contour(self, interv1 = pxs_Interval(-5, 5), interv2 = pxs_Interval(-5, 5), nb_points = 30, levels = 10, title = True, **kwargs):
        """
        Trace les lignes de niveau d'une fonction de deux variables.

        Cette méthode génère un tracé 2D des courbes de niveau d'une fonction
        à exactement deux variables.

        Paramètres
        ----------
        interv1 : pxs_Interval, optionnel
            Intervalle pour la première variable. Par défaut [-5, 5].
        interv2 : pxs_Interval, optionnel
            Intervalle pour la deuxième variable. Par défaut [-5, 5].
        nb_points : int, optionnel
            Nombre de points par axe pour la grille. Par défaut 30.
        levels : int ou array-like, optionnel
            Nombre de niveaux ou valeurs spécifiques pour les lignes de niveau.
            Par défaut 10.
        cmap : str, optionnel
            Colormap matplotlib pour les lignes de niveau. Par défaut "viridis".
        title : bool, optionnel
            Afficher ou non le titre avec l'expression LaTeX. Par défaut True.
        **kwargs
            Arguments supplémentaires passés à matplotlib.pyplot.contour ou contourf.

        Lève
        ----
        ValueError
            Si l'expression ne contient pas exactement deux variables libres.

        Exemples
        --------
        >>> from sympy.abc import x, y
        >>> import matplotlib.pyplot as plt
        >>>
        >>> # Lignes de niveau d'un paraboloïde
        >>> parab = pxs_Plotable(x**2 + y**2)
        >>> parab.contour(levels=15)
        >>> plt.show()
        >>>
        >>> # Lignes de niveau avec couleurs personnalisées
        >>> gaussian = pxs_Plotable(sp.exp(-(x**2 + y**2)/2))
        >>> gaussian.contour(cmap="hot", levels=20)
        >>>
        >>> # Niveaux spécifiques pour une fonction trigonométrique
        >>> trig = pxs_Plotable(sp.sin(x)*sp.cos(y))
        >>> levels_custom = [-0.8, -0.4, 0, 0.4, 0.8]
        >>> trig.contour(levels=levels_custom, colors="black", linewidths=2)
        >>> plt.clabel(cs, inline=True, fontsize=10)  # Ajouter des labels
        >>>
        >>> # Selle de cheval avec intervalle personnalisé
        >>> selle = pxs_Plotable(x**2 - y**2)
        >>> selle.contour(interv1=pxs_Interval(-3, 3),
        ...                    interv2=pxs_Interval(-3, 3),
        ...                    levels=25, cmap="RdBu_r")

        :pxs_trigger: lignes de niveau, courbes de niveau, isolignes, carte topographique, contour 2D fonction deux variables, f(x,y)=c
        :pxs_returns: |
            None (effet de bord). Dessine les courbes de niveau sur l'axe
            matplotlib courant, avec titre LaTeX, labels des axes, et ratio
            d'aspect "equal" pour une représentation fidèle.
        :pxs_example: |
            parab = pxs_Plotable(x**2 + y**2)
            parab.contour(levels=15)
            plt.show()
        :pxs_antipattern: Construire meshgrid + lambdify + plt.contour à la main sans normaliser le titre ni verrouiller l'aspect ratio.
        """

        X, Y, Z = self.__aux_2var(interv1, interv2, nb_points)
        liste_vars = list(self.vars)
        # Tracé des lignes de niveau
        ax = plt.gca()
        cs = ax.contour(X, Y, Z, levels=levels, **kwargs)

        # Ajout du titre
        if title:
            var1, var2 = liste_vars[0], liste_vars[1]
            ax.set_title(fr"Lignes de niveau de $({var1}, {var2}) \mapsto {sp.latex(self.expr)}$")


        # Labels des axes
        ax.set_xlabel(f"${liste_vars[0]}$")
        ax.set_ylabel(f"${liste_vars[1]}$")

        # Assurer un ratio d'aspect égal pour une représentation fidèle
        ax.set_aspect('equal', adjustable='box')


    def contour_partial(self, plot_vars = None, fixes = None, **kwargs):
        """
        Trace les lignes de niveau d'une fonction partielle en fixant certaines variables.

        Cette méthode permet de tracer les lignes de niveau d'une fonction de plus de deux
        variables en fixant toutes les variables sauf deux, générant ainsi un tracé 2D de
        lignes de niveau. Elle effectue automatiquement les vérifications de cohérence.

        Paramètres
        ----------
        plot_vars : lise de sympy.Symbol, optionnel
            Liste de deux variables pour les axes du tracé de contour. Par défaut,
            les deux premières variables de l'expression.
        fixes : dict, optionnel
            Dictionnaire {variable: valeur} fixant les autres variables.
            Par défaut, toutes les autres variables sont fixées à 0.
        **kwargs
            Arguments supplémentaires passés à la méthode contour().

        Retourne
        --------
        matplotlib.contour.QuadContourSet
            L'objet contour retourné par matplotlib, utile pour ajouter des labels
            ou personnaliser l'affichage.

        Lève
        ----
        ValueError
            Si plot_vars ne contient pas exactement 2 variables, si les variables
            de plot_vars n'appartiennent pas à l'expression, si certaines variables
            ne sont pas fixées, ou si une valeur fixée correspond à une singularité.

        Exemples
        --------
        >>> from sympy.abc import x, y, z, t
        >>> import matplotlib.pyplot as plt
        >>>
        >>> # Fonction de 4 variables
        >>> pex = pxs_Plotable(x**2 + y**2 + z*t)
        >>>
        >>> # Lignes de niveau dans le plan x-y avec z=1, t=2
        >>> pex.contour_partial([x, y], {z: 1, t: 2}, levels=15)
        >>>
        >>> # Lignes de niveau dans le plan x-z avec y=0, t=1
        >>> pex.contour_partial([x, z], {y: 0, t: 1}, cmap="plasma")
        >>>
        >>> # Niveaux personnalisés pour une fonction trigonométrique
        >>> trig_3d = pxs_Plotable(sp.sin(x)*sp.cos(y) + z)
        >>> levels_custom = [0, 0.5, 1.0, 1.5, 2.0]
        >>> trig_3d.contour_partial([x, y], {z: 1}, levels=levels_custom,
        ...                              colors="black", linewidths=2)

        :pxs_trigger: lignes de niveau fonction partielle plus de 2 variables, contour 2D avec variables fixées, section isolignes
        :pxs_returns: |
            None (effet de bord). Fixe les variables de fixes, puis trace les
            courbes de niveau de la fonction partielle sur les deux variables
            restantes (plot_vars) via pxs_Plotable.contour.
        :pxs_example: |
            pex = pxs_Plotable(x**2 + y**2 + z*t)
            pex.contour_partial([x, y], {z: 1, t: 2}, levels=15)
        :pxs_antipattern: Faire expr.subs puis contour à la main sans vérifier la cohérence de plot_vars ni détecter les singularités.
        """

        fixes = self.__aux_verif_partial_2var(plot_vars, fixes)

        fonction_partielle = pxs_Plotable(self.expr.subs(fixes))
        fonction_partielle.contour(**kwargs)



    def plot_corde(self, absc_corde, fast = False, color = "black", linestyle = "dashed", marker = ".", **kwargs):
        """
        Trace la corde reliant deux points d'une courbe.

        Cette méthode trace un segment de droite reliant deux points de la courbe
        représentative de la fonction.

        Paramètres
        ----------
        absc_corde : tuple ou list
            Tuple ou liste de deux abscisses (a, b) définissant les extrémités
            de la corde.
        fast : bool, optionnel
            Mode de tracé rapide utilisant plt directement. Par défaut False.
        color : str, optionnel
            Couleur de la corde. Par défaut "black".
        linestyle : str, optionnel
            Style de ligne. Par défaut "dashed".
        marker : str, optionnel
            Marqueur aux extrémités. Par défaut ".".
        **kwargs
            Arguments supplémentaires passés à matplotlib.pyplot.plot.

        Lève
        ----
        ValueError
            Si l'expression ne contient pas exactement une variable libre.

        Exemples
        --------
        >>> from sympy.abc import x
        >>> pex = pxs_Plotable("x**3 - 2*x")
        >>> pex.plot(color="blue")
        >>> # Corde entre x=-1 et x=2
        >>> pex.plot_corde((-1, 2), color="red", linewidth=2)
        >>> # Plusieurs cordes
        >>> pex.plot_corde((0, 1), color="green", marker="o")

        :pxs_trigger: corde courbe, taux d'accroissement visuel, sécante, segment reliant (a,f(a)) et (b,f(b)), illustration dérivée
        :pxs_returns: |
            None (effet de bord). Trace un segment en pointillés noirs reliant
            les points (a, f(a)) et (b, f(b)) sur l'axe matplotlib courant.
            Typiquement superposé à un appel pxs_Plotable.plot préalable.
        :pxs_example: |
            pex = pxs_Plotable("x**3 - 2*x")
            pex.plot(color="blue")
            pex.plot_corde((-1, 2), color="red", linewidth=2)
        :pxs_antipattern: Calculer f(a) et f(b) via sympy.subs puis plt.plot([a,b],[fa,fb]) à la main à chaque exercice.
        """

        # Vérification du nombre de variables
        if len(self.vars) != 1:
            raise ValueError("La fonction plot_corde ne peut être utilisée que pour des fonctions d'une seule variable")

        # ci-dessous on suppose que c'est OK
        a, b = absc_corde
        var = list(self.vars)[0]
        fa, fb = self.expr.subs(var, a), self.expr.subs(var, b)
        if fast:
            plt.plot([a, b], [fa, fb], color = color, linestyle = linestyle,  marker = marker, **kwargs)
        else:
            ax = plt.gca()
            ax.plot([a, b], [fa, fb], color = color, linestyle = linestyle, marker = marker, **kwargs)

    def scatter(self, n_terms=20, start_index=0, fast=False, **kwargs):
        """
        Trace les termes d'une suite numérique sous forme de nuage de points.

        Cette méthode évalue l'expression pour des valeurs entières consécutives
        de la variable et affiche les résultats sous forme de nuage de points.

        Paramètres
        ----------
        n_terms : int, optionnel
            Nombre de termes de la suite à tracer. Doit être un entier positif.
            Par défaut 20.
        start_index : int, optionnel
            Indice de départ de la suite. Peut être négatif, nul ou positif
            selon la définition de la suite. Par défaut 0.
        fast : bool, optionnel
            Mode de tracé rapide utilisant plt directement sans axes personnalisés.
            Si False, ajoute automatiquement les labels et le titre. Par défaut False.
        **kwargs
            Arguments supplémentaires passés à matplotlib.pyplot.scatter.
            Exemples : color, s (taille), alpha, marker, etc.

        Lève
        ----
        ValueError
            Si l'expression ne contient pas exactement une variable libre.
            Message : "La fonction scatter ne peut être utilisée que
            pour des suites (fonction d'une seule variable)".

        Exemples
        --------
        >>> from sympy.abc import n
        >>> import matplotlib.pyplot as plt
        >>>
        >>> # Suite arithmétique : u_n = 2n + 1
        >>> suite1 = pxs_Plotable(2*n + 1)
        >>> suite1.scatter(n_terms=15, color="blue", s=50)
        >>> plt.show()
        >>>
        >>> # Suite géométrique : u_n = (1/2)^n
        >>> suite2 = pxs_Plotable("(1/2)**n")
        >>> suite2.scatter(n_terms=20, start_index=1, color="red", s=40)
        >>>
        >>> # Suite alternée : u_n = (-1)^n / n
        >>> suite4 = pxs_Plotable((-1)**n / n)
        >>> suite4.scatter(n_terms=20, start_index=1, color="purple", alpha=0.7)
        >>>
        >>> # Mode fast pour tracé rapide sans labels
        >>> suite1.scatter(fast=True, n_terms=10, color="cyan", s=80)

        :pxs_trigger: suite numérique, nuage de points, termes u_n graphique, représentation points isolés indice/valeur, suite arithmétique géométrique alternée
        :pxs_returns: |
            None (effet de bord). Évalue l'expression pour les indices entiers
            de start_index à start_index+n_terms-1, puis trace un scatter avec
            labels et titre LaTeX de la forme "(u_n)_{n ≥ start_index}".
        :pxs_example: |
            suite = pxs_Plotable(2*n + 1)
            suite.scatter(n_terms=15, color="blue", s=50)
        :pxs_antipattern: Faire une boucle for + sympy.subs + plt.scatter à la main sans labels normalisés ni titre LaTeX pédagogique.
        """
        if len(self.vars) != 1:
            raise ValueError("La fonction plot_scatter_sequence ne peut être utilisée que pour des suites (fonction d'une seule variable)")

        var = list(self.vars)[0]
        indices = list(range(start_index, start_index + n_terms))
        values = [float(self.expr.subs(var, n)) for n in indices]

        if fast:
            plt.scatter(indices, values, **kwargs)
        else:
            ax = plt.gca()
            ax.scatter(indices, values, **kwargs)
            ax.set_xlabel(f"${var}$ (indice)")
            ax.set_ylabel(f"${sp.latex(self.expr)}$")
            ax.set_title(fr"Termes de la suite de $\left({sp.latex(self.expr)}\right)_{{ {var} \geq {start_index} }}$")