sqrt()        : extraction de racine carrée
pow()        : calcul de puissances
HUGE_VAL        : symbole pour une valeur infinie, défini dans <math.h>

Prototype:
• double sqrt( double x);
• double pow( double x, double y);
• long double powl( long double x, long double y);
  dans: <math.h>



Code objet:

dans libm.a (généralement dans le répertoire /usr/lib)
à l'édition de liens sur UNIX, précisez l'option -lm pour faire référence à la bibliothhèque /usr/lib/libm.a
exemples:
• xlc source.c -lm # système AIX.
• cc source.c -lm



Description:

• sqrt(x) calcule la racine carrée de x quand x est positif ou null.
  
  
• pow() calcule x**y.
  
  Lorsque x est positif et y non entier, le calcul peut être fait en utilisant l'égalité: x**y   =   exp(y*log(x)).
  
  Si le parametre x est négatif ou nul, alors y doit être entier.
  Si y est égal à 0, alors pow() renvoie 1.O, quel que soit x.
  



Valeur renvoyée:

• la valeur calculée s'il n'y a pas de problème
  
• pour sqrt():
  si x   <   0, la valeur renvoyée est NaN, et errno vaut EDOM
  
• pour pow():
  
  • en cas de débordement, pow() positionne errno à la constante ERANGE et renvoie:
    
    • HUGE_VAL si le résultat est trop grand
    • 0 si le résultat est trop petit
  • si x   <   0 et y n'est pas un entier, pow() renvoie NaN et errno vaut EDOM
  • si x=0 et y<0, pow() renvoie HUGE_VAL sans modifier errno


Voir aussi:
     double,       exp()  


Portabilité:
DOS, UNIX, norme ANSI du langage C.



Exemple:

/* Dans le programme ci-dessous: utilisations de la fonction sqrt() utilisations simples de la fonction pow() affichage de errno après utilisation de pow() remarques sur la précision des calculs: un grand nombre N tel que 'N+1' et N soient identiques (ou 1 est négligeable devant N) un nombre petit n, tel que 'n+1' et 1 soit identiques (ou n est négligeable devant 1) */ #include <stdio.h> #include <math.h> #include <errno.h> /* utilisation de errno et des constantes ERANGE ... */ void main(void) { double x, y, res, res1; /* Quelques constantes et errno:variable externe */ /**************************************************/ printf("\nAffichage de quelques constantes\n"); printf("HUGE_VAL:%lf, ERANGE=%d EDOM=%d errno=%d\n", HUGE_VAL, ERANGE, EDOM, errno); printf("\nUtilisations de la fonction sqrt()\n"); /* ********************************** */ x=3.14; printf("Déroulement normal --> sqrt(%lf): %le\n", x, sqrt(x)); errno=0; x=-1; res=sqrt(x); printf("Déroulement anormal --> sqrt(%lf): %le errno=%d\n", x, res, errno); printf("\nUtilisations de la fonction pow()\n"); /* ********************************* */ x=40.0; y=1/3.0; /* racine cubique de 40 */ printf("Racine cubique: %lf ** %lf: %lf\n", x,y,pow(x,y)); /* 2**53 est représentable sur un double mais pas un entier */ x=-2; y=52; res=pow(x,y); printf("Puissance entière: %lf ** %lf: %lf\n", x, y, res); printf("\nDans la suite on surveille le compte rendu d'erreur (errno)\n"); /* *************************************************** */ /* Premier cas, errno n'est pas modifiée par l'appel à pow() */ errno=0; x=2; y=-52; res = pow(x,y); printf("Déroulement normal --> %lf ** %lf: %le errno=%d\n", x,y, res, errno); errno=0; x=10; y=-300; res=pow(x,y); printf("Pas de débordement --> %lf ** %lf: %le, errno=%d\n", x, y, res, errno); /* Deuxième cas, errno est modifiée par l'appel à pow() */ errno=0; x=10; y=1000; res=pow(x,y); printf("Débordement --> %lf ** %lf: %lf, errno=%d\n", x, y, res, errno); errno=0; x=10; y=-900; res=pow(x,y); printf("Débordement --> %lf ** %lf: %le, errno=%d\n", x, y, res, errno); /* Troisième cas, errno n'est pas modifiée par l'appel à pow() */ errno=0; x=0; y=-1000; res=pow(0,y); printf("x nul, exposant entier négatif --> %lf ** %lf: %lf, errno=%d\n", x, y, res, errno); /* Quatrième cas, errno est modifiée par l'appel à pow() */ errno=0; x=-30; y=1.5; res=pow(x,y); printf("Erreur (x négatif, y non entier) --> %lf ** %lf: %lf, errno=%d\n", x, y, res, errno); printf("\nRemarques sur la précision\n"); /* ************************** */ y=52; res=pow(2,y); res1=res+1; printf("'res+1' est différent de res --> res=2**%lf; (res+1)-res=%le\n", y, res1-res); res=pow(2,y+1); res1=res+1; printf("'res+1' est identique à res --> res=2**%lf; (res+1)-res=%le\n", y+1, res1-res); y=-52; res=pow(2,y); res1=res+1; printf("'res+1' est différent de 1 --> res=2**%lf; (res+1)-1=%le\n", y, res1-1); res=pow(2,y-1); res1=res+1; printf("'res+1' est identique à 1 --> res=2**%lf; (res+1)-1=%le\n", y-1, res1-1); }

   Table des matières         Index