Testez les lignes suivantes directement dans l'interprète Python, et vérifiez que vous comprenez bien chacune des lignes.

>>> t1 = [2, 4, 6, 8]  	# on déclare un tableau à 4 cases
>>> print(len(t1))	# on affiche sa taille (normalement, c'est 4)
4
>>> t2 = t1 + [8, 10]	# on concatène le tableau avec un nouveau tableau
>>> print(len(t2)) 	# normalement, on doit obtenir 6
6
>>> print(t2[0])	# on affiche la première case
2
>>> print(t2)		# on affiche tout le tableau t2
[2, 4, 6, 8, 8, 10]
>>> t2[4] = 12		# on modifie une case par une affectation
>>> print(t2)		# on affiche tout le tableau t2
[2, 4, 6, 8, 12, 10]
>>> print(t2 * 2)
[2, 4, 6, 8, 12, 10, 2, 4, 6, 8, 12, 10]

Écrivez une procédure d'affichage d'un polynôme. La définition de votre fonction commencera par

def affiche_poly(P):
    """procédure d'affichage d'un polynôme
paramètre : P de type tableau de flottants"""
    ...
    ...

Votre procédure devra pouvoir afficher des polynômes de degré arbitraire.

Facultatif : améliorez votre procédure d'affichage pour :

• ne pas afficher le "*X^0"
• afficher "X" au lieu de "X^1"
• ne pas afficher "0*X^n"
• afficher les coefficients négatifs directement avec "- 2.3*X^n" au lieu de "+ -2.3*X^n"
• ...

Écrivez la fonction "input_poly" qui commence comme suit :

def input_poly(message):
    """initialise un polynôme en posant des questions à l'utilisateur
La fonction commence par demander le degré du polynôme, et demande ensuite
chacun des coefficients.

paramètre : message de type chaine de caractères, c'est le message affiché
avant de demander le degré du polynôme

résultat de type polynôme, c'est à dire tableau de flottants."""
    ...
    ...

Attention :

• vous pouvez initialiser le tableau de flottants dés que vous connaissez son degré d en utilisant

    P = [0.0] * (d+1)
  

  ceci permet d'obtenir un tableau de d+1 cases, chacune d'entre elle contenant le coefficient 0.0.

• vous pouvez modifier la valeur contenue dans case d'indice i avec la ligne

    P[i] = 12.0
  

Écrivez une fonction pour calculer le produit scalaire de deux polynômes. Votre définition commencera par

def produit_scalaire(P1, P2):
    """calcule le produit scalaire de deux polynômes

paramètres : P1 et P2, deux polynômes de même degré, c'est à dire deux tableaux
de flottants de même taille.

résultat : un polynôme de même degré que les paramètres P1 et P2"""
    ...
    ...

Testez votre fonction, avec la procédure suivante :

def test_produit_scalaire():
    P = input_poly("premier polynôme")
    Q = input_poly("second polynôme")
    R = produit_scalaire(P, Q)
    print("le produit scalaire des deux polynômes est")
    affiche_poly(R)

Vérifiez en particulier ce qui se passe lorsque les deux polynômes n'ont pas le même degré.

Écrivez une fonction pour calculer la somme de deux polynômes.

Combien de paramètres cette fonction doit elle avoir ? Quels sont leurs types ? Quel est le type du résultat de cette fonction ?

Attention,

• vous devez pouvoir additionner des polynômes de degré différents,
• vous devez écrire une procédure de test, et tester votre fonction.

Écrivez une fonction pour calculer la dérivée d'un polynôme.

Comme précédemment, vous devrez écrire une procédure de test pour tester votre fonction.

Le problème est maintenant de savoir qu'elle est la valeur d'un polynôme sur un flottant particulier. Écrivez la fonction qui calcule cette valeur.

Combien de paramètres cette fonction doit elle avoir ? Quels sont leurs types ?

N'oubliez pas d'écrire une fonction de test qui demande un polynôme à l'utilisateur, puis qui lui demande quelques flottants sur lesquels évaluer le polynôme.

Écrivez (et testez) une fonction qui calcule la multiplication de deux polynômes.

Attention, c'est plus complexe pour l'addition, car le degré du résultat augmente. Par exemple, on a (- 2 + 4X -3X²) (1 - X + X³) = (-2 + 6X - 7X² + 4X⁴ - 3X⁵)

Écrivez et testez une fonction qui calcule la composition de deux polynômes.