Discussion :

[jayjay78]

Salut tout le monde je commence la programmation et il y a un exercice dont j'ai la solution mais je comprend toujours pas pourquoi la solution marche à moins qu'il y ai un erreur :

Voici l'énoncé : Ecrire un programme récursif pour calculer la tengente de x en utilisant la formule :
tan(x) = 2t / (1-t*t) dans laquelle t = tan (x/2) et le fait que si x est petit, par exemple inférieur à 10^-6 alors tan(x) est à peu près égale à x.

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
 
public class Main {
 
       public static double tan(double x){
        if(x<1e-8)
            return x;
        double t=tan(x/2);
        return 2*t/(1-t*t);
    }
 
    public static void main(String[] args) {
        ReadConsole c = new ReadConsole();
        System.out.println("Entrer le chiffre tangeante");
        double x = c.readInt();
        double res = tan(x);
        System.out.println(res);
    }
}

Moi dans cette solution je comprend que pour x on appelle la méthode tan. Dans ce cas si x est moins grand 0.0000000001 alors dans ce cas on retourne que tan est x. Par contre si x est plus grand alors dans ce cas on rappelle la fonction tan avec x divisé par deux pour encore recommencer encore et encore jusqu'à ce que x soit assez petit pour dire que on retourne x car il est infèrieur à 0.00000001 ce qui n'a aucun sens je l'admets.
Pour résumé je ne comprend pas comment on arrive au deuxième return.

Merci ça fait une heure que je suis dessus et j'y comprend que dalle ...

[CyberChouan]

Je pense que tu n'as pas compris le programme (ni la récursivité)

Certes ton programme va appeler la méthoed "tangeante" en récursivement jusqu'à arriver à un x "assez petit". Mais ce qui est renvoyé par la méthode récursive, ce n'est pas tan(x/2), mais 2*t/(1-t*t) où t vaut tan(x/2)

Et cette formule mathématique n'a rien d'absurde...

Une fois que tu es arrivé à un x "assez petit" tu obtiens t=x. Tu remontes dans la méthode appelante qui renvoie 2*t/(1-t*t), soit 2*x/(1-x*x)

Ce résultat est à son tour remonté dans la méthode "tangeante" qui l'avait appelé. On a donc à ce niveau t=2*x/(1-x*x). On passe alors à la ligne de retour de la méthode qui vaut 2*t/(1-t*t), soit 2*(2*x/(1-x*x))/(1-(2*x/(1-x*x)*2*x/(1-x*x)))

On remonte encore d'un niveau... etc. etc. autant de fois qu'il y a eu d'appels récursifs à la méthode tangeante.

[sironimo]

De plus, sans avoir trop pu regarder ton code, je te conseille d'éviter de faire deux return dans une même méthode

[jayjay78]

Oui en effet je n'ai pas compris. J'ai du mal à comprendre ta réponse.

Pour moi (je sais que c'est faux) le programme appelle la méthode et quand il arrive à t=tan (x/2); il rappelle forcément la méthode en en divisant x par deux. Je ne comprend pas comment cela peut-être autrement.

Le deuxième return (pour moi toujours) ne peut jamais être atteints et si il l'est il renverrais ça au programme principal.

Je ne comprend pas pourquoi le return se renverrait dans la même méthode, il devrait y avoir à la fin :

return tan(2*t/(1-t*t))


J'ai vraiment du mal avec cette récursivité ...

[Kh4iN3]

Salut,

Le return d'une méthode ne retourne pas au 'programme principale' comme tu l'appel, mais à la méthode appellante.

La méthode tan s'appelle elle meme avec à chaque fois X qui vaut la moitié.
Lorsque X est inférieur à 1e-8, on renvoie la valeur à l'appel précédent, cet appel passe alors au calcul de la tangent : 2 * t / (1 - t * t). (Avet t qui a pour valeur le X précédent).
Il renvoie alors le résultat de ce calcul à la méthode précédente qui n'est autre que tan.

Et ainsi desuite les méthode se déempile en calculant à chaque fois la nouvelle valeur de t

J'espère avoir été un peu plus clair.....

a+

[jayjay78]

Merci Khain, ta réponse m'a permis de mieux comprendre celle de CyberChouan et je pense avoir compris. +++