Discussion :

[Évariste Galois]

Bonjour,

J'ai ici deux fonctions destinées à calculer un cosinus et un sinus respectivement :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
 
// cos(x) = Somme(n=0, +oo)  (-1)^n . (x^{2n}) / (2n)! 
double calculerCos(double X,double precision)
{
     double terme_1 = 1;            // (-1)^n
     double terme_2 = 1;            // x^{2n}
     double terme_3 = 1;            // 1/(2n)! 
     double terme_final = 1;        // (-1)^n . (x^{2n}) / (2n)!
     double reponse = 1;
     long int n = 0;
 
     do
     {
        terme_1 *= (-1);
        terme_2 *= (X * X);
        /* Somme(n=0, +oo) = 1/1 + 1/(1*2) + 1/(1*2*3*4) + 1/(1*2*3*4*5*6 + ...
           on a donc T(k) = T(k- 1).1/((n + 1)(n +2)) avec n = 0 si k = 0 et n est 
           incrémenté de 2 à chaque itération
         */
        terme_3 *= 1/((double)(n + 1)*(n + 2));
        terme_final = (terme_1 * terme_2 * terme_3);
        reponse +=terme_final;
        n+= 2;
 
     }while (abs(terme_final) > precision);
 
     return reponse;
}
 
// sin(x) = Somme(n=0, +oo)  (-1)^n . (x^{2n + 1}) / (2n +1)! 
double calculerSin(double X,double precision)
{
     double terme_1 = 1;            // (-1)^n
     double terme_2 = X;            // x^{2n +1}
     double terme_3 = 1;            // 1/(2n + 1)! 
     double terme_final = 1;        // (-1)^n . (x^{2n + 1}) / (2n +1)!
     double reponse = X;
     long int n = 1;
 
     do
     {
        terme_1 *= (-1);
        terme_2 *= (X * X);
        /* Somme(n=0, +oo) = 1/1 + 1/(1*2) + 1/(1*2*3*4) + 1/(1*2*3*4*5*6 + ...
           on a donc T(k) = T(k- 1).1/((n + 1)(n +2)) avec n = 0 si k = 0 et n est 
           incrémenté de 2 à chaque itération
         */
        terme_3 *= 1/((double)(n + 1)*(n + 2));
        terme_final = (terme_1 * terme_2 * terme_3);
        reponse +=terme_final;
        n+= 2;
 
     }while (abs(terme_final) > precision);
 
     return reponse;

Comme vous le voyez elle ne différent que par l'initialisation des variables de départ. A votre avis, je compresse le tout en une seule ou je laisse comme ça ? Il faudra alors que je rajoute un paramètre à la fonction de manière à savoir s'il faut calculer un sinus ou un cosinus.

Vous allez me dire que c'est très secondaire comme question mais j'aimerais avoir votre avis.

merci

[DaZumba]

J'en ferais trois. Une fonction privee (static dans l'unite de traduction) qui fait le calcul reel. Deux fonctions publiques, cos et sin, qui ne sont en fait qu'un emballage de la fonction privee (wrapper) et qui se chargent de faire l'initialisation correcte.
Ainsi, tu gardes la simplicite d'appel de cos et sin, mais tu factorises le code.

[Captain_JS]

sin (x) = cos (pi/2 - x)

a partir de la dans l'une des 2 tu changes ton X et t'appele l'autre avec

[diogene]

Je suis entièrement d'accord avec les solutions préconisées par DaZumba et Captain_JS.
A ta place, je modifierais le code de manière à ramener l'angle entre 0 et 2*PI avant le calcul (ou entre 0 et PI/2 avec correction du signe du résultat) pour obtenir une convergence plus rapide.

[Matthieu Brucher]

Et avec des template aussi peut-être ?

[Évariste Galois]

Et avec des template aussi peut-être ?

Je n'ai jamais vraiment utilisé les modèles, faudrait que je m'y mette un jour

Ok sinon ce sont de bonnes idées ça, je vas voir un peu, merci bien

[Bob.Killer]

moi j en ferais 10 mais ça n engage que moi !

[Laurent Gomila]

Pour ce qui est des templates, tu peux jeter un oeil par ici par exemple.

[Matthieu Brucher]

Etant donné que tu cours après une précision, tu devrais plutôt commencer par calculer le n qui va bien, dans le sens contraire, tu n'auras pas la précision que tur recherches alors que tu penses l'avoir.

[Évariste Galois]

moi j en ferais 10 mais ça n engage que moi !

Mais tu auras un fichier source énorme

Pour ce qui est des templates, tu peux jeter un oeil par ici par exemple.

En fait c'est expliqué dans mon livre sur le C++. L'ennui c'est que c'est expliqué à la fin du livre et qu'a ce stade ils supposent connue les notions avancées de POO tels que l'héritage, fonctions virtuels, etc.
Je ne compte pas me lance la dedans tout de suite (quoique j'ai déja jeté un coup d'oeil, et de toute façon en fac. d'info on ne commence sérieusement avec la POO qu'en deuxième année alors ...).
Je vais voir ton lien

tu devrais plutôt commencer par calculer le n qui va bien, dans le sens contraire, tu n'auras pas la précision que tur recherches alors que tu penses l'avoir.

Ah bon ? Je ne comprend pas comment ça se fait
Sinon si tu veux tout savoir eh bien on a demandé de concevoir ce programme à des étudiants de première année d'info à l'ULB (dans le cadre du cours de programmation) et l'énoncé de l'exercice précisait :

"Votre programme devra continuer l'addition des termes succecifs de la série jusqu'a ce que la valeur d'un terme soit plus petite qu'un epsilon donné"
Donc en fait je n'ai fait que mettre l'énoncé en pratique ...

merci !

[Matthieu Brucher]

Mouais...
En fait, le nombre additionné diminue à chaque fois. Or, pour avoir un maximum de précision, il te faut commencer par additionner les plus petits ensembles, puis les suivants.
Un exemple, tu est limité à 5 chiffres significatifs :
1.0000 + 0.00005 + 0.00005 = ?
Si tu fais dans l'ordre, tu auras... 1.0000
Si tu additionnes les plus petits, tu auras 1.0001
Lequel est le plus précis ? Lequel sera à un epsilon du bon résultat ?

Au fait, ce n'est pas parce que l'énonce te dire de faire comme ça et comme ça que tu n'as pas le droit d'avoir un esprit critique, au contraire, ça devrait être apprécié ! C'est le genre de choses qu'on demande d'un gars qu'on embauche !