Développement limité de fonction

Bonsoir,

Dans le cadre de mes études je dois créer 3 versions d'une même méthode pour obtenir le même résultat pour les fonctions exponentielles, cosinus et sinus.

1ere méthode à l'aide de la classe Math :

- Cosinus :

Code:

---

1 2 3 4

public double valeur(double x) { return Math.cos(x); }

---

- Sinus :

Code:

---

1 2 3 4

public double valeur(double x) { return Math.sin(x); }

---

- Exponentielle :

Code:

---

1 2 3 4

public double valeur(double x) { return Math.exp(x); }

---

2e version via le développement limité de la fonction et les fonctions puissance et factorielle (Math.pow et Factoriel.fact) :

La méthode fact(double x) de la classe Factoriel est une classe personnel qui fonctionne correctement.

Code:

---

1 2 3 4 5 6 7 8 9 10

public double valeur2(double x) { double exp = 0; for(int i = 0; i<n;i++) { exp += Math.pow(x, i)/Factoriel.fact(i); } return exp; }

---

Cependant, je ne sais comment déterminer la valeur n pour obtenir le résultat adéquate. Est ce que ma méthode est enfaite bien plus complexe que celle présentée similaire à quelque chose comme cela : http://www.maths-forum.com/calcul-ex...ite-101965.php mais adapté au cas.

Quant à la troisième version, elle correspond à une solution plus efficace (n’utilise pas les fonctions puissance et factorielle), basée sur le fait que le
terme d’ordre i peut être calculé en fonction du terme d’ordre i − 1.

Merci d'avance pour votre aide :)

Si tu veux une valeur de n, je peux en donner une :

Code:

---

private final const int n =10;

---

Ce qui manque à votre sujet, c'est une problématique.
Du style, "Comment faire le calcule suivant : ?"...

Si tu dois faire 3 fonctions qui renvoient (exactement) le même résultat.
Alors, il n'y a pas 36 solutions :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

public double fonction1(double x) { return doFonction(x); }   public double fonction2(double x) { return doFonction(x); }   public double fonction3(double x) { return doFonction(x); }   private double doFonction(double x) { return x; }

---

Le résultat renvoyé par les trois versions n'est pas identique mais très similaire à un ordre de grandeur minimum.

Le but de l'exercice est de visualiser les approximations obtenues en fonction de l’ordre du développement limité utilisé et ensuite tester de manière concrète la différence de performance des deux derniers algorithmes.

On souhaite simplement utiliser des algorithmes différents pour une même résultat recherché.

Citation:

---

Envoyé par Schnapse

On souhaite simplement utiliser des algorithmes différents pour une même résultat recherché.

---

Oui j'ai bien compris ça mais du coup où est la question ? Je suppose que ton soucis doit plus s'apparenter à un problème de math que d'informatique non ?

Ca me fait penser à un exo que j'avais eut en pascal en 1ere année. Il fallait calculer le cosinus d'un multiple entier de PI.

Evidemment la plupart des étudiants ont vu que :

cos(n * PI) = 1 si n est pair et 0 si n est impair. Ca fait une première solution lol...

Plus sérieusement, quelques remarques avant d'aller plus loin.

Tu ne dois pas utiliser "const" en Java.

Programme des méthodes avec des vrais noms. Tu peux avoir trois méthodes comme calculerSinus, calculerCosinus, calculerExponentiel que tu mets dans une interface nommée Calculette. Ensuite tu fais 3 classes qui implémentents Calculette, par exemple :

Code:

---

1 2 3 4 5 6

public interface Calculette { Double calculerCosinus(Double d); Double calculerSinus(Double d); Double calculerExponentiel(Double x, Double e); }

---

puis

Code:

---

1 2 3 4 5 6 7 8

public class Calculette1 implements Calculette { public Double calculerSinus(Double d) { return ... }   ... }

---

Ca te permettre en outre de faire très facilement tes cas de test, avec JUnit par exemple, surtout si tu penses à factoriser tes appels dans une classe abstraite et à spécifier ton implémentation dans le test en bout de chaine.

Pense aussi à bien formater ton code en Java, et non en C.

Une question que je me pose, c'est comment calculer un exponentiel avec des chiffres trop grands si tu travailles avec des doubles, idem pour le factoriel (je parle précisément de ce cas en annexes de mon article de présentation de 3T) car la capacité des int et des double est vite atteinte...

Sinon, effectivement, dès qu'on dépasse une certaine précision, on ne cherche plus à tester l'égalité mais l'appartenance à un intervalle de valeur (le plus petit possible), c'est à dire à minorer l’imprécision.

Tu peux aussi faire :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

public class Calculette { private int nbIteration = 1;   public Calculette(iteration){ this.nbIteration = iteration; } public Double calculerSinus(Double d) { return doCosinus(d, nbIteration); }   private double doCosinus(double x, int n){ double exp = 0; for(int i = 0; i<n;i++) { exp += Math.pow(x, i)/Factoriel.fact(i); } return exp; } }

---

Et faire plusieurs calculette...

Et même une interface pour la Calculette et une classe abstraite pour le code proposé par kolodz. Là ça serait vraiment top.

Reste à régler le problème du calcul du factoriel et de la capacité des doubles.

Citation:

---

Envoyé par Schnapse

Le résultat renvoyé par les trois versions n'est pas identique mais très similaire à un ordre de grandeur minimum.

Le but de l'exercice est de visualiser les approximations obtenues en fonction de l’ordre du développement limité utilisé et ensuite tester de manière concrète la différence de performance des deux derniers algorithmes.

On souhaite simplement utiliser des algorithmes différents pour une même résultat recherché.

---

Dans ce cas là, n'est ce pas la valeur de 'n' qui importe ?

Code:

---

1 2 3 4 5 6 7 8 9 10

boolean end = false; int n =0 ; double epsilon = 0.0001; while ( ! end ){ n++; double diff = Math.abs(cos(x) -doCosinus(x,n)); end = diff <= epsilon; } System.err.println("........ iteration calcul algo 1 " + n );

---

Si tu ne peux pas utiliser cos(x), tu peux peut-être faire un truc du style :

Code:

---

1 2 3 4 5 6 7 8 9 10

boolean end = false; int n =1 ; double epsilon = 0.0001; while ( ! end ){ n++; double diff = Math.abs(doCosinus(x,n-1) -doCosinus(x,n)); end = diff <= epsilon; } System.err.println("........ iteration calcul algo 1 " + n );

---

tu refais la même chose pour l'algo 2 et tu compares le nombre d'itérations. Celui qui a le plus petit a gagné.