(*************************************************)
(*                 Hugo Eti‚vant                 *)
(*     http://www.multimania.com/cyberzoide/     *)
(*       e-mail : cyberzoide@multimania.com      *)
(*       (pour une aide en Turbo Pascal 7.0)     *)
(*************************************************)
(*                                               *)
(*    Programme d'‚valuation de la rapidit‚      *)
(*    d'algorithmes permettant d'‚lever un       *)
(*    nombre r‚el … une puissance entiŠre.       *)
(*                                               *)
(*************************************************)

program exposant;

uses dos;

type time= record
           heure,minute,seconde,centieme:byte;
           end;

{enregistre l'heure systŠme instantan‚e}
procedure PickTime(var temps:time);
var h,m,s,hund:word;
begin
  GetTime(h,m,s,hund);
  with temps do
       begin
       heure:=h;
       minute:=m;
       seconde:=s;
       centieme:=hund;
       end;
end;

{ calcul la diff‚rence de deux horaires en centiŠmes de secondes}
function Delai(x,y:time):word;
var temps:time;
begin
with temps do
     begin
     heure:=y.heure-x.heure;
     minute:=y.minute-x.minute;
     seconde:=y.seconde-x.seconde;
     centieme:=y.centieme-x.centieme;
Delai:=centieme+seconde*100+minute*60*100+heure*60*60*100;
     end;
end;

{  X : nombre r‚el,
   N : exposant entier  }

(************************************************************************)
(*  EXP_BOUCLE : fonction exposant grace … une boucle int‚rative.       *)
(*  Permet d'‚lever un nombre r‚el ou entier … une puissance entiŠre    *)
(************************************************************************)
function exp_boucle(x:real; n:integer):real;
var i:integer;
    a:real;
begin
a:=1;
for i:=1 to n do a:=a*x;
exp_boucle:=a;
end;

(************************************************************************)
(*  EXP_LOG : fonction exposant grace … l'usage de l'exponentielle et   *)
(*  du logarythme n‚p‚rien. Permet d'‚lever un nombre r‚el ou entier …  *)
(*  une puissance r‚elle ou entiŠre.                                    *)
(************************************************************************)
function exp_log(x:real; n:integer):real;
begin
exp_log:=exp(n*ln(x));
end;

var x,y:real;
    debut,fin:time;
    i:word;

BEGIN
{ Partie A : calcul de la rapidit‚ de la fonction EXP_BOUCLE }
PickTime(debut);
for i:=1 to high(i) do x:=exp_boucle(i,6);
PickTime(fin);
writeln('EXP_BOUCLE = ':15,Delai(debut,fin):5,' centiŠmes de secondes.');

{ Partie B : calcul de la rapidit‚ de la fonction EXP_LOG }
PickTime(debut);
for i:=1 to high(i) do x:=exp_log(i,6);
PickTime(fin);
writeln('EXP_LOG = ':15,Delai(debut,fin):5,' centiŠmes de secondes.');
END.

ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿
³  Constatation : EXP_LOG est beaucoup plus longue que EXP_BOUCLE.         ³
³  Cela vient du fait de les fonctions math‚matiques exponetielle et       ³
³  logarythme sont cod‚es dans le microprocesseur sous la forme de         ³
³  "d‚velloppements limit‚s" qui consistes en une suite trŠs grande de     ³
³  polyn“mes en T (si on fait exp(T) ou ln(T)) de coeficient une fraction  ³
³  ayant pour d‚nominateur une factorielle. Ouf!                           ³
³                                                                          ³
³  Par exemple, exp(T)="somme pour i allant de 0 … n de [(T^i)/(i!)]" avec ³
³  n un nombre suffisamment grand pour que le dernier terme de la s‚rie    ³
³  soit quasiment n‚gligeable vis-…-vis du r‚sultat final de la somme.     ³
³                                                                          ³
³  De plus, les nombres r‚els sont plus complexes … manipuler que les      ³
³  entiers car il y a la mantisse, la virgule flottante, l'exposant et la  ³
³  taille en m‚moire en est beaucoup plus importante. Cela explique que    ³
³  mˆme cod‚es directement sur le hardware (la puce en silicium) ces deux  ³
³  2 fonctions "exp" et "ln" sont trŠs gourmandes en ressources systŠmes.  ³
³                                                                          ³
³  Conclusion : dans un programme o— les exposants sont des nombres        ³
³  entiers, il est recommend‚ d'utiliser la fonction EXP_BOUCLE surtout    ³
³  si elle doit ˆtre utilis‚e au sein d'une boucle. Cela ‚vitera des       ³
³  temps de calculs inutiles et m‚moriaux.                                 ³
³                                                            Hugo ETIEVANT ³
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ