[ainsi-c]calcul d'une racine carrée par algorithme d'héron

5/5 (4 avis)

Vue 27 221 fois - Téléchargée 371 fois

Télécharger le projet
Commenter

Description

Comment calculer une racine carrée sans la librairie math.h ?
Il existe de nombreux algorithme, et j'ai choisi l'algorithme d'héron pour sa simplicité et sa précision remarquable.
c'est une suite : an+1=(an+A/an)/2
avec A=le nombre dont on calcule la racine
a(0)=un nombre quelquonque !
cette suite converge vers sqrt(A) très rapidement (d'autant plus rapidement que a0 est proche de sqrt(A))
Compile sous linux et windows.. (executable win + source dans le zip)

Source / Exemple : 


// calcul les racines carrées avec l'algo d'héron

#include <stdio.h>
void about(void);
int main(void) {

	int increment;
	float resultat;
	float acalculer;
	float an;
	float an1;
    about();
       do {
	printf("calcul des racines carrees par les approximation d'heron\n");
	printf("entrez un nombre dont on va calculer sa racine carre : \n");
	scanf("%f", &acalculer);
          }while(acalculer<=0);
	an=acalculer;
	for (increment=0;increment<8;increment++) {
	
	an1=(an+(acalculer)/an)/2;
	an=an1;	
	
	}
	resultat=an1;
printf("resultat =  %f\n\n", resultat);
if (getchar()=='\n')
   getchar();
	
return 0;

}
void about(void) {
printf("programmé par kjus\n");
}

Conclusion :


licence gpl.
pas de bugs connus.
Télécharger le projet

Codes Sources

A voir également

Ajouter un commentaire Commentaires
BruNews Messages postés 21041 Date d'inscription jeudi 23 janvier 2003 Statut Modérateur Dernière intervention 21 août 2019
16 mars 2006 à 17:24
La récursivité n'est quasi jamais la bienvenue ni pour la stack qui risque de sauter ni pour les perfs, c'est généralement le signe qu'on n'a pas réussi à s'en débarrasser.
marik7335 Messages postés 115 Date d'inscription samedi 27 décembre 2003 Statut Membre Dernière intervention 11 mai 2009
16 janv. 2005 à 23:43
Salut à tous,

J'ai réaliser cet algo dans mes débuts en programmation c++ et c'est vrai que l'astuce est bien trouvée.

Par contre, la récursivité serait la bienvenue.

l'algorithme d'héron consiste, en effet, à effectuer des calculs tant que la precision attendue n'est pas atteinte.

au début X0 = A
puis X1 = 0.5 * ( A/X0 + X0) ..... etc
juqu'à ce que Xn²- A < precision

Pour plus de simplicité on aurait pu écire la fonction de cette manière :

double RacineCarree(int A, double Xn, double precision)
{
if( (Xn*Xn) - A ) > precision
return RacineCarree(A, 0.5 * ( (A/Xn) + Xn ), precision);
else return Xn;
};

il faudra déclarer cette fonction comme ceci
Si A=7
cout << RacineCarree(7,7,0.0001); par exemple

Voilà
cs_kjus Messages postés 269 Date d'inscription mercredi 24 avril 2002 Statut Membre Dernière intervention 9 juin 2003
8 juil. 2002 à 14:21
effectivement la convergence est plus rapide lorsque "an" est proche de la racine carré. Mais ca marche avec n'importe quelle valeur. La convergence est très rapide.
mmuller57 Messages postés 174 Date d'inscription mardi 10 avril 2001 Statut Membre Dernière intervention 30 juillet 2003 1
8 juil. 2002 à 02:48
Pas mal mais il ne faut pas oublier que an doit être une estimation (valeur approchée) de la racine carrée ! non ?
S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.

Du même auteur (cs_kjus)