Végtelen nem szakaszos tizedes törtből meg lehet-e állapítani, hogy az mondjuk négyzetgyök 2 Turbo Pascalban?

> Ha Turbo Pascalban beírok egy tizedes törtet a négyzetgyök kettő számjegyeivel, akkor azt a programnyelv véges tizedes törtként kezeli.

Ez a számábrázolás jellegzetessége. A Pascal nyelv – ahogy kvázi majdnem mindegyik programnyelv és maga a processzor is – a nem egész számokat lebegőpontos számként ábrázolja. Gyakorlatilag így:

szám = (-1)^előjel * mantissza * 2^kitevő

Mind a mantissza, mind a kitevő vége számú bitből áll, így számolni csak véges pontossággal és véges intervallumban tud.

(Lásd még: Google: Lebegőpontos számábrázolás)

Így természetesen véges számú biten csak véges tizedes törtet lehet ábrázolni, így mindig van valamekkora pontatlanság. A dupla pontosságú lebegőpontos típus (double) esetén tízes számrendszerbeli alakban kb. 15–16 értékes számjegyig pontos a számábrázolás. Ez a legtöbb esetben bőven elegendő. Gondolj bele, hogy a Nap–Föld távolság kb. 150 millió km. Egy Nap–Föld távolságú négyzet átlójának a számítása ezzel a számábrázolással is kb. mikrométer pontosságú. Ennyire pontos számításra nincs szükség, lévén a számítások alapjául szolgáló adatok mérési pontatlansága általában nagyobb ennél.

De ha valamilyen matematikailag indokolt ok miatt ez a pontosság nem elegendő, vannak olyan függvénykönyvtárak, unitok, amik ennél nagyobb pontossággal képesek számolni (nyilván jóval-jóval lassabban), a pontosságnak csak a memória mérete szab gátat. De ezek is fixpontos vagy lebegőpontos számábrázolást használnak, így természetesen nem lehet tetszőleges pontossággal tárolni a √2 értékét.

Aztán még létez(het)nek – Pascallal ezer éve nem foglalkoztam, nem tudom, hogy ott mi a helyzet – olyan függvénykönyvtárak, amik bizonyos típusú matematikai kifejezéseken képesek teljes pontosságú számolást végezni, törteket lehet velük összeadni, szorozni, esetleg hatványokat is képesek pontosan kezelni. De mikor ezt tizedes törtre kell alakítani, nyilván ezek is véges pontossággal tudják ezt megtenni.

~ ~ ~

Szóval gyakorlatilag így tudod egy számról eldönteni, hogy √2-e (az adott pontosságon belül):

program …;

var

szam: double;

begin

… szám bekérése, beolvasása, stb…

if abs(szam*szam-2) < 0.0000000001 then

writeln('A szám egyenlő gyök kettővel.')

else

writeln('A szám nem egyenlő gyök kettővel.');

…

Ha ennél pontosabb számításra van szükséged, akkor vázold fel a megoldandó probléma mibenlétét.

var

egyik: double;

masik: double;

begin

…

if abs(egyik-masik) < 0.00000000001 then writeln('a két szám (közel) egyenlő');

Persze ebben az esetben az egyik és a masik változóban lévő szám is eleve pontatlan.

√3 esetén még viszonylag egyszerűbb a dolog:

if abs(szam*szam - 3) < 0.00000000001 then writeln('A szám gyök három');

Még általánosabban:

kozelito_negyzet = round(szam*szam);

if abs(szam*szam - kozelito_negyzet) < 0.00000000001 then writeln('A szám gyök ' + kozelito_negyzet);

> A köbgyök 3-mal mi a helyzet?

Ne vedd sértésnek, de ha a fentiek alapján ez továbbra is kérdés számodra, akkor lehet érdemes újragondolni, hogy mennyire érdemes programozást tanulni.

Az egyik megoldás:

if abs(szam - 1.4422495703074083823) < 0.00000000000001 then writeln('A szám egyenlő köbgyök hárommal.');

(Ugye ∛3 = 1,4422495703074083823…)

A másik megoldási módnak három változata:

if abs(szam*szam*szam - 3) < 0.00000000000001 then writeln('A szám egyenlő köbgyök hárommal.');

if abs(power(szam, 3) - 3) < 0.00000000000001 then writeln('A szám egyenlő köbgyök hárommal.');

if abs(szam - power(3, 1/3)) < 0.00000000000001 then writeln('A szám egyenlő köbgyök hárommal.');

> n. gyök 3-mal?

Ha n ismert, akkor egyszerű:

if abs(power(szam, n) - 3) < 0.00000000000001 then writeln('A szám egyenlő köbgyök hárommal.');

if abs(szam - power(3, 1/n)) < 0.00000000000001 then writeln('A szám egyenlő köbgyök hárommal.');

Ha n nem ismert, akkor kérdés, hogy egésznek kell-e lennie. (Bár n-nel olyan ismeretlent, változót szokás jelölni, ami természetes szám, de nem kötelező.) Illetve van-e egy olyan intervallum, amibe n-nek esnie kellene. Ebben az esetben egy ciklussal végig lehet menni n lehetséges értékein.

Amúgy ha nem ismert és bármennyi lehet, akkor belesünk abba az elvi problémába, hogy bármelyik valós számhoz tartozik egy egész számnak egy egész gyöke, ami adott pontosságon belül egyenlő vele.

Pl. ott a π, ami mondjuk 6 értékes számjegy pontossággal 3,14159. Tudok találni olyan egész számot, aminek az egész gyöke ezzel legalább 6 értékes számjegy pontossággal egyenlő. Pl.:

(Az alábbiakat a SpeedCrunch nevű számológép szoftverrel számoltam ki, 50 számjegyes pontosságot beállítva.)

93648^(1/10) = 3,14159249432267375664895824869699082503450369935794

93648^(1/10) - π = -0,00000015926711948181368513458251205916266570001717

Vagy:

28658146^(1/15) = 3,14159265381351191918337643234460768072471949898126

28658146^(1/15) - π = 0,00000000022371868072073304906510479652755009960615

Vagy:

8431341691876^(1/26) = 3,14159265358979027096776549922332491763131465269745

8431341691876^(1/26) - π = -0,00000000000000296749487788405617796656585474667766

~ ~ ~

Illetve itt már szerintem joggal merül fel az a kérdés, hogy tulajdonképpen mit akarsz csinálni? Mit akarsz leprogramozni? Honnan jön az input? Mit is akarsz pontosan az inputról eldönteni?