Exercice III : polynôme creux

(1)

Exercice III : polynôme creux

Dans cet exercice, on se propose de développer un module permettant de manipuler des polynômes creux. Un polynôme creux est un polynôme contenant très peu de monômes non nuls.

Exemple : P(x) = 5.6 x¹²⁸⁰ + 0.8 x – 9 contient 1281 termes dont 3 seulement sont non nuls.

enreg Tmonome entier deg réel coef Tmonome *suiv finenreg

Chaque monôme est décrit par un enregistrement de type Tmonome comportant les 3 champs suivants :

• deg : entier représentant le degré du monôme ;

• coef : réel représentant le coefficient du monôme ;

• suiv : pointeur sur le monôme suivant.

enreg Tpolynome Tmonome *prem finenreg

Un polynôme sera décrit par une structure Tpolynome contenant un seul champ prem :

• Si prem est nul, le polynôme correspondant sera le polynôme zéro ;

• Si prem est non nul, il pointera sur le monôme de plus haut degré dont le coefficient est non nul. Les monômes de coefficient non nuls sont chaînés par ordre de degré décroissant.

Proposez un algorithme pour la procédure ajouter :

••••

Procédure ajouter (résultat Tpolynome pol, valeur entier deg, valeur réel coef)

qui ajoute à un polynôme (pol) la valeur d’un monôme défini par son degré (deg) et son coefficient (coef).

On s’intéresse maintenant à l’implémentation des opérations additionner et multiplier dont les déclarations sont données ci-dessous. Ces opérations construisent le polynôme résultat somme (respectivement produit) de deux polynômes :

• procédure additionner (valeur Tpolynome1 pol1, valeur Tpolynome1 pol2, résultat Tpolynome1 pol3)

• procédure multiplier (valeur Tpolynome1 pol1, valeur Tpolynome1 pol2, résultat Tpolynome1 pol3)

Proposez des algorithmes pour les opérations additionner et multiplier utilisant la procédure ajouter de la question précédente.

Proposez un autre algorithme pour l’opération additionner sans utiliser la procédure ajouter, en remarquant que chaque fois que l’on ajoute un monôme au polynôme résultat, il est toujours placé à la fin puisque les monômes sont rangés dans un ordre décroissant

1280 5.6

1 0.8

0 -9 P

(2)

Procédure ajouter

1. Procédure ajouter (résultat Tpolynome pol, valeur entier deg, valeur réel coef) 2. Tmonome *pmon

3. Tmonome *pmon_avant 4. Tmonome *pmon_apres 5. début

6. si coef <> nul alors

7. pmon_apres ← pol.premier 8. pmon_avant ← nul

9. tantque pmon_apres <> nul et (*pmon_apres).deg > deg faire 10. pmon_avant ← pmon_apres

11. pmon_apres ← (*pmon_apres).suiv 12. fintantque

13. /* Cas pmon_apres = nul ou bien (*pmon_ apres).deg <= deg */

14. si (pmon_apres = nul) ou (*pmon_apres).deg <> deg alors 15. /* on a soit pmon_apres = nul soit (*pmon_ apres).deg < deg */

16. pmon ← allouer(taille(Tmonome))

17. si pmon = nul alors Ecrire(" erreur allocation mémoire ") 18. sinon

19. (*pmon).deg ← deg 20. (*pmon).coef ← coef

21. (*pmon).suiv ← pmon_apres 22. si pmon_avant <> nul alors 23. (*pmon_avant).suiv ← pmon 24. sinon

25. pol.prem ← pmon 26. finsi

27. finsi

28. sinon /* on a (*pmon_ apres).deg = deg */

29. (*pmon_ apres).coef ← (*pmon_ apres).coef + coef

30. si (*pmon_ apres).coef = 0 alors /* il faut le supprimer */

31. si pmon_avant <> nul alors

32. (*pmon_ avant).suiv ← (*pmon_ apres).suiv 33. sinon

34. pol.prem ← (*pmon_ apres).suiv 35. finsi

36. libérer(pmon_apres) 37. finsi

38. finsi 39. finsi 40. fin

Procédure additionner : solution 1

Dans cette version, on utilise la procédure ajouter de la question précédente.

1. Procédure additionner ( valeur Tpolynome pol1, 2. valeur Tpolynome pol2, 3. résultat Tpolynome pol3) 4. Tmonome *pmon1, *pmon2

5. début

6. pol3.prem ← nul 7. pmon1 ← pol1.prem 8. pmon2 ← pol2.prem

9. tantque pmon1 <> nul et pmon2 <> nul faire 10. si (*pmon1).deg = (*pmon2).deg alors

11. ajouter (pol3, (*pmon1).deg, (*pmon1).coef + (*pmon2).coef)

(3)

12. pmon1 ← (*pmon1).suiv 13. pmon2 ← (*pmon2).suiv 14. sinon

15. si (*pmon1).deg > (*pmon2).deg alors

16. ajouter (pol3, (*pmon1).deg, (*pmon1).coef) 17. pmon1 ← (*pmon1).suiv

18. sinon

21. finsi 22. finsi 23. fintantque

24. /* Cas pmon1 = nul ou pmon2 = nul */

25. si pmon1 = nul alors 26. pmon1← pmon2 27. finsi

28. tantque pmon1 <> nul faire

31. fintantque 32. fin

Procédure additionner : solution 2

Dans cette version, on n'utilise pas la procédure ajouter

1. Procédure additionner ( valeur Tpolynome pol1,

2. valeur Tpolynome pol2,

3. résultat Tpolynome pol3) 4. Tmonome *pmon1, *pmon2, *pmon3, *pmon

5. réel coef 6. entier deg 7. début

8. pol3.prem ← nul 9. pmon1 ← pol1.prem 10. pmon2 ← pol2.prem 11. pmon3 ← nul

12. tantque pmon1 <> nul et pmon2 <> nul faire 13. si (*pmon1).deg = (*pmon2).deg alors 14. coef ← (*pmon1).coef + (*pmon2).coef) 15. deg ← (*pmon1).deg

16. pmon1 ← (*pmon1).suiv 17. pmon2 ← (*pmon2).suiv 18. sinon

19. si (*pmon1).deg > (*pmon2).deg alors 20. deg ← (*pmon1).deg

21. coef ← (*pmon1).coef 22. pmon1 ← (*pmon1).suiv 23. sinon

24. deg ← (*pmon2).deg 25. coef ← (*pmon2).coef 26. pmon2 ← (*pmon2).suiv 27. finsi

28. finsi

29. si coef <> 0 alors

31. si pmon = nul alors Ecrire("erreur allocation mémoire") 32. sinon

(4)

33. (*pmon).deg ← deg 34. (*pmon).coef ← coef 35. (*pmon).suiv ← nul 36. si pmon3 <> nul alors 37. (*pmon3).suiv ← pmon 38. sinon

39. pol3.prem ← pmon 40. finsi

41. pmon3 ← pmon 42. finsi

43. finsi 44. fintantque

45. si pmon1 = nul alors 46. pmon1 ← pmon2 47. finsi

50. si pmon = nul alors Ecrire("erreur allocation mémoire") 51. sinon

52. (*pmon).deg ← deg 53. (*pmon).coef ← coef 54. (*pmon).suiv ← nul 55. si pmon3 <> nul alors 56. (*pmon3).suiv ← pmon 57. sinon

58. pol3.prem ← pmon 59. finsi

60. pmon3 ← pmon 61. finsi

62. pmon1 ← (*pmon1).suiv 63. fintantque

64. fin

Procédure multiplier : première version

1. Procédure multiplier ( valeur Tpolynome pol1, 2. valeur Tpolynome pol2, 3. résultat Tpolynome pol3) 4. Tmonome *pmon1, *pmon2

5. début

6. pol3.prem ← nul 7. pmon1 ← pol1.prem

8. tantque pmon1 <> nul faire 9. pmon2 ← pol2.prem

11. ajouter (pol3, (*pmon1).deg, (*pmon2).deg, (*pmon1).coef * (*pmon2).coef) 12. pmon2 ← (*pmon2).suiv

13. fintantque

14. pmon1 ← (*pmon2).suiv 15. fintantque

16. fin

(5)

Procédure multiplier : deuxième version

1. Procédure multiplier ( valeur Tpolynome pol1, 2. valeur Tpolynome pol2, 3. résultat Tpolynome pol3) 4. Tmonome *pmon1, *pmon2, *pmon3, *pmon, *pmon_apres 5. booléen fini

6. entier deg 7. réel coef 8. début

9. pol3.prem ← nul 10. pmon1 ← pol1.prem 11. pmon2 ← pol2.prem 12. pmon3 ← nul

13. si pmon2 <> nul alors 14. fini ← faux

15. sinon 16. fini ← vrai 17. finsi

18. tantque pmon1 <> nul et fini = faux faire 19. pmon2 ← pol2.prem

20. pmon3 ← pol3.premier

21. tantque pmon2 <> nul et fini = faux faire 22. deg ← (*pmon1).deg + (*pmon2).deg 23. coef ← (*pmon).coef * (*pmon).coef 24. pmon_apres ← pmon3

25. tantque pmon_apres <> nul et (*pmon_apres).deg > deg faire 26. pmon3 ← pmon_apres

27. pmon_apres ← (*pmon_apres).suiv 28. fintantque

29. si pmon_apres = nul ou (*pmon_apres).deg <> deg alors 30. pmon ← allouer(taille(Tmonome))

31. si pmon = nul alors Ecrire("erreur allocation mémoire") 32. fini ← vrai

33. sinon

34. (*pmon).deg ← deg 35. (*pmon).coef ← coef 36. si pmon3 = nul alors 37. pmon3 ← pmon 38. pol3.prem ← pmon 39. (*pmon).suiv ← nul 40. sinon

41. (*pmon).suiv ← pmon_apres 42. (*pmon3).suiv ← pmon 43. finsi

44. sinon

45. /* Cas (*pmon_apres).deg = deg */

46. (*pmon_apres).coef ← (*pmon_apres).coef + coef 47. si (*pmon_apres).coef = 0 alors

48. (*pmon3).suiv ← (*pmon_apres).suiv 49. libérer(pmon_apres)

50. finsi 51. finsi

52. pmon2 ← (*pmon2).suiv 53. fintantque

54. pmon1 ← (*pol1).suiv 55. fintantque

56. fin