Discussion :

[naruto-next]

J'essaye de refaire la fonction sqrt Pour cela je me suis demander quel formule il faut que j'utilise , etant en terminal je ne le sais toujours pas . Bon donc je vais faire avec un peu de logique ce qui me donne ça :

Fonction :

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
 
double racine( double racine )
            {
 
            double resultat = 0.000;
            double i = 0.000;
            double maximum = racine;
 
 
            for( i = 0.000 ; i < maximum ; i += 0.001 )
 
                    {
                        if( i * i == racine)
 
                        {
                            resultat = i;
 
 
                        }
 
 
                    }
 
            return resultat;
 
 
            }

Prototype :

Code :

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

1
2
 
double racine(double naturel);

Main.c :

Code :

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

1
2
 
printf("%f",racine(25));

Malheuresement j'obtient 0.0000 au lieu de 5.00000

Ah oui , le nombre x sera en general plus grand que la racine de x , apart si celui si est inferieur à 1 donc pour la condition je la ferai plus tard

[jeroman]

Pour calculer plus rapidement et plus simplement, il vaut mieux passer par les méthodes ancestrales. Tu as par exemple celle-ci : http://fr.wikipedia.org/wiki/M%C3%A9thode_de_H%C3%A9ron

[aymenet1]

voilà amigos

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
#include <stdio.h>
#include <math.h>
#include <conio.h>
double racine( double x )
            {
            double i;
 
            i=0.000;
            do
            {
            i+=0.001;
 
            }while(i*i<x);
 
 
            return i;
 
 
            }
 
            void main()
            { int ent;
              double sqrt;
            printf("donner un entier ");
            scanf("%i",&ent);
            sqrt=racine(ent);
            printf("la racine carrée de %i est %.2f",ent,sqrt);
            getch();
            }

fonctionnel 100% si tu comprends pas quelque choses n'hesite pas a me demander ...

[diogene]

Je te conseille de te pencher sur la méthode classique et beaucoup plus efficace évoquée par jeroman. Si tu es en terminale, elle est à ta portée.

[Obsidian]

fonctionnel 100% si tu comprends pas quelque choses n'hesite pas a me demander ...

C'est un peu présomptueux :

• Sur mon Core 2 Quad à 2,83 Ghz, il m'a fallu dix secondes pour que i atteigne 2767750,9674904584. Si tu voulais trouver la racine du plus grand nombre possible représentable avec un double (64 bits). Cela prendrait donc DBL_MAX ÷ 2767750.9674904584 ÷ 6 ÷ 60 ÷ 24 ÷ 365.25 années, soit : 205 818 581 907 479 461 463 410 466 691 017 217 129 174 295 660 217 585 353 873 316 935 10 583 895 465 556 118 545 809 178 392 910 646 621 189 221 477 561 271 807 007 840 365 11 27 868 396 532 752 861 115 510 232 209 269 907 478 541 557 950 849 017 030 089 280 180 75 650 652 320 555 183 125 073 391 189 973 814 214 462 500 545 051 898 146 802 766 095 968 806 074 575 629 103 353 387 359 928 320 années de calcul. À titre de comparaisons, l'univers n'est âgé que de 13 700 000 000 années ;
• Même si tu avais la patience d'attendre, le principe d'un nombre à virgule flottante est de représenter des nombres toujours plus grands sur une même largeur de bits. Les nombres les plus petits sont alors négligés. Ton 0.001 finirait par être assimilé à un zéro et ton programme tournerait en boucle infinie ;
• Les carrés des nombres inférieurs à 1 sont plus petits que leurs racines. Tous les nombres plus proches de zéro que 0,031623 auraient alors « 0,001 » pour solution unique !

Il y a plusieurs manières d'extraire une racine carrée mais, étant donné qu'un ordinateur est une machine finie et soumise aux imprécisions, je trouve que le plus simple est d'utiliser l'algorithme arithmétique tel qu'il était enseigné jadis à l'école :

http://fr.wikipedia.org/wiki/Racine_...s_carr.C3.A9es

C'est applicable à toutes les bases, y compris la base 2 qui, comme pour la division, simplifie considérablement les étapes à mener. La complexité (et sa durée) de l'algorithme est alors uniquement fonction du nombre de bits (ici, 64).

[aymenet1]

mon code n'est pas precis et il ne trouve pas les racines des reels <1 .
je comprends Obsidian ...
si on choisis 0.000000001 comme pas et on veux trouver la racine de 1000000000 il faut attendre une un tres grand temps ^^
Merci pour l'explication pour les examples .

[Obsidian]

si on choisis 0.000000001 comme pas et on veux trouver la racine de 1000000000 il faut attendre une un tres grand temps ^^

Non seulement, dans certains cas, l'âge de l'univers lui-même serait insignifiant par rapport au temps qu'il faudrait mais, comme je te le disais, il est possible qu'à partir d'une certaine valeur, ton programme entre dans une boucle infinie. Voici pour exemple un programme qui utilise float et qui compte de 1.000.000.000 (un milliard) à 1.000.000.100 (un milliard cent), soit cent tours de boucle, ce qui n'a rien d'extraordinaire. Lance-le sur ta machine et admire le résultat :

Code C :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <stdio.h>
#include <stdio.h>
 
int main (void)
{
    float x =  1000000000.0;     /* Un milliard. */
 
    while (x < 1000000100.0)
    {
        printf ("%f\n",x);
        x = x+1;                /* On ajoute 1 */
    }
 
    return 0;
}

Code Shell :

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

1
2
3
4
5
6
7
8
9
10
11
12
$ gcc milliard.c -o milliard
$ ./milliard
1000000000.000000
1000000000.000000
1000000000.000000
1000000000.000000
1000000000.000000
1000000000.000000
1000000000.000000
1000000000.000000
1000000000.000000
…

Essaie de comprendre pourquoi.

Merci pour l'explication pour les examples .

À ton service.