Tracer des points particuliers sur une courbe en python

Bonjour,

Version courte

Si l'on note P(x) ton polynôme, tu dois résoudre P(x) = 0 comme on a dû t'expliquer en cours de première. En admettant que ce polynôme ait deux racines réelles (éventuellement, une racine double), il suffit alors de tracer les deux points en question avec plt.scatter.

Version détaillée

Dans ce qui suit :

• je passe rapidement sur le calcul des points du polynôme (fonction polynom) il y a d'autres manière de l'écrire, mais celle-ci se repose essentiellement sur numpy ce la rend performante. Pour les curieux :
  • coeffs est converti sous forme d'une matrice 1 x n où n est le degré du polynôme
  • à partir de xs (un vecteur de 1000 valeurs de x dispersées linéairement entre -10 et 10) on construit une matrice values de taille n x 1000 où la case (i, j) contient la valeur xs[j]^i (dont la j-ème valeur de xs à la puissance i)
  • puis on calcule le produit scalaire (pas matriciel) de coeffs et de values pour obtenir un vecteur de 1000 ordonnées que l'on retourne et qui permet d'initialiser ys.
• comme son nom l'indique, solve_polynome calcule les racines du polynomes
• ta question porte sur le contenu de plot_polynom et plus précisément l'appel à plt.scatter. Note que le code est prévu pour fonctionner quel que soit le nombre de racines réelles du polynome.
• la fin du programme orchestre ses fonctions pour tracer y = x^2 - 4 (qui admet deux racines réelles : -2 et 2).
• Enfin, plot_polynoms (ou si on ne veut tracer qu'un polynôme, plot_polynom) est appelé dans le contexte défini par PlotContext. C'est une manière dire qu'il y a des choses à faire au début du with (voir __enter__ : préparer le graphique) et à la fin du with (voir __exit__ :dessiner la légende par dessus la figure, afficher la figure).

import numpy as np
import matplotlib.pyplot as plt

def polynom(coeffs: np.array, xs: np.array) -> float:
    n = coeffs.shape[0]
    values = np.array([xs ** i for i in np.arange(n)])
    return np.dot(coeffs, values)

def solve_polynom(coeffs: list) -> list:
    (c, b, a) = coeffs
    delta = b ** 2 - 4 * a * c
    sqrt_delta = np.sqrt(delta)
    return [
        (-b - sqrt_delta) / (2 * a),
        (-b + sqrt_delta) / (2 * a)
    ] if delta >= 0 else list()

class PlotContext():
    def __init__(self, xmin: float, xmax: float):
        self.xlim = (xmin, xmax)

    def __enter__(self):
        # Axes
        fig, ax = plt.subplots()
        ax.set(xlim=self.xlim)
        ax.grid(True, which="both")
        ax.axhline(y=0, color="k")
        ax.axvline(x=0, color="k")
        ax.set_xlabel("x")
        ax.set_xlabel("y")

    def __exit__(self, exc_type, exc_value, exc_traceback):
        plt.legend()
        plt.show()

def plot_polynom(coeffs: list, xlim: tuple):
    coeffs = np.array(coeffs)
    (xmin, xmax) = xlim

    # Polynom
    xs = np.linspace(xmin, xmax, 1000)
    ys = polynom(coeffs, xs)
    roots = solve_polynom(coeffs)
    label = "y = " + "+".join([f"{coeff}.x^{i}" for (i, coeff) in enumerate(coeffs)])
    plt.plot(xs, ys, label=label)

    # Racines
    plt.scatter(roots, [0] * len(roots), label=f"roots of {label}", marker="x")

def plot_polynoms(list_of_coeffs: list, xlim: tuple):
    for coeffs in list_of_coeffs:
        plot_polynom(coeffs, xlim) # P(x) = x^2 - 4

ctx = PlotContext(xmin=-10, xmax=10)
with ctx:
    plot_polynoms(
        [
            [-4, 0, 1], # x^2 - 4
            [0,  0, 2], # 2 * x^2
            [4,  0, 1], # x^2 + 4
        ],
        xlim = ctx.xlim
    )

Bonne chance

bonjour,

peux-tu montrer ton programme?