#!/usr/bin/env python # -*- coding: UTF-8 -*- """ écriture d'un programme pour évaluer des polynomes + fonction de multiplication d'un polynôme pas un scalaire + fonction d'addition de deux polynômes """ from math import * def polyeval(x,a): """ application de l'agorithme de Horner cf. http://fr.wikipedia.org/wiki/M%C3%A9thode_de_Ruffini-Horner """ n = len(a) - 1 # n = ordre du polynôme p =0. for i in range(n,-1,-1): p = p*x +a[i] return p def polyscal(s,a): """ polynôme multiplié par un scalaire s """ b = [] for coef in a: b.append(coef*s) return b # on retourne les coefficients multipliés par s def polyadd(a,b): """ Addition de deux polynômes de coefficients a et b """ r = a[:] # on travaille sur une copie de a pour ne pas le modifier t = b[:] # idem pour b g = [] # polynôme somme n1 = len(r) # ordre du premier polynôme n2 = len(t) # ordre du second polynôme if n1 > n2: # premier polynôme de plus haut degré que le second for i in range(n1-n2): t.append(0) elif n1 < n2: # second polynôme de plus haut degré que le premier for i in range(n2-n1): r.append(0) # r et t ont à présent la même longueur for i in range(len(r)): g.append(r[i] + t[i]) return g # on retourne les coefficients additionnés dans la liste g # différents tests : x = 2. a = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] print(polyeval(x,a)) coefm = 2.75 print(polyscal(coefm,a)) varx = 0.5 varcoef = [1., 2., 3., 4., 5., 6., 7., 8., 9., 10.] print(polyeval(varx,varcoef)) for j in range(0,11,1): rep = sin(polyeval(float(j) * 0.1,varcoef)) print(rep) u = [1, 2, 4, 8, 16] v = [1, 3, 9, 27, 81, 243, 729] print(u,v,polyadd(u,v))
Dans le fonction polyadd ci-dessus, l'idée est de compléter les listes par autant de zéros qu'il faut pour que la liste la plus courte devienne aussi longue que l'autre. On travaille en fait sur des copies des listes pour ne pas modifier les données originales, car python passe les paramètres des fonctions par référence et pas par valeur (cf. ici ou là). Polyadd aurait pu être conçue d'une autre manière, par exemple en additionnant les termes tant qu'on est en dessous du degré maximum du polynôme de degré minimum ! et en complétant ensuite par les coefficients de degré supérieur du polynôme de degré maximum. Comme la proposition suivante d'un étudiant !
Si on utilise les astuces de programmation les plus “pythoniques” avec notamment la librairie itertools, la fonction polyadd peut être récrite beaucoup plus simplement :
def polyadd2(a,b): """ Addition de deux polynomes de coefficients a et b utilisation de la librairie itertools avec itertools.zip_longest ref : https://stackoverflow.com/questions/44000727/iterate-over-two-lists-with-different-lengths """ return [u + v for u, v in itertools.zip_longest(a, b, fillvalue=0)]
Il est temps de créer des graphes de fonctions polynomiales. Comment faire ? Quelles librairies utiliser ?
Voici un programme simple pour une fonction particulière (une sinusoïde amortie) :
#!/usr/bin/env python # -*- coding: UTF-8 -*- """ graphe d'une sinusoïde amortie """ from pylab import * def sin_amort(t): s1 = sin(pi * t) e1 = exp(- t /8.) return s1 * e1 xvals = arange(0., 40., 0.1) plot(xvals, sin_amort(xvals)) show() # le même genre de graphique, avec des symboles rouges et lignes noires plot(xvals, sin_amort(xvals), 'ro', xvals, sin_amort(xvals), 'k') show()
Il faut donc faire un programme similaire en introduisant la fonction nécessaire et en adaptant les appels.