Informatika 2023-24: Pi zenbakia: Wallis (1655)

John Wallis, (Ashford, 1616 - Oxford, 1703) ingeles matematikaria zen Cambridgen egin zituen ikasketak.

1640an apaiz egin zen, eta 1649an Oxfordeko geometria-irakasle izendatu zuten. Zirkuluaren koadraturari buruzko azterketak egin zituen. Berak asmatua da infinitua irudikatzeko sinboloa (∞). Arithmetica infinitorum, Wallisen lanik garrantzitsuena, 1656an argitaratu zen. Tratatu horretan Descartesen eta Cavalieriren analisi-metodoak sistematizatu eta hedatu egin zituen.

Wallisek ekarpen esanguratsuak egin zizkion trigonometriari, kalkuluari, geometriari, eta serie infinituen analisiari. Opera Mathematica I (1695) lanean, frakzio jarraitua terminoa sartu zuen.

Bestalde, π konstantearen hamartarrak kalkulatzeko segida bat proposatu zuen Wallisek 1655ean, Wallisen biderkadura deritzona, oso segida estetikoa da baina ez da eraginkorra hamartarrak lortzean iterazio asko behar dituelako. Wallisen biderkadura hainbat biderkagaiz osaturik dago eta biderkagaiak bikoteka antolatzen dira.

Hau da Wallisen biderkadura segida π konstantearen hamartarrak kalkulatzeko:

$\prod _{n=1}^{\infty }\left({\frac {2n}{2n-1}}\cdot {\frac {2n}{2n+1}}\right)={\frac {2}{1}}\cdot {\frac {2}{3}}\cdot {\frac {4}{3}}\cdot {\frac {4}{5}}\cdot {\frac {6}{5}}\cdot {\frac {6}{7}}\cdot {\frac {8}{7}}\cdot {\frac {8}{9}}\cdots ={\frac {\pi }{2}}$

Jarraian ematen diren hiru programetan ikusiko da π konstantearen hamartarrak kalkulatzeko, Wallisen biderkadurak konputazio-karga handia behar duela. Baina, argi utz dezagun formula hori aurkitu izana meritu handia dela, nahiz eta praktikan ez den baliagarria π zenbakiaren hamartarrak zehaztasunez kalkulatzeko.

Jarraian π zenbakiaren hamartarrak kalkulatzen dituen Wallisen biderkadura segidaren hiru adibide-programa erakutsiko dira, baina lehenik segidaren ezaugarriak azter ditzagun.

Ikusten denez, segidaren biderkagaiek ondoko hauek betetzen dituzte:

Biderkagaiak binaka antolaturik datoz
Bikote bakoitzean, jarraian doazen hiru kopuru agertzen dira:

Lehen bikotean, 1-2-3
Bigarren bikotean, 3-4-5
Hirugarren bikotean, 5-6-7
Laugarren bikotean, 7-8-9
Bosgarren bikotean, 9-10-11
...

Bikoteen balioak kalkulatuz, zatidura gero eta hurbilago dago 1.0 zenbakitik:

Lehen bikotearen emaitza 4/3=1.333 da
Bigarren bikotearen emaitza 16/15=1.066 da
Hirugarren bikotearen emaitza 36/35=1.028 da
Laugarren bikotearen emaitza 64/63=1.016 da
Bosgarren bikotearen emaitza 100/99=1.010 da
...

Bikote baten balioa kalkulua esleipen honetan erakusten da, non iKont aldagaia goiko irudiaren zenbaki urdina litzatekeen:

rBikotea := ((iKont+1)/(iKont))*((iKont+1)/(iKont+2));

Lehen bikotean, iKont=1 eta rBikotea=4/3
Bigarren bikotean, iKont=3 eta rBikotea=16/15
Hirugarren bikotean, iKont=5 eta rBikotea=36/35
Laugarren bikotean, iKont=7 eta rBikotea=64/63
Bosgarren bikotean, iKont=9 eta rBikotea=100/99
...

Demagun biderkagaien kopurua ezaguna dela programan. Adibidez, teklatuaren bitartez bikoteen iZenbat kopurua irakurtzen delako (5 eta 500 arteko balio osoa). Hauxe izan daiteke lehen bertsioaren programa bat:

{------------------------------------------------------------------------------
  PI kalkulatzeko, bikote kopurua ezaguna da (5 eta 500 artekoa):
                        1         3         5         7          9
    PI/2 = rPIerdi = 2/1*2/3 * 4/3*4/5 * 6/5*6/7 * 8/7*8/9 * 10/9*10/11 * ...
    PI/2 = rPIerdi =   4/3   *  16/15  *  36/35  *  64/63  *  100/99    * ...
    PI/2 = rPIerdi =  1.333  *  1.066  *  1.028  *  1.016  *   1.010    * ...
------------------------------------------------------------------------------}
program WallisBiderkadura_1;
uses
   crt;
 
{ ------------------------------Programa Nagusia------------------------------}
var
   rPIerdi, rBikotea: real;
   iZenbat, iKont: integer;
begin
   clrscr;
   repeat
      write('Zenbat bikote hartuko dira PI kalkulatzeko? Adibidez 5 eta 500 artekoa: ');
      readln(iZenbat);
   if (iZenbat < 5) or (iZenbat > 500) then
      writeln('Bikoteen kopurua 5 eta 500 artekoa izan dadila.');
   until (iZenbat >= 5) and (iZenbat <= 500);
   writeln;
    
   iKont := 1;
   rBikotea := ((iKont+1)/(iKont))*((iKont+1)/(iKont+2));
   rPIerdi := rBikotea;
   writeln('iKont=', iKont:3, 'rBikotea=':18, rBikotea:0:8, 'PI=':12, rPIerdi:0:8);
   writeln('-------------------------------------------------------------------------------');
    
   for iKont:=2 to iZenbat*2 do
   begin
      if iKont mod 2 = 1 then
      begin
         rBikotea := ((iKont+1)/(iKont))*((iKont+1)/(iKont+2));
         rPIerdi := rPIerdi*rBikotea;
         writeln('iKont=', iKont:3, 'rBikotea=':18, rBikotea:0:8, 'PI=':12, 2*rPIerdi:0:6);
      end;
   end;
    
   writeln;
   writeln(iZenbat:10, ' iterazio ondoren: PI=':12, 2*rPIerdi:0:6);
   writeln;
 
   repeat until keypressed;
end.

WallisBiderkadura_1.pas programa birritan exekutatzean lor daitezkeen pantaila-ireteerak:

iZenbat datuak 16 balio du eta π konstantearen hamartarrak 3.094359 dira

iZenbat datuak 500 balio du eta π konstantearen hamartarrak 3.140024 dira

Demagun biderkagaien kopurua ezezaguna dela programan. Prozesu errepikakorretik irteteko daukagun datua da azken bikotearen balioa 1.0 konstantetik oso hurbil dagoela. Beraz, rEpsilon hurbiltasunaren maila teklatuz emanik (0.0000010 baino handiagoa adibidez), iterazio batean rBikotea-1.0 adierazpenaren balioa rEpsilon baino txikiagoa bihurtzen bada prozesu errepikakorra eteteko da.

Hauxe izan daiteke bigarren bertsioaren programa bat while-do egituraz kodeturik (ariketa hau programatu daiteke ere repeat-until egitura erabiliz):

{------------------------------------------------------------------------------
  PI kalkulatzeko, azken bikotea 1.0-tik oso oso hurbil izan dadila:
                        1         3         5         7          9
    PI/2 = rPIerdi = 2/1*2/3 * 4/3*4/5 * 6/5*6/7 * 8/7*8/9 * 10/9*10/11 * ...
    PI/2 = rPIerdi =   4/3   *  16/15  *  36/35  *  64/63  *  100/99    * ...
    PI/2 = rPIerdi =  1.333  *  1.066  *  1.028  *  1.016  *   1.010    * ...
------------------------------------------------------------------------------}
program WallisBiderkadura_2;
uses
   crt;
 
{ ------------------------------Programa Nagusia------------------------------}
var
   rPIerdi, rBikotea, rEpsilon: real;
   iKont: integer;
begin
   clrscr;
   repeat
      write('Eman azken bikotearen hurbiltasuna 1.0-tik (adibidez: 0.0000011): ');
      readln(rEpsilon);
   if rEpsilon <= 0.0000010 then
      writeln('Azken bikotea 1.0-tik hurbil dago, diferentzia 0.0000010 baino handiagoa.');
   until rEpsilon > 0.0000010;
   writeln;
    
   iKont := 1;
   rBikotea := ((iKont+1)/(iKont))*((iKont+1)/(iKont+2));
   rPIerdi := rBikotea;
   writeln('iKont=', iKont:3, 'rBikotea=':13, rBikotea:0:8, 'PI=':8, rPIerdi:0:8, 'rEpsilon=':15, rEpsilon:0:7);
   writeln('-------------------------------------------------------------------------------');
    
   while rBikotea - 1.0 > rEpsilon do
   begin
      iKont := iKont + 2;
      rBikotea := ((iKont+1)/(iKont))*((iKont+1)/(iKont+2));
      rPIerdi := rPIerdi*rBikotea;
      writeln('iKont=', iKont:3, 'rBikotea=':13, rBikotea:0:8, '(rBikotea-1.0)=':19, (rBikotea - 1.0):0:8, 'PI=':8, 2*rPIerdi:0:6);
   end;
    
   writeln;
   writeln((iKont div 2):10, ' iterazio ondoren:        iKont=', iKont:3, 'PI=':12, 2*rPIerdi:0:6);
   writeln;
 
   repeat until keypressed;
end.

WallisBiderkadura_2.pas programa bi aldiz exekutatzean lor daitezkeen emaitzak:

rEpsilon datuak 0.001 balio du eta π konstantearen hamartarrak 3.094359 dira

rEpsilon datuak 0.0000011 balio du eta π konstantearen hamartarrak 3.139948 dira

Demagun biderkagaien kopurua ezezaguna dela programan. Prozesu errepikakorretik irteteko daukagun datua da, azken bi bikoteen balioen arteko diferentzia txikia dela (0.00000010 baino handiagoa adibidez), iterazio batean rOraingoBikotea aldagaiari balioa ematen zaio eta aurreko iterazioaren rAurrekoBikotea balioarekin kenketa egiten da, eta kendura rEpsilon baino txikiagoa bihurtzen bada prozesu errepikakorra eteteko da.

Hauxe izan daiteke hirugarren bertsioaren programa bat repeat-until egituraz kodeturik (while-do egitura erabil daiteke ere ariketa hau programatzeko):

{------------------------------------------------------------------------------
  PI kalkulatzeko, bi bikoteen arteko diferentzia txikia izan dadila:
                        1         3         5         7          9
    PI/2 = rPIerdi = 2/1*2/3 * 4/3*4/5 * 6/5*6/7 * 8/7*8/9 * 10/9*10/11 * ...
    PI/2 = rPIerdi =   4/3   *  16/15  *  36/35  *  64/63  *  100/99    * ...
    PI/2 = rPIerdi =  1.333  *  1.066  *  1.028  *  1.016  *   1.010    * ...
------------------------------------------------------------------------------}
program WallisBiderkadura_3;
uses
   crt;
 
{ ------------------------------Programa Nagusia------------------------------}
var
   rPIerdi, rAurrekoBikotea, rOraingoBikotea, rEpsilon: real;
   iKont: integer;
begin
   clrscr;
   repeat
      write('Eman bi bikoteen arteko diferentziaren muga (adibidez: 0.000005): ');
      readln(rEpsilon);
      if rEpsilon <= 0.00000010 then
         writeln('Bi bikoteen arteko diferentzia 0.00000010 baino handiagoa izan dadila.');
   until rEpsilon > 0.00000010;
   writeln;
    
   iKont := 1;
   rOraingoBikotea := ((iKont+1)/(iKont))*((iKont+1)/(iKont+2));
   rPIerdi := rOraingoBikotea;
   writeln('iKont=', iKont:3, 'Orain=':12, rOraingoBikotea:0:8, 'PI=':10, rPIerdi:0:8, 'rEpsilon=':15, rEpsilon:0:7);
   writeln('-------------------------------------------------------------------------------');
    
   repeat
      iKont := iKont + 2;
      rAurrekoBikotea := rOraingoBikotea;
      rOraingoBikotea := ((iKont+1)/(iKont))*((iKont+1)/(iKont+2));
      rPIerdi := rPIerdi*rOraingoBikotea;
      writeln('iKont=', iKont:3, 'Aurre=':9, rAurrekoBikotea:0:8, 'Orain=':9, rOraingoBikotea:0:8, 'Dif.=':8, (rAurrekoBikotea - rOraingoBikotea):0:8, 'PI=':6, 2*rPIerdi:0:6);
   until (rAurrekoBikotea - rOraingoBikotea) < rEpsilon;
    
   writeln;
   writeln((iKont div 2):10, ' iterazio ondoren:        iKont=', iKont:3, 'PI=':12, 2*rPIerdi:0:6);
   writeln;
 
   repeat until keypressed;
end.